Wire Sysio Wire Sysion 1.0.0
Loading...
Searching...
No Matches
const_tests.cpp
Go to the documentation of this file.
1// Generated by spec_test_generator. DO NOT MODIFY THIS FILE.
2
3#include <algorithm>
4#include <vector>
5#include <iostream>
6#include <iterator>
7#include <cmath>
8#include <cstdlib>
9#include <catch2/catch.hpp>
10#include <utils.hpp>
11#include <wasm_config.hpp>
12#include <sysio/vm/backend.hpp>
13
14using namespace sysio;
15using namespace sysio::vm;
16extern wasm_allocator wa;
17
18BACKEND_TEST_CASE( "Testing wasm <const_0_wasm>", "[const_0_wasm_tests]" ) {
19 using backend_t = backend<standalone_function_t, TestType>;
20 auto code = read_wasm( std::string(wasm_directory) + "const.0.wasm");
21 backend_t bkend( code, &wa );
22
23}
24
25BACKEND_TEST_CASE( "Testing wasm <const_1_wasm>", "[const_1_wasm_tests]" ) {
26 using backend_t = backend<standalone_function_t, TestType>;
27 auto code = read_wasm( std::string(wasm_directory) + "const.1.wasm");
28 backend_t bkend( code, &wa );
29
30}
31
32BACKEND_TEST_CASE( "Testing wasm <const_100_wasm>", "[const_100_wasm_tests]" ) {
33 using backend_t = backend<standalone_function_t, TestType>;
34 auto code = read_wasm( std::string(wasm_directory) + "const.100.wasm");
35 backend_t bkend( code, &wa );
36
37 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
38}
39
40BACKEND_TEST_CASE( "Testing wasm <const_101_wasm>", "[const_101_wasm_tests]" ) {
41 using backend_t = backend<standalone_function_t, TestType>;
42 auto code = read_wasm( std::string(wasm_directory) + "const.101.wasm");
43 backend_t bkend( code, &wa );
44
45 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
46}
47
48BACKEND_TEST_CASE( "Testing wasm <const_102_wasm>", "[const_102_wasm_tests]" ) {
49 using backend_t = backend<standalone_function_t, TestType>;
50 auto code = read_wasm( std::string(wasm_directory) + "const.102.wasm");
51 backend_t bkend( code, &wa );
52
53 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
54}
55
56BACKEND_TEST_CASE( "Testing wasm <const_103_wasm>", "[const_103_wasm_tests]" ) {
57 using backend_t = backend<standalone_function_t, TestType>;
58 auto code = read_wasm( std::string(wasm_directory) + "const.103.wasm");
59 backend_t bkend( code, &wa );
60
61 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
62}
63
64BACKEND_TEST_CASE( "Testing wasm <const_104_wasm>", "[const_104_wasm_tests]" ) {
65 using backend_t = backend<standalone_function_t, TestType>;
66 auto code = read_wasm( std::string(wasm_directory) + "const.104.wasm");
67 backend_t bkend( code, &wa );
68
69 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
70}
71
72BACKEND_TEST_CASE( "Testing wasm <const_105_wasm>", "[const_105_wasm_tests]" ) {
73 using backend_t = backend<standalone_function_t, TestType>;
74 auto code = read_wasm( std::string(wasm_directory) + "const.105.wasm");
75 backend_t bkend( code, &wa );
76
77 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
78}
79
80BACKEND_TEST_CASE( "Testing wasm <const_106_wasm>", "[const_106_wasm_tests]" ) {
81 using backend_t = backend<standalone_function_t, TestType>;
82 auto code = read_wasm( std::string(wasm_directory) + "const.106.wasm");
83 backend_t bkend( code, &wa );
84
85 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
86}
87
88BACKEND_TEST_CASE( "Testing wasm <const_107_wasm>", "[const_107_wasm_tests]" ) {
89 using backend_t = backend<standalone_function_t, TestType>;
90 auto code = read_wasm( std::string(wasm_directory) + "const.107.wasm");
91 backend_t bkend( code, &wa );
92
93 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
94}
95
96BACKEND_TEST_CASE( "Testing wasm <const_108_wasm>", "[const_108_wasm_tests]" ) {
97 using backend_t = backend<standalone_function_t, TestType>;
98 auto code = read_wasm( std::string(wasm_directory) + "const.108.wasm");
99 backend_t bkend( code, &wa );
100
101 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
102}
103
104BACKEND_TEST_CASE( "Testing wasm <const_109_wasm>", "[const_109_wasm_tests]" ) {
105 using backend_t = backend<standalone_function_t, TestType>;
106 auto code = read_wasm( std::string(wasm_directory) + "const.109.wasm");
107 backend_t bkend( code, &wa );
108
109 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
110}
111
112BACKEND_TEST_CASE( "Testing wasm <const_110_wasm>", "[const_110_wasm_tests]" ) {
113 using backend_t = backend<standalone_function_t, TestType>;
114 auto code = read_wasm( std::string(wasm_directory) + "const.110.wasm");
115 backend_t bkend( code, &wa );
116
117 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
118}
119
120BACKEND_TEST_CASE( "Testing wasm <const_111_wasm>", "[const_111_wasm_tests]" ) {
121 using backend_t = backend<standalone_function_t, TestType>;
122 auto code = read_wasm( std::string(wasm_directory) + "const.111.wasm");
123 backend_t bkend( code, &wa );
124
125 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
126}
127
128BACKEND_TEST_CASE( "Testing wasm <const_112_wasm>", "[const_112_wasm_tests]" ) {
129 using backend_t = backend<standalone_function_t, TestType>;
130 auto code = read_wasm( std::string(wasm_directory) + "const.112.wasm");
131 backend_t bkend( code, &wa );
132
133 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
134}
135
136BACKEND_TEST_CASE( "Testing wasm <const_113_wasm>", "[const_113_wasm_tests]" ) {
137 using backend_t = backend<standalone_function_t, TestType>;
138 auto code = read_wasm( std::string(wasm_directory) + "const.113.wasm");
139 backend_t bkend( code, &wa );
140
141 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
142}
143
144BACKEND_TEST_CASE( "Testing wasm <const_114_wasm>", "[const_114_wasm_tests]" ) {
145 using backend_t = backend<standalone_function_t, TestType>;
146 auto code = read_wasm( std::string(wasm_directory) + "const.114.wasm");
147 backend_t bkend( code, &wa );
148
149 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
150}
151
152BACKEND_TEST_CASE( "Testing wasm <const_115_wasm>", "[const_115_wasm_tests]" ) {
153 using backend_t = backend<standalone_function_t, TestType>;
154 auto code = read_wasm( std::string(wasm_directory) + "const.115.wasm");
155 backend_t bkend( code, &wa );
156
157 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
158}
159
160BACKEND_TEST_CASE( "Testing wasm <const_116_wasm>", "[const_116_wasm_tests]" ) {
161 using backend_t = backend<standalone_function_t, TestType>;
162 auto code = read_wasm( std::string(wasm_directory) + "const.116.wasm");
163 backend_t bkend( code, &wa );
164
165 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
166}
167
168BACKEND_TEST_CASE( "Testing wasm <const_117_wasm>", "[const_117_wasm_tests]" ) {
169 using backend_t = backend<standalone_function_t, TestType>;
170 auto code = read_wasm( std::string(wasm_directory) + "const.117.wasm");
171 backend_t bkend( code, &wa );
172
173 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
174}
175
176BACKEND_TEST_CASE( "Testing wasm <const_118_wasm>", "[const_118_wasm_tests]" ) {
177 using backend_t = backend<standalone_function_t, TestType>;
178 auto code = read_wasm( std::string(wasm_directory) + "const.118.wasm");
179 backend_t bkend( code, &wa );
180
181 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922819));
182}
183
184BACKEND_TEST_CASE( "Testing wasm <const_119_wasm>", "[const_119_wasm_tests]" ) {
185 using backend_t = backend<standalone_function_t, TestType>;
186 auto code = read_wasm( std::string(wasm_directory) + "const.119.wasm");
187 backend_t bkend( code, &wa );
188
189 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406467));
190}
191
192BACKEND_TEST_CASE( "Testing wasm <const_12_wasm>", "[const_12_wasm_tests]" ) {
193 using backend_t = backend<standalone_function_t, TestType>;
194 auto code = read_wasm( std::string(wasm_directory) + "const.12.wasm");
195 backend_t bkend( code, &wa );
196
197}
198
199BACKEND_TEST_CASE( "Testing wasm <const_120_wasm>", "[const_120_wasm_tests]" ) {
200 using backend_t = backend<standalone_function_t, TestType>;
201 auto code = read_wasm( std::string(wasm_directory) + "const.120.wasm");
202 backend_t bkend( code, &wa );
203
204 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922816));
205}
206
207BACKEND_TEST_CASE( "Testing wasm <const_121_wasm>", "[const_121_wasm_tests]" ) {
208 using backend_t = backend<standalone_function_t, TestType>;
209 auto code = read_wasm( std::string(wasm_directory) + "const.121.wasm");
210 backend_t bkend( code, &wa );
211
212 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406464));
213}
214
215BACKEND_TEST_CASE( "Testing wasm <const_122_wasm>", "[const_122_wasm_tests]" ) {
216 using backend_t = backend<standalone_function_t, TestType>;
217 auto code = read_wasm( std::string(wasm_directory) + "const.122.wasm");
218 backend_t bkend( code, &wa );
219
220 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
221}
222
223BACKEND_TEST_CASE( "Testing wasm <const_123_wasm>", "[const_123_wasm_tests]" ) {
224 using backend_t = backend<standalone_function_t, TestType>;
225 auto code = read_wasm( std::string(wasm_directory) + "const.123.wasm");
226 backend_t bkend( code, &wa );
227
228 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
229}
230
231BACKEND_TEST_CASE( "Testing wasm <const_124_wasm>", "[const_124_wasm_tests]" ) {
232 using backend_t = backend<standalone_function_t, TestType>;
233 auto code = read_wasm( std::string(wasm_directory) + "const.124.wasm");
234 backend_t bkend( code, &wa );
235
236 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
237}
238
239BACKEND_TEST_CASE( "Testing wasm <const_125_wasm>", "[const_125_wasm_tests]" ) {
240 using backend_t = backend<standalone_function_t, TestType>;
241 auto code = read_wasm( std::string(wasm_directory) + "const.125.wasm");
242 backend_t bkend( code, &wa );
243
244 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
245}
246
247BACKEND_TEST_CASE( "Testing wasm <const_126_wasm>", "[const_126_wasm_tests]" ) {
248 using backend_t = backend<standalone_function_t, TestType>;
249 auto code = read_wasm( std::string(wasm_directory) + "const.126.wasm");
250 backend_t bkend( code, &wa );
251
252 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
253}
254
255BACKEND_TEST_CASE( "Testing wasm <const_127_wasm>", "[const_127_wasm_tests]" ) {
256 using backend_t = backend<standalone_function_t, TestType>;
257 auto code = read_wasm( std::string(wasm_directory) + "const.127.wasm");
258 backend_t bkend( code, &wa );
259
260 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
261}
262
263BACKEND_TEST_CASE( "Testing wasm <const_128_wasm>", "[const_128_wasm_tests]" ) {
264 using backend_t = backend<standalone_function_t, TestType>;
265 auto code = read_wasm( std::string(wasm_directory) + "const.128.wasm");
266 backend_t bkend( code, &wa );
267
268 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783616));
269}
270
271BACKEND_TEST_CASE( "Testing wasm <const_129_wasm>", "[const_129_wasm_tests]" ) {
272 using backend_t = backend<standalone_function_t, TestType>;
273 auto code = read_wasm( std::string(wasm_directory) + "const.129.wasm");
274 backend_t bkend( code, &wa );
275
276 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267264));
277}
278
279BACKEND_TEST_CASE( "Testing wasm <const_13_wasm>", "[const_13_wasm_tests]" ) {
280 using backend_t = backend<standalone_function_t, TestType>;
281 auto code = read_wasm( std::string(wasm_directory) + "const.13.wasm");
282 backend_t bkend( code, &wa );
283
284}
285
286BACKEND_TEST_CASE( "Testing wasm <const_130_wasm>", "[const_130_wasm_tests]" ) {
287 using backend_t = backend<standalone_function_t, TestType>;
288 auto code = read_wasm( std::string(wasm_directory) + "const.130.wasm");
289 backend_t bkend( code, &wa );
290
291 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
292}
293
294BACKEND_TEST_CASE( "Testing wasm <const_131_wasm>", "[const_131_wasm_tests]" ) {
295 using backend_t = backend<standalone_function_t, TestType>;
296 auto code = read_wasm( std::string(wasm_directory) + "const.131.wasm");
297 backend_t bkend( code, &wa );
298
299 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
300}
301
302BACKEND_TEST_CASE( "Testing wasm <const_132_wasm>", "[const_132_wasm_tests]" ) {
303 using backend_t = backend<standalone_function_t, TestType>;
304 auto code = read_wasm( std::string(wasm_directory) + "const.132.wasm");
305 backend_t bkend( code, &wa );
306
307 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
308}
309
310BACKEND_TEST_CASE( "Testing wasm <const_133_wasm>", "[const_133_wasm_tests]" ) {
311 using backend_t = backend<standalone_function_t, TestType>;
312 auto code = read_wasm( std::string(wasm_directory) + "const.133.wasm");
313 backend_t bkend( code, &wa );
314
315 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
316}
317
318BACKEND_TEST_CASE( "Testing wasm <const_134_wasm>", "[const_134_wasm_tests]" ) {
319 using backend_t = backend<standalone_function_t, TestType>;
320 auto code = read_wasm( std::string(wasm_directory) + "const.134.wasm");
321 backend_t bkend( code, &wa );
322
323 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
324}
325
326BACKEND_TEST_CASE( "Testing wasm <const_135_wasm>", "[const_135_wasm_tests]" ) {
327 using backend_t = backend<standalone_function_t, TestType>;
328 auto code = read_wasm( std::string(wasm_directory) + "const.135.wasm");
329 backend_t bkend( code, &wa );
330
331 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
332}
333
334BACKEND_TEST_CASE( "Testing wasm <const_136_wasm>", "[const_136_wasm_tests]" ) {
335 using backend_t = backend<standalone_function_t, TestType>;
336 auto code = read_wasm( std::string(wasm_directory) + "const.136.wasm");
337 backend_t bkend( code, &wa );
338
339 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
340}
341
342BACKEND_TEST_CASE( "Testing wasm <const_137_wasm>", "[const_137_wasm_tests]" ) {
343 using backend_t = backend<standalone_function_t, TestType>;
344 auto code = read_wasm( std::string(wasm_directory) + "const.137.wasm");
345 backend_t bkend( code, &wa );
346
347 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
348}
349
350BACKEND_TEST_CASE( "Testing wasm <const_138_wasm>", "[const_138_wasm_tests]" ) {
351 using backend_t = backend<standalone_function_t, TestType>;
352 auto code = read_wasm( std::string(wasm_directory) + "const.138.wasm");
353 backend_t bkend( code, &wa );
354
355 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
356}
357
358BACKEND_TEST_CASE( "Testing wasm <const_139_wasm>", "[const_139_wasm_tests]" ) {
359 using backend_t = backend<standalone_function_t, TestType>;
360 auto code = read_wasm( std::string(wasm_directory) + "const.139.wasm");
361 backend_t bkend( code, &wa );
362
363 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
364}
365
366BACKEND_TEST_CASE( "Testing wasm <const_140_wasm>", "[const_140_wasm_tests]" ) {
367 using backend_t = backend<standalone_function_t, TestType>;
368 auto code = read_wasm( std::string(wasm_directory) + "const.140.wasm");
369 backend_t bkend( code, &wa );
370
371 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
372}
373
374BACKEND_TEST_CASE( "Testing wasm <const_141_wasm>", "[const_141_wasm_tests]" ) {
375 using backend_t = backend<standalone_function_t, TestType>;
376 auto code = read_wasm( std::string(wasm_directory) + "const.141.wasm");
377 backend_t bkend( code, &wa );
378
379 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
380}
381
382BACKEND_TEST_CASE( "Testing wasm <const_142_wasm>", "[const_142_wasm_tests]" ) {
383 using backend_t = backend<standalone_function_t, TestType>;
384 auto code = read_wasm( std::string(wasm_directory) + "const.142.wasm");
385 backend_t bkend( code, &wa );
386
387 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
388}
389
390BACKEND_TEST_CASE( "Testing wasm <const_143_wasm>", "[const_143_wasm_tests]" ) {
391 using backend_t = backend<standalone_function_t, TestType>;
392 auto code = read_wasm( std::string(wasm_directory) + "const.143.wasm");
393 backend_t bkend( code, &wa );
394
395 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
396}
397
398BACKEND_TEST_CASE( "Testing wasm <const_144_wasm>", "[const_144_wasm_tests]" ) {
399 using backend_t = backend<standalone_function_t, TestType>;
400 auto code = read_wasm( std::string(wasm_directory) + "const.144.wasm");
401 backend_t bkend( code, &wa );
402
403 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
404}
405
406BACKEND_TEST_CASE( "Testing wasm <const_145_wasm>", "[const_145_wasm_tests]" ) {
407 using backend_t = backend<standalone_function_t, TestType>;
408 auto code = read_wasm( std::string(wasm_directory) + "const.145.wasm");
409 backend_t bkend( code, &wa );
410
411 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
412}
413
414BACKEND_TEST_CASE( "Testing wasm <const_146_wasm>", "[const_146_wasm_tests]" ) {
415 using backend_t = backend<standalone_function_t, TestType>;
416 auto code = read_wasm( std::string(wasm_directory) + "const.146.wasm");
417 backend_t bkend( code, &wa );
418
419 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
420}
421
422BACKEND_TEST_CASE( "Testing wasm <const_147_wasm>", "[const_147_wasm_tests]" ) {
423 using backend_t = backend<standalone_function_t, TestType>;
424 auto code = read_wasm( std::string(wasm_directory) + "const.147.wasm");
425 backend_t bkend( code, &wa );
426
427 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
428}
429
430BACKEND_TEST_CASE( "Testing wasm <const_148_wasm>", "[const_148_wasm_tests]" ) {
431 using backend_t = backend<standalone_function_t, TestType>;
432 auto code = read_wasm( std::string(wasm_directory) + "const.148.wasm");
433 backend_t bkend( code, &wa );
434
435 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
436}
437
438BACKEND_TEST_CASE( "Testing wasm <const_149_wasm>", "[const_149_wasm_tests]" ) {
439 using backend_t = backend<standalone_function_t, TestType>;
440 auto code = read_wasm( std::string(wasm_directory) + "const.149.wasm");
441 backend_t bkend( code, &wa );
442
443 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
444}
445
446BACKEND_TEST_CASE( "Testing wasm <const_150_wasm>", "[const_150_wasm_tests]" ) {
447 using backend_t = backend<standalone_function_t, TestType>;
448 auto code = read_wasm( std::string(wasm_directory) + "const.150.wasm");
449 backend_t bkend( code, &wa );
450
451 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
452}
453
454BACKEND_TEST_CASE( "Testing wasm <const_151_wasm>", "[const_151_wasm_tests]" ) {
455 using backend_t = backend<standalone_function_t, TestType>;
456 auto code = read_wasm( std::string(wasm_directory) + "const.151.wasm");
457 backend_t bkend( code, &wa );
458
459 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
460}
461
462BACKEND_TEST_CASE( "Testing wasm <const_152_wasm>", "[const_152_wasm_tests]" ) {
463 using backend_t = backend<standalone_function_t, TestType>;
464 auto code = read_wasm( std::string(wasm_directory) + "const.152.wasm");
465 backend_t bkend( code, &wa );
466
467 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
468}
469
470BACKEND_TEST_CASE( "Testing wasm <const_153_wasm>", "[const_153_wasm_tests]" ) {
471 using backend_t = backend<standalone_function_t, TestType>;
472 auto code = read_wasm( std::string(wasm_directory) + "const.153.wasm");
473 backend_t bkend( code, &wa );
474
475 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
476}
477
478BACKEND_TEST_CASE( "Testing wasm <const_154_wasm>", "[const_154_wasm_tests]" ) {
479 using backend_t = backend<standalone_function_t, TestType>;
480 auto code = read_wasm( std::string(wasm_directory) + "const.154.wasm");
481 backend_t bkend( code, &wa );
482
483 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783619));
484}
485
486BACKEND_TEST_CASE( "Testing wasm <const_155_wasm>", "[const_155_wasm_tests]" ) {
487 using backend_t = backend<standalone_function_t, TestType>;
488 auto code = read_wasm( std::string(wasm_directory) + "const.155.wasm");
489 backend_t bkend( code, &wa );
490
491 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267267));
492}
493
494BACKEND_TEST_CASE( "Testing wasm <const_156_wasm>", "[const_156_wasm_tests]" ) {
495 using backend_t = backend<standalone_function_t, TestType>;
496 auto code = read_wasm( std::string(wasm_directory) + "const.156.wasm");
497 backend_t bkend( code, &wa );
498
499 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783616));
500}
501
502BACKEND_TEST_CASE( "Testing wasm <const_157_wasm>", "[const_157_wasm_tests]" ) {
503 using backend_t = backend<standalone_function_t, TestType>;
504 auto code = read_wasm( std::string(wasm_directory) + "const.157.wasm");
505 backend_t bkend( code, &wa );
506
507 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267264));
508}
509
510BACKEND_TEST_CASE( "Testing wasm <const_158_wasm>", "[const_158_wasm_tests]" ) {
511 using backend_t = backend<standalone_function_t, TestType>;
512 auto code = read_wasm( std::string(wasm_directory) + "const.158.wasm");
513 backend_t bkend( code, &wa );
514
515 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
516}
517
518BACKEND_TEST_CASE( "Testing wasm <const_159_wasm>", "[const_159_wasm_tests]" ) {
519 using backend_t = backend<standalone_function_t, TestType>;
520 auto code = read_wasm( std::string(wasm_directory) + "const.159.wasm");
521 backend_t bkend( code, &wa );
522
523 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
524}
525
526BACKEND_TEST_CASE( "Testing wasm <const_16_wasm>", "[const_16_wasm_tests]" ) {
527 using backend_t = backend<standalone_function_t, TestType>;
528 auto code = read_wasm( std::string(wasm_directory) + "const.16.wasm");
529 backend_t bkend( code, &wa );
530
531}
532
533BACKEND_TEST_CASE( "Testing wasm <const_160_wasm>", "[const_160_wasm_tests]" ) {
534 using backend_t = backend<standalone_function_t, TestType>;
535 auto code = read_wasm( std::string(wasm_directory) + "const.160.wasm");
536 backend_t bkend( code, &wa );
537
538 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
539}
540
541BACKEND_TEST_CASE( "Testing wasm <const_161_wasm>", "[const_161_wasm_tests]" ) {
542 using backend_t = backend<standalone_function_t, TestType>;
543 auto code = read_wasm( std::string(wasm_directory) + "const.161.wasm");
544 backend_t bkend( code, &wa );
545
546 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
547}
548
549BACKEND_TEST_CASE( "Testing wasm <const_162_wasm>", "[const_162_wasm_tests]" ) {
550 using backend_t = backend<standalone_function_t, TestType>;
551 auto code = read_wasm( std::string(wasm_directory) + "const.162.wasm");
552 backend_t bkend( code, &wa );
553
554 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
555}
556
557BACKEND_TEST_CASE( "Testing wasm <const_163_wasm>", "[const_163_wasm_tests]" ) {
558 using backend_t = backend<standalone_function_t, TestType>;
559 auto code = read_wasm( std::string(wasm_directory) + "const.163.wasm");
560 backend_t bkend( code, &wa );
561
562 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
563}
564
565BACKEND_TEST_CASE( "Testing wasm <const_164_wasm>", "[const_164_wasm_tests]" ) {
566 using backend_t = backend<standalone_function_t, TestType>;
567 auto code = read_wasm( std::string(wasm_directory) + "const.164.wasm");
568 backend_t bkend( code, &wa );
569
570 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
571}
572
573BACKEND_TEST_CASE( "Testing wasm <const_165_wasm>", "[const_165_wasm_tests]" ) {
574 using backend_t = backend<standalone_function_t, TestType>;
575 auto code = read_wasm( std::string(wasm_directory) + "const.165.wasm");
576 backend_t bkend( code, &wa );
577
578 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
579}
580
581BACKEND_TEST_CASE( "Testing wasm <const_166_wasm>", "[const_166_wasm_tests]" ) {
582 using backend_t = backend<standalone_function_t, TestType>;
583 auto code = read_wasm( std::string(wasm_directory) + "const.166.wasm");
584 backend_t bkend( code, &wa );
585
586 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
587}
588
589BACKEND_TEST_CASE( "Testing wasm <const_167_wasm>", "[const_167_wasm_tests]" ) {
590 using backend_t = backend<standalone_function_t, TestType>;
591 auto code = read_wasm( std::string(wasm_directory) + "const.167.wasm");
592 backend_t bkend( code, &wa );
593
594 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
595}
596
597BACKEND_TEST_CASE( "Testing wasm <const_168_wasm>", "[const_168_wasm_tests]" ) {
598 using backend_t = backend<standalone_function_t, TestType>;
599 auto code = read_wasm( std::string(wasm_directory) + "const.168.wasm");
600 backend_t bkend( code, &wa );
601
602 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
603}
604
605BACKEND_TEST_CASE( "Testing wasm <const_169_wasm>", "[const_169_wasm_tests]" ) {
606 using backend_t = backend<standalone_function_t, TestType>;
607 auto code = read_wasm( std::string(wasm_directory) + "const.169.wasm");
608 backend_t bkend( code, &wa );
609
610 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
611}
612
613BACKEND_TEST_CASE( "Testing wasm <const_17_wasm>", "[const_17_wasm_tests]" ) {
614 using backend_t = backend<standalone_function_t, TestType>;
615 auto code = read_wasm( std::string(wasm_directory) + "const.17.wasm");
616 backend_t bkend( code, &wa );
617
618}
619
620BACKEND_TEST_CASE( "Testing wasm <const_170_wasm>", "[const_170_wasm_tests]" ) {
621 using backend_t = backend<standalone_function_t, TestType>;
622 auto code = read_wasm( std::string(wasm_directory) + "const.170.wasm");
623 backend_t bkend( code, &wa );
624
625 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783616));
626}
627
628BACKEND_TEST_CASE( "Testing wasm <const_171_wasm>", "[const_171_wasm_tests]" ) {
629 using backend_t = backend<standalone_function_t, TestType>;
630 auto code = read_wasm( std::string(wasm_directory) + "const.171.wasm");
631 backend_t bkend( code, &wa );
632
633 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267264));
634}
635
636BACKEND_TEST_CASE( "Testing wasm <const_172_wasm>", "[const_172_wasm_tests]" ) {
637 using backend_t = backend<standalone_function_t, TestType>;
638 auto code = read_wasm( std::string(wasm_directory) + "const.172.wasm");
639 backend_t bkend( code, &wa );
640
641 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
642}
643
644BACKEND_TEST_CASE( "Testing wasm <const_173_wasm>", "[const_173_wasm_tests]" ) {
645 using backend_t = backend<standalone_function_t, TestType>;
646 auto code = read_wasm( std::string(wasm_directory) + "const.173.wasm");
647 backend_t bkend( code, &wa );
648
649 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
650}
651
652BACKEND_TEST_CASE( "Testing wasm <const_174_wasm>", "[const_174_wasm_tests]" ) {
653 using backend_t = backend<standalone_function_t, TestType>;
654 auto code = read_wasm( std::string(wasm_directory) + "const.174.wasm");
655 backend_t bkend( code, &wa );
656
657 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
658}
659
660BACKEND_TEST_CASE( "Testing wasm <const_175_wasm>", "[const_175_wasm_tests]" ) {
661 using backend_t = backend<standalone_function_t, TestType>;
662 auto code = read_wasm( std::string(wasm_directory) + "const.175.wasm");
663 backend_t bkend( code, &wa );
664
665 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
666}
667
668BACKEND_TEST_CASE( "Testing wasm <const_176_wasm>", "[const_176_wasm_tests]" ) {
669 using backend_t = backend<standalone_function_t, TestType>;
670 auto code = read_wasm( std::string(wasm_directory) + "const.176.wasm");
671 backend_t bkend( code, &wa );
672
673 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
674}
675
676BACKEND_TEST_CASE( "Testing wasm <const_177_wasm>", "[const_177_wasm_tests]" ) {
677 using backend_t = backend<standalone_function_t, TestType>;
678 auto code = read_wasm( std::string(wasm_directory) + "const.177.wasm");
679 backend_t bkend( code, &wa );
680
681 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
682}
683
684BACKEND_TEST_CASE( "Testing wasm <const_178_wasm>", "[const_178_wasm_tests]" ) {
685 using backend_t = backend<standalone_function_t, TestType>;
686 auto code = read_wasm( std::string(wasm_directory) + "const.178.wasm");
687 backend_t bkend( code, &wa );
688
689 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(0));
690}
691
692BACKEND_TEST_CASE( "Testing wasm <const_179_wasm>", "[const_179_wasm_tests]" ) {
693 using backend_t = backend<standalone_function_t, TestType>;
694 auto code = read_wasm( std::string(wasm_directory) + "const.179.wasm");
695 backend_t bkend( code, &wa );
696
697 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483648));
698}
699
700BACKEND_TEST_CASE( "Testing wasm <const_18_wasm>", "[const_18_wasm_tests]" ) {
701 using backend_t = backend<standalone_function_t, TestType>;
702 auto code = read_wasm( std::string(wasm_directory) + "const.18.wasm");
703 backend_t bkend( code, &wa );
704
705}
706
707BACKEND_TEST_CASE( "Testing wasm <const_180_wasm>", "[const_180_wasm_tests]" ) {
708 using backend_t = backend<standalone_function_t, TestType>;
709 auto code = read_wasm( std::string(wasm_directory) + "const.180.wasm");
710 backend_t bkend( code, &wa );
711
712 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1));
713}
714
715BACKEND_TEST_CASE( "Testing wasm <const_181_wasm>", "[const_181_wasm_tests]" ) {
716 using backend_t = backend<standalone_function_t, TestType>;
717 auto code = read_wasm( std::string(wasm_directory) + "const.181.wasm");
718 backend_t bkend( code, &wa );
719
720 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483649));
721}
722
723BACKEND_TEST_CASE( "Testing wasm <const_182_wasm>", "[const_182_wasm_tests]" ) {
724 using backend_t = backend<standalone_function_t, TestType>;
725 auto code = read_wasm( std::string(wasm_directory) + "const.182.wasm");
726 backend_t bkend( code, &wa );
727
728 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1));
729}
730
731BACKEND_TEST_CASE( "Testing wasm <const_183_wasm>", "[const_183_wasm_tests]" ) {
732 using backend_t = backend<standalone_function_t, TestType>;
733 auto code = read_wasm( std::string(wasm_directory) + "const.183.wasm");
734 backend_t bkend( code, &wa );
735
736 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483649));
737}
738
739BACKEND_TEST_CASE( "Testing wasm <const_184_wasm>", "[const_184_wasm_tests]" ) {
740 using backend_t = backend<standalone_function_t, TestType>;
741 auto code = read_wasm( std::string(wasm_directory) + "const.184.wasm");
742 backend_t bkend( code, &wa );
743
744 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1));
745}
746
747BACKEND_TEST_CASE( "Testing wasm <const_185_wasm>", "[const_185_wasm_tests]" ) {
748 using backend_t = backend<standalone_function_t, TestType>;
749 auto code = read_wasm( std::string(wasm_directory) + "const.185.wasm");
750 backend_t bkend( code, &wa );
751
752 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483649));
753}
754
755BACKEND_TEST_CASE( "Testing wasm <const_186_wasm>", "[const_186_wasm_tests]" ) {
756 using backend_t = backend<standalone_function_t, TestType>;
757 auto code = read_wasm( std::string(wasm_directory) + "const.186.wasm");
758 backend_t bkend( code, &wa );
759
760 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1));
761}
762
763BACKEND_TEST_CASE( "Testing wasm <const_187_wasm>", "[const_187_wasm_tests]" ) {
764 using backend_t = backend<standalone_function_t, TestType>;
765 auto code = read_wasm( std::string(wasm_directory) + "const.187.wasm");
766 backend_t bkend( code, &wa );
767
768 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483649));
769}
770
771BACKEND_TEST_CASE( "Testing wasm <const_188_wasm>", "[const_188_wasm_tests]" ) {
772 using backend_t = backend<standalone_function_t, TestType>;
773 auto code = read_wasm( std::string(wasm_directory) + "const.188.wasm");
774 backend_t bkend( code, &wa );
775
776 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1));
777}
778
779BACKEND_TEST_CASE( "Testing wasm <const_189_wasm>", "[const_189_wasm_tests]" ) {
780 using backend_t = backend<standalone_function_t, TestType>;
781 auto code = read_wasm( std::string(wasm_directory) + "const.189.wasm");
782 backend_t bkend( code, &wa );
783
784 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483649));
785}
786
787BACKEND_TEST_CASE( "Testing wasm <const_19_wasm>", "[const_19_wasm_tests]" ) {
788 using backend_t = backend<standalone_function_t, TestType>;
789 auto code = read_wasm( std::string(wasm_directory) + "const.19.wasm");
790 backend_t bkend( code, &wa );
791
792}
793
794BACKEND_TEST_CASE( "Testing wasm <const_190_wasm>", "[const_190_wasm_tests]" ) {
795 using backend_t = backend<standalone_function_t, TestType>;
796 auto code = read_wasm( std::string(wasm_directory) + "const.190.wasm");
797 backend_t bkend( code, &wa );
798
799 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
800}
801
802BACKEND_TEST_CASE( "Testing wasm <const_191_wasm>", "[const_191_wasm_tests]" ) {
803 using backend_t = backend<standalone_function_t, TestType>;
804 auto code = read_wasm( std::string(wasm_directory) + "const.191.wasm");
805 backend_t bkend( code, &wa );
806
807 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
808}
809
810BACKEND_TEST_CASE( "Testing wasm <const_192_wasm>", "[const_192_wasm_tests]" ) {
811 using backend_t = backend<standalone_function_t, TestType>;
812 auto code = read_wasm( std::string(wasm_directory) + "const.192.wasm");
813 backend_t bkend( code, &wa );
814
815 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
816}
817
818BACKEND_TEST_CASE( "Testing wasm <const_193_wasm>", "[const_193_wasm_tests]" ) {
819 using backend_t = backend<standalone_function_t, TestType>;
820 auto code = read_wasm( std::string(wasm_directory) + "const.193.wasm");
821 backend_t bkend( code, &wa );
822
823 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
824}
825
826BACKEND_TEST_CASE( "Testing wasm <const_194_wasm>", "[const_194_wasm_tests]" ) {
827 using backend_t = backend<standalone_function_t, TestType>;
828 auto code = read_wasm( std::string(wasm_directory) + "const.194.wasm");
829 backend_t bkend( code, &wa );
830
831 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
832}
833
834BACKEND_TEST_CASE( "Testing wasm <const_195_wasm>", "[const_195_wasm_tests]" ) {
835 using backend_t = backend<standalone_function_t, TestType>;
836 auto code = read_wasm( std::string(wasm_directory) + "const.195.wasm");
837 backend_t bkend( code, &wa );
838
839 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
840}
841
842BACKEND_TEST_CASE( "Testing wasm <const_196_wasm>", "[const_196_wasm_tests]" ) {
843 using backend_t = backend<standalone_function_t, TestType>;
844 auto code = read_wasm( std::string(wasm_directory) + "const.196.wasm");
845 backend_t bkend( code, &wa );
846
847 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
848}
849
850BACKEND_TEST_CASE( "Testing wasm <const_197_wasm>", "[const_197_wasm_tests]" ) {
851 using backend_t = backend<standalone_function_t, TestType>;
852 auto code = read_wasm( std::string(wasm_directory) + "const.197.wasm");
853 backend_t bkend( code, &wa );
854
855 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
856}
857
858BACKEND_TEST_CASE( "Testing wasm <const_198_wasm>", "[const_198_wasm_tests]" ) {
859 using backend_t = backend<standalone_function_t, TestType>;
860 auto code = read_wasm( std::string(wasm_directory) + "const.198.wasm");
861 backend_t bkend( code, &wa );
862
863 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
864}
865
866BACKEND_TEST_CASE( "Testing wasm <const_199_wasm>", "[const_199_wasm_tests]" ) {
867 using backend_t = backend<standalone_function_t, TestType>;
868 auto code = read_wasm( std::string(wasm_directory) + "const.199.wasm");
869 backend_t bkend( code, &wa );
870
871 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
872}
873
874BACKEND_TEST_CASE( "Testing wasm <const_20_wasm>", "[const_20_wasm_tests]" ) {
875 using backend_t = backend<standalone_function_t, TestType>;
876 auto code = read_wasm( std::string(wasm_directory) + "const.20.wasm");
877 backend_t bkend( code, &wa );
878
879}
880
881BACKEND_TEST_CASE( "Testing wasm <const_200_wasm>", "[const_200_wasm_tests]" ) {
882 using backend_t = backend<standalone_function_t, TestType>;
883 auto code = read_wasm( std::string(wasm_directory) + "const.200.wasm");
884 backend_t bkend( code, &wa );
885
886 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
887}
888
889BACKEND_TEST_CASE( "Testing wasm <const_201_wasm>", "[const_201_wasm_tests]" ) {
890 using backend_t = backend<standalone_function_t, TestType>;
891 auto code = read_wasm( std::string(wasm_directory) + "const.201.wasm");
892 backend_t bkend( code, &wa );
893
894 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
895}
896
897BACKEND_TEST_CASE( "Testing wasm <const_202_wasm>", "[const_202_wasm_tests]" ) {
898 using backend_t = backend<standalone_function_t, TestType>;
899 auto code = read_wasm( std::string(wasm_directory) + "const.202.wasm");
900 backend_t bkend( code, &wa );
901
902 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
903}
904
905BACKEND_TEST_CASE( "Testing wasm <const_203_wasm>", "[const_203_wasm_tests]" ) {
906 using backend_t = backend<standalone_function_t, TestType>;
907 auto code = read_wasm( std::string(wasm_directory) + "const.203.wasm");
908 backend_t bkend( code, &wa );
909
910 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
911}
912
913BACKEND_TEST_CASE( "Testing wasm <const_204_wasm>", "[const_204_wasm_tests]" ) {
914 using backend_t = backend<standalone_function_t, TestType>;
915 auto code = read_wasm( std::string(wasm_directory) + "const.204.wasm");
916 backend_t bkend( code, &wa );
917
918 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3));
919}
920
921BACKEND_TEST_CASE( "Testing wasm <const_205_wasm>", "[const_205_wasm_tests]" ) {
922 using backend_t = backend<standalone_function_t, TestType>;
923 auto code = read_wasm( std::string(wasm_directory) + "const.205.wasm");
924 backend_t bkend( code, &wa );
925
926 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483651));
927}
928
929BACKEND_TEST_CASE( "Testing wasm <const_206_wasm>", "[const_206_wasm_tests]" ) {
930 using backend_t = backend<standalone_function_t, TestType>;
931 auto code = read_wasm( std::string(wasm_directory) + "const.206.wasm");
932 backend_t bkend( code, &wa );
933
934 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2139095039));
935}
936
937BACKEND_TEST_CASE( "Testing wasm <const_207_wasm>", "[const_207_wasm_tests]" ) {
938 using backend_t = backend<standalone_function_t, TestType>;
939 auto code = read_wasm( std::string(wasm_directory) + "const.207.wasm");
940 backend_t bkend( code, &wa );
941
942 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(4286578687));
943}
944
945BACKEND_TEST_CASE( "Testing wasm <const_208_wasm>", "[const_208_wasm_tests]" ) {
946 using backend_t = backend<standalone_function_t, TestType>;
947 auto code = read_wasm( std::string(wasm_directory) + "const.208.wasm");
948 backend_t bkend( code, &wa );
949
950 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2139095039));
951}
952
953BACKEND_TEST_CASE( "Testing wasm <const_209_wasm>", "[const_209_wasm_tests]" ) {
954 using backend_t = backend<standalone_function_t, TestType>;
955 auto code = read_wasm( std::string(wasm_directory) + "const.209.wasm");
956 backend_t bkend( code, &wa );
957
958 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(4286578687));
959}
960
961BACKEND_TEST_CASE( "Testing wasm <const_21_wasm>", "[const_21_wasm_tests]" ) {
962 using backend_t = backend<standalone_function_t, TestType>;
963 auto code = read_wasm( std::string(wasm_directory) + "const.21.wasm");
964 backend_t bkend( code, &wa );
965
966}
967
968BACKEND_TEST_CASE( "Testing wasm <const_210_wasm>", "[const_210_wasm_tests]" ) {
969 using backend_t = backend<standalone_function_t, TestType>;
970 auto code = read_wasm( std::string(wasm_directory) + "const.210.wasm");
971 backend_t bkend( code, &wa );
972
973 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2139095039));
974}
975
976BACKEND_TEST_CASE( "Testing wasm <const_211_wasm>", "[const_211_wasm_tests]" ) {
977 using backend_t = backend<standalone_function_t, TestType>;
978 auto code = read_wasm( std::string(wasm_directory) + "const.211.wasm");
979 backend_t bkend( code, &wa );
980
981 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(4286578687));
982}
983
984BACKEND_TEST_CASE( "Testing wasm <const_212_wasm>", "[const_212_wasm_tests]" ) {
985 using backend_t = backend<standalone_function_t, TestType>;
986 auto code = read_wasm( std::string(wasm_directory) + "const.212.wasm");
987 backend_t bkend( code, &wa );
988
989 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719808));
990}
991
992BACKEND_TEST_CASE( "Testing wasm <const_213_wasm>", "[const_213_wasm_tests]" ) {
993 using backend_t = backend<standalone_function_t, TestType>;
994 auto code = read_wasm( std::string(wasm_directory) + "const.213.wasm");
995 backend_t bkend( code, &wa );
996
997 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495616));
998}
999
1000BACKEND_TEST_CASE( "Testing wasm <const_214_wasm>", "[const_214_wasm_tests]" ) {
1001 using backend_t = backend<standalone_function_t, TestType>;
1002 auto code = read_wasm( std::string(wasm_directory) + "const.214.wasm");
1003 backend_t bkend( code, &wa );
1004
1005 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1006}
1007
1008BACKEND_TEST_CASE( "Testing wasm <const_215_wasm>", "[const_215_wasm_tests]" ) {
1009 using backend_t = backend<standalone_function_t, TestType>;
1010 auto code = read_wasm( std::string(wasm_directory) + "const.215.wasm");
1011 backend_t bkend( code, &wa );
1012
1013 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1014}
1015
1016BACKEND_TEST_CASE( "Testing wasm <const_216_wasm>", "[const_216_wasm_tests]" ) {
1017 using backend_t = backend<standalone_function_t, TestType>;
1018 auto code = read_wasm( std::string(wasm_directory) + "const.216.wasm");
1019 backend_t bkend( code, &wa );
1020
1021 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1022}
1023
1024BACKEND_TEST_CASE( "Testing wasm <const_217_wasm>", "[const_217_wasm_tests]" ) {
1025 using backend_t = backend<standalone_function_t, TestType>;
1026 auto code = read_wasm( std::string(wasm_directory) + "const.217.wasm");
1027 backend_t bkend( code, &wa );
1028
1029 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1030}
1031
1032BACKEND_TEST_CASE( "Testing wasm <const_218_wasm>", "[const_218_wasm_tests]" ) {
1033 using backend_t = backend<standalone_function_t, TestType>;
1034 auto code = read_wasm( std::string(wasm_directory) + "const.218.wasm");
1035 backend_t bkend( code, &wa );
1036
1037 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1038}
1039
1040BACKEND_TEST_CASE( "Testing wasm <const_219_wasm>", "[const_219_wasm_tests]" ) {
1041 using backend_t = backend<standalone_function_t, TestType>;
1042 auto code = read_wasm( std::string(wasm_directory) + "const.219.wasm");
1043 backend_t bkend( code, &wa );
1044
1045 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1046}
1047
1048BACKEND_TEST_CASE( "Testing wasm <const_22_wasm>", "[const_22_wasm_tests]" ) {
1049 using backend_t = backend<standalone_function_t, TestType>;
1050 auto code = read_wasm( std::string(wasm_directory) + "const.22.wasm");
1051 backend_t bkend( code, &wa );
1052
1053}
1054
1055BACKEND_TEST_CASE( "Testing wasm <const_220_wasm>", "[const_220_wasm_tests]" ) {
1056 using backend_t = backend<standalone_function_t, TestType>;
1057 auto code = read_wasm( std::string(wasm_directory) + "const.220.wasm");
1058 backend_t bkend( code, &wa );
1059
1060 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1061}
1062
1063BACKEND_TEST_CASE( "Testing wasm <const_221_wasm>", "[const_221_wasm_tests]" ) {
1064 using backend_t = backend<standalone_function_t, TestType>;
1065 auto code = read_wasm( std::string(wasm_directory) + "const.221.wasm");
1066 backend_t bkend( code, &wa );
1067
1068 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1069}
1070
1071BACKEND_TEST_CASE( "Testing wasm <const_222_wasm>", "[const_222_wasm_tests]" ) {
1072 using backend_t = backend<standalone_function_t, TestType>;
1073 auto code = read_wasm( std::string(wasm_directory) + "const.222.wasm");
1074 backend_t bkend( code, &wa );
1075
1076 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1077}
1078
1079BACKEND_TEST_CASE( "Testing wasm <const_223_wasm>", "[const_223_wasm_tests]" ) {
1080 using backend_t = backend<standalone_function_t, TestType>;
1081 auto code = read_wasm( std::string(wasm_directory) + "const.223.wasm");
1082 backend_t bkend( code, &wa );
1083
1084 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1085}
1086
1087BACKEND_TEST_CASE( "Testing wasm <const_224_wasm>", "[const_224_wasm_tests]" ) {
1088 using backend_t = backend<standalone_function_t, TestType>;
1089 auto code = read_wasm( std::string(wasm_directory) + "const.224.wasm");
1090 backend_t bkend( code, &wa );
1091
1092 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1093}
1094
1095BACKEND_TEST_CASE( "Testing wasm <const_225_wasm>", "[const_225_wasm_tests]" ) {
1096 using backend_t = backend<standalone_function_t, TestType>;
1097 auto code = read_wasm( std::string(wasm_directory) + "const.225.wasm");
1098 backend_t bkend( code, &wa );
1099
1100 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1101}
1102
1103BACKEND_TEST_CASE( "Testing wasm <const_226_wasm>", "[const_226_wasm_tests]" ) {
1104 using backend_t = backend<standalone_function_t, TestType>;
1105 auto code = read_wasm( std::string(wasm_directory) + "const.226.wasm");
1106 backend_t bkend( code, &wa );
1107
1108 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1109}
1110
1111BACKEND_TEST_CASE( "Testing wasm <const_227_wasm>", "[const_227_wasm_tests]" ) {
1112 using backend_t = backend<standalone_function_t, TestType>;
1113 auto code = read_wasm( std::string(wasm_directory) + "const.227.wasm");
1114 backend_t bkend( code, &wa );
1115
1116 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1117}
1118
1119BACKEND_TEST_CASE( "Testing wasm <const_228_wasm>", "[const_228_wasm_tests]" ) {
1120 using backend_t = backend<standalone_function_t, TestType>;
1121 auto code = read_wasm( std::string(wasm_directory) + "const.228.wasm");
1122 backend_t bkend( code, &wa );
1123
1124 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1125}
1126
1127BACKEND_TEST_CASE( "Testing wasm <const_229_wasm>", "[const_229_wasm_tests]" ) {
1128 using backend_t = backend<standalone_function_t, TestType>;
1129 auto code = read_wasm( std::string(wasm_directory) + "const.229.wasm");
1130 backend_t bkend( code, &wa );
1131
1132 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1133}
1134
1135BACKEND_TEST_CASE( "Testing wasm <const_23_wasm>", "[const_23_wasm_tests]" ) {
1136 using backend_t = backend<standalone_function_t, TestType>;
1137 auto code = read_wasm( std::string(wasm_directory) + "const.23.wasm");
1138 backend_t bkend( code, &wa );
1139
1140}
1141
1142BACKEND_TEST_CASE( "Testing wasm <const_230_wasm>", "[const_230_wasm_tests]" ) {
1143 using backend_t = backend<standalone_function_t, TestType>;
1144 auto code = read_wasm( std::string(wasm_directory) + "const.230.wasm");
1145 backend_t bkend( code, &wa );
1146
1147 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1148}
1149
1150BACKEND_TEST_CASE( "Testing wasm <const_231_wasm>", "[const_231_wasm_tests]" ) {
1151 using backend_t = backend<standalone_function_t, TestType>;
1152 auto code = read_wasm( std::string(wasm_directory) + "const.231.wasm");
1153 backend_t bkend( code, &wa );
1154
1155 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1156}
1157
1158BACKEND_TEST_CASE( "Testing wasm <const_232_wasm>", "[const_232_wasm_tests]" ) {
1159 using backend_t = backend<standalone_function_t, TestType>;
1160 auto code = read_wasm( std::string(wasm_directory) + "const.232.wasm");
1161 backend_t bkend( code, &wa );
1162
1163 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1164}
1165
1166BACKEND_TEST_CASE( "Testing wasm <const_233_wasm>", "[const_233_wasm_tests]" ) {
1167 using backend_t = backend<standalone_function_t, TestType>;
1168 auto code = read_wasm( std::string(wasm_directory) + "const.233.wasm");
1169 backend_t bkend( code, &wa );
1170
1171 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1172}
1173
1174BACKEND_TEST_CASE( "Testing wasm <const_234_wasm>", "[const_234_wasm_tests]" ) {
1175 using backend_t = backend<standalone_function_t, TestType>;
1176 auto code = read_wasm( std::string(wasm_directory) + "const.234.wasm");
1177 backend_t bkend( code, &wa );
1178
1179 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1180}
1181
1182BACKEND_TEST_CASE( "Testing wasm <const_235_wasm>", "[const_235_wasm_tests]" ) {
1183 using backend_t = backend<standalone_function_t, TestType>;
1184 auto code = read_wasm( std::string(wasm_directory) + "const.235.wasm");
1185 backend_t bkend( code, &wa );
1186
1187 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1188}
1189
1190BACKEND_TEST_CASE( "Testing wasm <const_236_wasm>", "[const_236_wasm_tests]" ) {
1191 using backend_t = backend<standalone_function_t, TestType>;
1192 auto code = read_wasm( std::string(wasm_directory) + "const.236.wasm");
1193 backend_t bkend( code, &wa );
1194
1195 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719811));
1196}
1197
1198BACKEND_TEST_CASE( "Testing wasm <const_237_wasm>", "[const_237_wasm_tests]" ) {
1199 using backend_t = backend<standalone_function_t, TestType>;
1200 auto code = read_wasm( std::string(wasm_directory) + "const.237.wasm");
1201 backend_t bkend( code, &wa );
1202
1203 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495619));
1204}
1205
1206BACKEND_TEST_CASE( "Testing wasm <const_238_wasm>", "[const_238_wasm_tests]" ) {
1207 using backend_t = backend<standalone_function_t, TestType>;
1208 auto code = read_wasm( std::string(wasm_directory) + "const.238.wasm");
1209 backend_t bkend( code, &wa );
1210
1211 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719808));
1212}
1213
1214BACKEND_TEST_CASE( "Testing wasm <const_239_wasm>", "[const_239_wasm_tests]" ) {
1215 using backend_t = backend<standalone_function_t, TestType>;
1216 auto code = read_wasm( std::string(wasm_directory) + "const.239.wasm");
1217 backend_t bkend( code, &wa );
1218
1219 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495616));
1220}
1221
1222BACKEND_TEST_CASE( "Testing wasm <const_24_wasm>", "[const_24_wasm_tests]" ) {
1223 using backend_t = backend<standalone_function_t, TestType>;
1224 auto code = read_wasm( std::string(wasm_directory) + "const.24.wasm");
1225 backend_t bkend( code, &wa );
1226
1227}
1228
1229BACKEND_TEST_CASE( "Testing wasm <const_240_wasm>", "[const_240_wasm_tests]" ) {
1230 using backend_t = backend<standalone_function_t, TestType>;
1231 auto code = read_wasm( std::string(wasm_directory) + "const.240.wasm");
1232 backend_t bkend( code, &wa );
1233
1234 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1235}
1236
1237BACKEND_TEST_CASE( "Testing wasm <const_241_wasm>", "[const_241_wasm_tests]" ) {
1238 using backend_t = backend<standalone_function_t, TestType>;
1239 auto code = read_wasm( std::string(wasm_directory) + "const.241.wasm");
1240 backend_t bkend( code, &wa );
1241
1242 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1243}
1244
1245BACKEND_TEST_CASE( "Testing wasm <const_242_wasm>", "[const_242_wasm_tests]" ) {
1246 using backend_t = backend<standalone_function_t, TestType>;
1247 auto code = read_wasm( std::string(wasm_directory) + "const.242.wasm");
1248 backend_t bkend( code, &wa );
1249
1250 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1251}
1252
1253BACKEND_TEST_CASE( "Testing wasm <const_243_wasm>", "[const_243_wasm_tests]" ) {
1254 using backend_t = backend<standalone_function_t, TestType>;
1255 auto code = read_wasm( std::string(wasm_directory) + "const.243.wasm");
1256 backend_t bkend( code, &wa );
1257
1258 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1259}
1260
1261BACKEND_TEST_CASE( "Testing wasm <const_244_wasm>", "[const_244_wasm_tests]" ) {
1262 using backend_t = backend<standalone_function_t, TestType>;
1263 auto code = read_wasm( std::string(wasm_directory) + "const.244.wasm");
1264 backend_t bkend( code, &wa );
1265
1266 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1267}
1268
1269BACKEND_TEST_CASE( "Testing wasm <const_245_wasm>", "[const_245_wasm_tests]" ) {
1270 using backend_t = backend<standalone_function_t, TestType>;
1271 auto code = read_wasm( std::string(wasm_directory) + "const.245.wasm");
1272 backend_t bkend( code, &wa );
1273
1274 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1275}
1276
1277BACKEND_TEST_CASE( "Testing wasm <const_246_wasm>", "[const_246_wasm_tests]" ) {
1278 using backend_t = backend<standalone_function_t, TestType>;
1279 auto code = read_wasm( std::string(wasm_directory) + "const.246.wasm");
1280 backend_t bkend( code, &wa );
1281
1282 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1283}
1284
1285BACKEND_TEST_CASE( "Testing wasm <const_247_wasm>", "[const_247_wasm_tests]" ) {
1286 using backend_t = backend<standalone_function_t, TestType>;
1287 auto code = read_wasm( std::string(wasm_directory) + "const.247.wasm");
1288 backend_t bkend( code, &wa );
1289
1290 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1291}
1292
1293BACKEND_TEST_CASE( "Testing wasm <const_248_wasm>", "[const_248_wasm_tests]" ) {
1294 using backend_t = backend<standalone_function_t, TestType>;
1295 auto code = read_wasm( std::string(wasm_directory) + "const.248.wasm");
1296 backend_t bkend( code, &wa );
1297
1298 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1299}
1300
1301BACKEND_TEST_CASE( "Testing wasm <const_249_wasm>", "[const_249_wasm_tests]" ) {
1302 using backend_t = backend<standalone_function_t, TestType>;
1303 auto code = read_wasm( std::string(wasm_directory) + "const.249.wasm");
1304 backend_t bkend( code, &wa );
1305
1306 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1307}
1308
1309BACKEND_TEST_CASE( "Testing wasm <const_25_wasm>", "[const_25_wasm_tests]" ) {
1310 using backend_t = backend<standalone_function_t, TestType>;
1311 auto code = read_wasm( std::string(wasm_directory) + "const.25.wasm");
1312 backend_t bkend( code, &wa );
1313
1314}
1315
1316BACKEND_TEST_CASE( "Testing wasm <const_250_wasm>", "[const_250_wasm_tests]" ) {
1317 using backend_t = backend<standalone_function_t, TestType>;
1318 auto code = read_wasm( std::string(wasm_directory) + "const.250.wasm");
1319 backend_t bkend( code, &wa );
1320
1321 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1322}
1323
1324BACKEND_TEST_CASE( "Testing wasm <const_251_wasm>", "[const_251_wasm_tests]" ) {
1325 using backend_t = backend<standalone_function_t, TestType>;
1326 auto code = read_wasm( std::string(wasm_directory) + "const.251.wasm");
1327 backend_t bkend( code, &wa );
1328
1329 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1330}
1331
1332BACKEND_TEST_CASE( "Testing wasm <const_252_wasm>", "[const_252_wasm_tests]" ) {
1333 using backend_t = backend<standalone_function_t, TestType>;
1334 auto code = read_wasm( std::string(wasm_directory) + "const.252.wasm");
1335 backend_t bkend( code, &wa );
1336
1337 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1338}
1339
1340BACKEND_TEST_CASE( "Testing wasm <const_253_wasm>", "[const_253_wasm_tests]" ) {
1341 using backend_t = backend<standalone_function_t, TestType>;
1342 auto code = read_wasm( std::string(wasm_directory) + "const.253.wasm");
1343 backend_t bkend( code, &wa );
1344
1345 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1346}
1347
1348BACKEND_TEST_CASE( "Testing wasm <const_254_wasm>", "[const_254_wasm_tests]" ) {
1349 using backend_t = backend<standalone_function_t, TestType>;
1350 auto code = read_wasm( std::string(wasm_directory) + "const.254.wasm");
1351 backend_t bkend( code, &wa );
1352
1353 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1354}
1355
1356BACKEND_TEST_CASE( "Testing wasm <const_255_wasm>", "[const_255_wasm_tests]" ) {
1357 using backend_t = backend<standalone_function_t, TestType>;
1358 auto code = read_wasm( std::string(wasm_directory) + "const.255.wasm");
1359 backend_t bkend( code, &wa );
1360
1361 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1362}
1363
1364BACKEND_TEST_CASE( "Testing wasm <const_256_wasm>", "[const_256_wasm_tests]" ) {
1365 using backend_t = backend<standalone_function_t, TestType>;
1366 auto code = read_wasm( std::string(wasm_directory) + "const.256.wasm");
1367 backend_t bkend( code, &wa );
1368
1369 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1370}
1371
1372BACKEND_TEST_CASE( "Testing wasm <const_257_wasm>", "[const_257_wasm_tests]" ) {
1373 using backend_t = backend<standalone_function_t, TestType>;
1374 auto code = read_wasm( std::string(wasm_directory) + "const.257.wasm");
1375 backend_t bkend( code, &wa );
1376
1377 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1378}
1379
1380BACKEND_TEST_CASE( "Testing wasm <const_258_wasm>", "[const_258_wasm_tests]" ) {
1381 using backend_t = backend<standalone_function_t, TestType>;
1382 auto code = read_wasm( std::string(wasm_directory) + "const.258.wasm");
1383 backend_t bkend( code, &wa );
1384
1385 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1386}
1387
1388BACKEND_TEST_CASE( "Testing wasm <const_259_wasm>", "[const_259_wasm_tests]" ) {
1389 using backend_t = backend<standalone_function_t, TestType>;
1390 auto code = read_wasm( std::string(wasm_directory) + "const.259.wasm");
1391 backend_t bkend( code, &wa );
1392
1393 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1394}
1395
1396BACKEND_TEST_CASE( "Testing wasm <const_260_wasm>", "[const_260_wasm_tests]" ) {
1397 using backend_t = backend<standalone_function_t, TestType>;
1398 auto code = read_wasm( std::string(wasm_directory) + "const.260.wasm");
1399 backend_t bkend( code, &wa );
1400
1401 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1402}
1403
1404BACKEND_TEST_CASE( "Testing wasm <const_261_wasm>", "[const_261_wasm_tests]" ) {
1405 using backend_t = backend<standalone_function_t, TestType>;
1406 auto code = read_wasm( std::string(wasm_directory) + "const.261.wasm");
1407 backend_t bkend( code, &wa );
1408
1409 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1410}
1411
1412BACKEND_TEST_CASE( "Testing wasm <const_262_wasm>", "[const_262_wasm_tests]" ) {
1413 using backend_t = backend<standalone_function_t, TestType>;
1414 auto code = read_wasm( std::string(wasm_directory) + "const.262.wasm");
1415 backend_t bkend( code, &wa );
1416
1417 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719811));
1418}
1419
1420BACKEND_TEST_CASE( "Testing wasm <const_263_wasm>", "[const_263_wasm_tests]" ) {
1421 using backend_t = backend<standalone_function_t, TestType>;
1422 auto code = read_wasm( std::string(wasm_directory) + "const.263.wasm");
1423 backend_t bkend( code, &wa );
1424
1425 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495619));
1426}
1427
1428BACKEND_TEST_CASE( "Testing wasm <const_264_wasm>", "[const_264_wasm_tests]" ) {
1429 using backend_t = backend<standalone_function_t, TestType>;
1430 auto code = read_wasm( std::string(wasm_directory) + "const.264.wasm");
1431 backend_t bkend( code, &wa );
1432
1433 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9106278446543142912));
1434}
1435
1436BACKEND_TEST_CASE( "Testing wasm <const_265_wasm>", "[const_265_wasm_tests]" ) {
1437 using backend_t = backend<standalone_function_t, TestType>;
1438 auto code = read_wasm( std::string(wasm_directory) + "const.265.wasm");
1439 backend_t bkend( code, &wa );
1440
1441 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(18329650483397918720));
1442}
1443
1444BACKEND_TEST_CASE( "Testing wasm <const_266_wasm>", "[const_266_wasm_tests]" ) {
1445 using backend_t = backend<standalone_function_t, TestType>;
1446 auto code = read_wasm( std::string(wasm_directory) + "const.266.wasm");
1447 backend_t bkend( code, &wa );
1448
1449 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9106278446543142913));
1450}
1451
1452BACKEND_TEST_CASE( "Testing wasm <const_267_wasm>", "[const_267_wasm_tests]" ) {
1453 using backend_t = backend<standalone_function_t, TestType>;
1454 auto code = read_wasm( std::string(wasm_directory) + "const.267.wasm");
1455 backend_t bkend( code, &wa );
1456
1457 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(18329650483397918721));
1458}
1459
1460BACKEND_TEST_CASE( "Testing wasm <const_268_wasm>", "[const_268_wasm_tests]" ) {
1461 using backend_t = backend<standalone_function_t, TestType>;
1462 auto code = read_wasm( std::string(wasm_directory) + "const.268.wasm");
1463 backend_t bkend( code, &wa );
1464
1465 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9106278446543142913));
1466}
1467
1468BACKEND_TEST_CASE( "Testing wasm <const_269_wasm>", "[const_269_wasm_tests]" ) {
1469 using backend_t = backend<standalone_function_t, TestType>;
1470 auto code = read_wasm( std::string(wasm_directory) + "const.269.wasm");
1471 backend_t bkend( code, &wa );
1472
1473 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(18329650483397918721));
1474}
1475
1476BACKEND_TEST_CASE( "Testing wasm <const_270_wasm>", "[const_270_wasm_tests]" ) {
1477 using backend_t = backend<standalone_function_t, TestType>;
1478 auto code = read_wasm( std::string(wasm_directory) + "const.270.wasm");
1479 backend_t bkend( code, &wa );
1480
1481 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9106278446543142914));
1482}
1483
1484BACKEND_TEST_CASE( "Testing wasm <const_271_wasm>", "[const_271_wasm_tests]" ) {
1485 using backend_t = backend<standalone_function_t, TestType>;
1486 auto code = read_wasm( std::string(wasm_directory) + "const.271.wasm");
1487 backend_t bkend( code, &wa );
1488
1489 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(18329650483397918722));
1490}
1491
1492BACKEND_TEST_CASE( "Testing wasm <const_272_wasm>", "[const_272_wasm_tests]" ) {
1493 using backend_t = backend<standalone_function_t, TestType>;
1494 auto code = read_wasm( std::string(wasm_directory) + "const.272.wasm");
1495 backend_t bkend( code, &wa );
1496
1497 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315008));
1498}
1499
1500BACKEND_TEST_CASE( "Testing wasm <const_273_wasm>", "[const_273_wasm_tests]" ) {
1501 using backend_t = backend<standalone_function_t, TestType>;
1502 auto code = read_wasm( std::string(wasm_directory) + "const.273.wasm");
1503 backend_t bkend( code, &wa );
1504
1505 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090816));
1506}
1507
1508BACKEND_TEST_CASE( "Testing wasm <const_274_wasm>", "[const_274_wasm_tests]" ) {
1509 using backend_t = backend<standalone_function_t, TestType>;
1510 auto code = read_wasm( std::string(wasm_directory) + "const.274.wasm");
1511 backend_t bkend( code, &wa );
1512
1513 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315009));
1514}
1515
1516BACKEND_TEST_CASE( "Testing wasm <const_275_wasm>", "[const_275_wasm_tests]" ) {
1517 using backend_t = backend<standalone_function_t, TestType>;
1518 auto code = read_wasm( std::string(wasm_directory) + "const.275.wasm");
1519 backend_t bkend( code, &wa );
1520
1521 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090817));
1522}
1523
1524BACKEND_TEST_CASE( "Testing wasm <const_276_wasm>", "[const_276_wasm_tests]" ) {
1525 using backend_t = backend<standalone_function_t, TestType>;
1526 auto code = read_wasm( std::string(wasm_directory) + "const.276.wasm");
1527 backend_t bkend( code, &wa );
1528
1529 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315009));
1530}
1531
1532BACKEND_TEST_CASE( "Testing wasm <const_277_wasm>", "[const_277_wasm_tests]" ) {
1533 using backend_t = backend<standalone_function_t, TestType>;
1534 auto code = read_wasm( std::string(wasm_directory) + "const.277.wasm");
1535 backend_t bkend( code, &wa );
1536
1537 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090817));
1538}
1539
1540BACKEND_TEST_CASE( "Testing wasm <const_278_wasm>", "[const_278_wasm_tests]" ) {
1541 using backend_t = backend<standalone_function_t, TestType>;
1542 auto code = read_wasm( std::string(wasm_directory) + "const.278.wasm");
1543 backend_t bkend( code, &wa );
1544
1545 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315009));
1546}
1547
1548BACKEND_TEST_CASE( "Testing wasm <const_279_wasm>", "[const_279_wasm_tests]" ) {
1549 using backend_t = backend<standalone_function_t, TestType>;
1550 auto code = read_wasm( std::string(wasm_directory) + "const.279.wasm");
1551 backend_t bkend( code, &wa );
1552
1553 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090817));
1554}
1555
1556BACKEND_TEST_CASE( "Testing wasm <const_280_wasm>", "[const_280_wasm_tests]" ) {
1557 using backend_t = backend<standalone_function_t, TestType>;
1558 auto code = read_wasm( std::string(wasm_directory) + "const.280.wasm");
1559 backend_t bkend( code, &wa );
1560
1561 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315009));
1562}
1563
1564BACKEND_TEST_CASE( "Testing wasm <const_281_wasm>", "[const_281_wasm_tests]" ) {
1565 using backend_t = backend<standalone_function_t, TestType>;
1566 auto code = read_wasm( std::string(wasm_directory) + "const.281.wasm");
1567 backend_t bkend( code, &wa );
1568
1569 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090817));
1570}
1571
1572BACKEND_TEST_CASE( "Testing wasm <const_282_wasm>", "[const_282_wasm_tests]" ) {
1573 using backend_t = backend<standalone_function_t, TestType>;
1574 auto code = read_wasm( std::string(wasm_directory) + "const.282.wasm");
1575 backend_t bkend( code, &wa );
1576
1577 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315009));
1578}
1579
1580BACKEND_TEST_CASE( "Testing wasm <const_283_wasm>", "[const_283_wasm_tests]" ) {
1581 using backend_t = backend<standalone_function_t, TestType>;
1582 auto code = read_wasm( std::string(wasm_directory) + "const.283.wasm");
1583 backend_t bkend( code, &wa );
1584
1585 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090817));
1586}
1587
1588BACKEND_TEST_CASE( "Testing wasm <const_284_wasm>", "[const_284_wasm_tests]" ) {
1589 using backend_t = backend<standalone_function_t, TestType>;
1590 auto code = read_wasm( std::string(wasm_directory) + "const.284.wasm");
1591 backend_t bkend( code, &wa );
1592
1593 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1594}
1595
1596BACKEND_TEST_CASE( "Testing wasm <const_285_wasm>", "[const_285_wasm_tests]" ) {
1597 using backend_t = backend<standalone_function_t, TestType>;
1598 auto code = read_wasm( std::string(wasm_directory) + "const.285.wasm");
1599 backend_t bkend( code, &wa );
1600
1601 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1602}
1603
1604BACKEND_TEST_CASE( "Testing wasm <const_286_wasm>", "[const_286_wasm_tests]" ) {
1605 using backend_t = backend<standalone_function_t, TestType>;
1606 auto code = read_wasm( std::string(wasm_directory) + "const.286.wasm");
1607 backend_t bkend( code, &wa );
1608
1609 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1610}
1611
1612BACKEND_TEST_CASE( "Testing wasm <const_287_wasm>", "[const_287_wasm_tests]" ) {
1613 using backend_t = backend<standalone_function_t, TestType>;
1614 auto code = read_wasm( std::string(wasm_directory) + "const.287.wasm");
1615 backend_t bkend( code, &wa );
1616
1617 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1618}
1619
1620BACKEND_TEST_CASE( "Testing wasm <const_288_wasm>", "[const_288_wasm_tests]" ) {
1621 using backend_t = backend<standalone_function_t, TestType>;
1622 auto code = read_wasm( std::string(wasm_directory) + "const.288.wasm");
1623 backend_t bkend( code, &wa );
1624
1625 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1626}
1627
1628BACKEND_TEST_CASE( "Testing wasm <const_289_wasm>", "[const_289_wasm_tests]" ) {
1629 using backend_t = backend<standalone_function_t, TestType>;
1630 auto code = read_wasm( std::string(wasm_directory) + "const.289.wasm");
1631 backend_t bkend( code, &wa );
1632
1633 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1634}
1635
1636BACKEND_TEST_CASE( "Testing wasm <const_290_wasm>", "[const_290_wasm_tests]" ) {
1637 using backend_t = backend<standalone_function_t, TestType>;
1638 auto code = read_wasm( std::string(wasm_directory) + "const.290.wasm");
1639 backend_t bkend( code, &wa );
1640
1641 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1642}
1643
1644BACKEND_TEST_CASE( "Testing wasm <const_291_wasm>", "[const_291_wasm_tests]" ) {
1645 using backend_t = backend<standalone_function_t, TestType>;
1646 auto code = read_wasm( std::string(wasm_directory) + "const.291.wasm");
1647 backend_t bkend( code, &wa );
1648
1649 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1650}
1651
1652BACKEND_TEST_CASE( "Testing wasm <const_292_wasm>", "[const_292_wasm_tests]" ) {
1653 using backend_t = backend<standalone_function_t, TestType>;
1654 auto code = read_wasm( std::string(wasm_directory) + "const.292.wasm");
1655 backend_t bkend( code, &wa );
1656
1657 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1658}
1659
1660BACKEND_TEST_CASE( "Testing wasm <const_293_wasm>", "[const_293_wasm_tests]" ) {
1661 using backend_t = backend<standalone_function_t, TestType>;
1662 auto code = read_wasm( std::string(wasm_directory) + "const.293.wasm");
1663 backend_t bkend( code, &wa );
1664
1665 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1666}
1667
1668BACKEND_TEST_CASE( "Testing wasm <const_294_wasm>", "[const_294_wasm_tests]" ) {
1669 using backend_t = backend<standalone_function_t, TestType>;
1670 auto code = read_wasm( std::string(wasm_directory) + "const.294.wasm");
1671 backend_t bkend( code, &wa );
1672
1673 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1674}
1675
1676BACKEND_TEST_CASE( "Testing wasm <const_295_wasm>", "[const_295_wasm_tests]" ) {
1677 using backend_t = backend<standalone_function_t, TestType>;
1678 auto code = read_wasm( std::string(wasm_directory) + "const.295.wasm");
1679 backend_t bkend( code, &wa );
1680
1681 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1682}
1683
1684BACKEND_TEST_CASE( "Testing wasm <const_296_wasm>", "[const_296_wasm_tests]" ) {
1685 using backend_t = backend<standalone_function_t, TestType>;
1686 auto code = read_wasm( std::string(wasm_directory) + "const.296.wasm");
1687 backend_t bkend( code, &wa );
1688
1689 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1690}
1691
1692BACKEND_TEST_CASE( "Testing wasm <const_297_wasm>", "[const_297_wasm_tests]" ) {
1693 using backend_t = backend<standalone_function_t, TestType>;
1694 auto code = read_wasm( std::string(wasm_directory) + "const.297.wasm");
1695 backend_t bkend( code, &wa );
1696
1697 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1698}
1699
1700BACKEND_TEST_CASE( "Testing wasm <const_298_wasm>", "[const_298_wasm_tests]" ) {
1701 using backend_t = backend<standalone_function_t, TestType>;
1702 auto code = read_wasm( std::string(wasm_directory) + "const.298.wasm");
1703 backend_t bkend( code, &wa );
1704
1705 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315011));
1706}
1707
1708BACKEND_TEST_CASE( "Testing wasm <const_299_wasm>", "[const_299_wasm_tests]" ) {
1709 using backend_t = backend<standalone_function_t, TestType>;
1710 auto code = read_wasm( std::string(wasm_directory) + "const.299.wasm");
1711 backend_t bkend( code, &wa );
1712
1713 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090819));
1714}
1715
1716BACKEND_TEST_CASE( "Testing wasm <const_30_wasm>", "[const_30_wasm_tests]" ) {
1717 using backend_t = backend<standalone_function_t, TestType>;
1718 auto code = read_wasm( std::string(wasm_directory) + "const.30.wasm");
1719 backend_t bkend( code, &wa );
1720
1721}
1722
1723BACKEND_TEST_CASE( "Testing wasm <const_300_wasm>", "[const_300_wasm_tests]" ) {
1724 using backend_t = backend<standalone_function_t, TestType>;
1725 auto code = read_wasm( std::string(wasm_directory) + "const.300.wasm");
1726 backend_t bkend( code, &wa );
1727
1728 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955520));
1729}
1730
1731BACKEND_TEST_CASE( "Testing wasm <const_301_wasm>", "[const_301_wasm_tests]" ) {
1732 using backend_t = backend<standalone_function_t, TestType>;
1733 auto code = read_wasm( std::string(wasm_directory) + "const.301.wasm");
1734 backend_t bkend( code, &wa );
1735
1736 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731328));
1737}
1738
1739BACKEND_TEST_CASE( "Testing wasm <const_302_wasm>", "[const_302_wasm_tests]" ) {
1740 using backend_t = backend<standalone_function_t, TestType>;
1741 auto code = read_wasm( std::string(wasm_directory) + "const.302.wasm");
1742 backend_t bkend( code, &wa );
1743
1744 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955521));
1745}
1746
1747BACKEND_TEST_CASE( "Testing wasm <const_303_wasm>", "[const_303_wasm_tests]" ) {
1748 using backend_t = backend<standalone_function_t, TestType>;
1749 auto code = read_wasm( std::string(wasm_directory) + "const.303.wasm");
1750 backend_t bkend( code, &wa );
1751
1752 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731329));
1753}
1754
1755BACKEND_TEST_CASE( "Testing wasm <const_304_wasm>", "[const_304_wasm_tests]" ) {
1756 using backend_t = backend<standalone_function_t, TestType>;
1757 auto code = read_wasm( std::string(wasm_directory) + "const.304.wasm");
1758 backend_t bkend( code, &wa );
1759
1760 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955521));
1761}
1762
1763BACKEND_TEST_CASE( "Testing wasm <const_305_wasm>", "[const_305_wasm_tests]" ) {
1764 using backend_t = backend<standalone_function_t, TestType>;
1765 auto code = read_wasm( std::string(wasm_directory) + "const.305.wasm");
1766 backend_t bkend( code, &wa );
1767
1768 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731329));
1769}
1770
1771BACKEND_TEST_CASE( "Testing wasm <const_306_wasm>", "[const_306_wasm_tests]" ) {
1772 using backend_t = backend<standalone_function_t, TestType>;
1773 auto code = read_wasm( std::string(wasm_directory) + "const.306.wasm");
1774 backend_t bkend( code, &wa );
1775
1776 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955521));
1777}
1778
1779BACKEND_TEST_CASE( "Testing wasm <const_307_wasm>", "[const_307_wasm_tests]" ) {
1780 using backend_t = backend<standalone_function_t, TestType>;
1781 auto code = read_wasm( std::string(wasm_directory) + "const.307.wasm");
1782 backend_t bkend( code, &wa );
1783
1784 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731329));
1785}
1786
1787BACKEND_TEST_CASE( "Testing wasm <const_308_wasm>", "[const_308_wasm_tests]" ) {
1788 using backend_t = backend<standalone_function_t, TestType>;
1789 auto code = read_wasm( std::string(wasm_directory) + "const.308.wasm");
1790 backend_t bkend( code, &wa );
1791
1792 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955521));
1793}
1794
1795BACKEND_TEST_CASE( "Testing wasm <const_309_wasm>", "[const_309_wasm_tests]" ) {
1796 using backend_t = backend<standalone_function_t, TestType>;
1797 auto code = read_wasm( std::string(wasm_directory) + "const.309.wasm");
1798 backend_t bkend( code, &wa );
1799
1800 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731329));
1801}
1802
1803BACKEND_TEST_CASE( "Testing wasm <const_31_wasm>", "[const_31_wasm_tests]" ) {
1804 using backend_t = backend<standalone_function_t, TestType>;
1805 auto code = read_wasm( std::string(wasm_directory) + "const.31.wasm");
1806 backend_t bkend( code, &wa );
1807
1808}
1809
1810BACKEND_TEST_CASE( "Testing wasm <const_310_wasm>", "[const_310_wasm_tests]" ) {
1811 using backend_t = backend<standalone_function_t, TestType>;
1812 auto code = read_wasm( std::string(wasm_directory) + "const.310.wasm");
1813 backend_t bkend( code, &wa );
1814
1815 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955521));
1816}
1817
1818BACKEND_TEST_CASE( "Testing wasm <const_311_wasm>", "[const_311_wasm_tests]" ) {
1819 using backend_t = backend<standalone_function_t, TestType>;
1820 auto code = read_wasm( std::string(wasm_directory) + "const.311.wasm");
1821 backend_t bkend( code, &wa );
1822
1823 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731329));
1824}
1825
1826BACKEND_TEST_CASE( "Testing wasm <const_312_wasm>", "[const_312_wasm_tests]" ) {
1827 using backend_t = backend<standalone_function_t, TestType>;
1828 auto code = read_wasm( std::string(wasm_directory) + "const.312.wasm");
1829 backend_t bkend( code, &wa );
1830
1831 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1832}
1833
1834BACKEND_TEST_CASE( "Testing wasm <const_313_wasm>", "[const_313_wasm_tests]" ) {
1835 using backend_t = backend<standalone_function_t, TestType>;
1836 auto code = read_wasm( std::string(wasm_directory) + "const.313.wasm");
1837 backend_t bkend( code, &wa );
1838
1839 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1840}
1841
1842BACKEND_TEST_CASE( "Testing wasm <const_314_wasm>", "[const_314_wasm_tests]" ) {
1843 using backend_t = backend<standalone_function_t, TestType>;
1844 auto code = read_wasm( std::string(wasm_directory) + "const.314.wasm");
1845 backend_t bkend( code, &wa );
1846
1847 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1848}
1849
1850BACKEND_TEST_CASE( "Testing wasm <const_315_wasm>", "[const_315_wasm_tests]" ) {
1851 using backend_t = backend<standalone_function_t, TestType>;
1852 auto code = read_wasm( std::string(wasm_directory) + "const.315.wasm");
1853 backend_t bkend( code, &wa );
1854
1855 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1856}
1857
1858BACKEND_TEST_CASE( "Testing wasm <const_316_wasm>", "[const_316_wasm_tests]" ) {
1859 using backend_t = backend<standalone_function_t, TestType>;
1860 auto code = read_wasm( std::string(wasm_directory) + "const.316.wasm");
1861 backend_t bkend( code, &wa );
1862
1863 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1864}
1865
1866BACKEND_TEST_CASE( "Testing wasm <const_317_wasm>", "[const_317_wasm_tests]" ) {
1867 using backend_t = backend<standalone_function_t, TestType>;
1868 auto code = read_wasm( std::string(wasm_directory) + "const.317.wasm");
1869 backend_t bkend( code, &wa );
1870
1871 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1872}
1873
1874BACKEND_TEST_CASE( "Testing wasm <const_318_wasm>", "[const_318_wasm_tests]" ) {
1875 using backend_t = backend<standalone_function_t, TestType>;
1876 auto code = read_wasm( std::string(wasm_directory) + "const.318.wasm");
1877 backend_t bkend( code, &wa );
1878
1879 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1880}
1881
1882BACKEND_TEST_CASE( "Testing wasm <const_319_wasm>", "[const_319_wasm_tests]" ) {
1883 using backend_t = backend<standalone_function_t, TestType>;
1884 auto code = read_wasm( std::string(wasm_directory) + "const.319.wasm");
1885 backend_t bkend( code, &wa );
1886
1887 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1888}
1889
1890BACKEND_TEST_CASE( "Testing wasm <const_320_wasm>", "[const_320_wasm_tests]" ) {
1891 using backend_t = backend<standalone_function_t, TestType>;
1892 auto code = read_wasm( std::string(wasm_directory) + "const.320.wasm");
1893 backend_t bkend( code, &wa );
1894
1895 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1896}
1897
1898BACKEND_TEST_CASE( "Testing wasm <const_321_wasm>", "[const_321_wasm_tests]" ) {
1899 using backend_t = backend<standalone_function_t, TestType>;
1900 auto code = read_wasm( std::string(wasm_directory) + "const.321.wasm");
1901 backend_t bkend( code, &wa );
1902
1903 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1904}
1905
1906BACKEND_TEST_CASE( "Testing wasm <const_322_wasm>", "[const_322_wasm_tests]" ) {
1907 using backend_t = backend<standalone_function_t, TestType>;
1908 auto code = read_wasm( std::string(wasm_directory) + "const.322.wasm");
1909 backend_t bkend( code, &wa );
1910
1911 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1912}
1913
1914BACKEND_TEST_CASE( "Testing wasm <const_323_wasm>", "[const_323_wasm_tests]" ) {
1915 using backend_t = backend<standalone_function_t, TestType>;
1916 auto code = read_wasm( std::string(wasm_directory) + "const.323.wasm");
1917 backend_t bkend( code, &wa );
1918
1919 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1920}
1921
1922BACKEND_TEST_CASE( "Testing wasm <const_324_wasm>", "[const_324_wasm_tests]" ) {
1923 using backend_t = backend<standalone_function_t, TestType>;
1924 auto code = read_wasm( std::string(wasm_directory) + "const.324.wasm");
1925 backend_t bkend( code, &wa );
1926
1927 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1928}
1929
1930BACKEND_TEST_CASE( "Testing wasm <const_325_wasm>", "[const_325_wasm_tests]" ) {
1931 using backend_t = backend<standalone_function_t, TestType>;
1932 auto code = read_wasm( std::string(wasm_directory) + "const.325.wasm");
1933 backend_t bkend( code, &wa );
1934
1935 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1936}
1937
1938BACKEND_TEST_CASE( "Testing wasm <const_326_wasm>", "[const_326_wasm_tests]" ) {
1939 using backend_t = backend<standalone_function_t, TestType>;
1940 auto code = read_wasm( std::string(wasm_directory) + "const.326.wasm");
1941 backend_t bkend( code, &wa );
1942
1943 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955523));
1944}
1945
1946BACKEND_TEST_CASE( "Testing wasm <const_327_wasm>", "[const_327_wasm_tests]" ) {
1947 using backend_t = backend<standalone_function_t, TestType>;
1948 auto code = read_wasm( std::string(wasm_directory) + "const.327.wasm");
1949 backend_t bkend( code, &wa );
1950
1951 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731331));
1952}
1953
1954BACKEND_TEST_CASE( "Testing wasm <const_328_wasm>", "[const_328_wasm_tests]" ) {
1955 using backend_t = backend<standalone_function_t, TestType>;
1956 auto code = read_wasm( std::string(wasm_directory) + "const.328.wasm");
1957 backend_t bkend( code, &wa );
1958
1959 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(4877398396442247168));
1960}
1961
1962BACKEND_TEST_CASE( "Testing wasm <const_329_wasm>", "[const_329_wasm_tests]" ) {
1963 using backend_t = backend<standalone_function_t, TestType>;
1964 auto code = read_wasm( std::string(wasm_directory) + "const.329.wasm");
1965 backend_t bkend( code, &wa );
1966
1967 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14100770433297022976));
1968}
1969
1970BACKEND_TEST_CASE( "Testing wasm <const_330_wasm>", "[const_330_wasm_tests]" ) {
1971 using backend_t = backend<standalone_function_t, TestType>;
1972 auto code = read_wasm( std::string(wasm_directory) + "const.330.wasm");
1973 backend_t bkend( code, &wa );
1974
1975 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(4877398396442247169));
1976}
1977
1978BACKEND_TEST_CASE( "Testing wasm <const_331_wasm>", "[const_331_wasm_tests]" ) {
1979 using backend_t = backend<standalone_function_t, TestType>;
1980 auto code = read_wasm( std::string(wasm_directory) + "const.331.wasm");
1981 backend_t bkend( code, &wa );
1982
1983 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14100770433297022977));
1984}
1985
1986BACKEND_TEST_CASE( "Testing wasm <const_332_wasm>", "[const_332_wasm_tests]" ) {
1987 using backend_t = backend<standalone_function_t, TestType>;
1988 auto code = read_wasm( std::string(wasm_directory) + "const.332.wasm");
1989 backend_t bkend( code, &wa );
1990
1991 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(4877398396442247169));
1992}
1993
1994BACKEND_TEST_CASE( "Testing wasm <const_333_wasm>", "[const_333_wasm_tests]" ) {
1995 using backend_t = backend<standalone_function_t, TestType>;
1996 auto code = read_wasm( std::string(wasm_directory) + "const.333.wasm");
1997 backend_t bkend( code, &wa );
1998
1999 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14100770433297022977));
2000}
2001
2002BACKEND_TEST_CASE( "Testing wasm <const_334_wasm>", "[const_334_wasm_tests]" ) {
2003 using backend_t = backend<standalone_function_t, TestType>;
2004 auto code = read_wasm( std::string(wasm_directory) + "const.334.wasm");
2005 backend_t bkend( code, &wa );
2006
2007 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(4877398396442247170));
2008}
2009
2010BACKEND_TEST_CASE( "Testing wasm <const_335_wasm>", "[const_335_wasm_tests]" ) {
2011 using backend_t = backend<standalone_function_t, TestType>;
2012 auto code = read_wasm( std::string(wasm_directory) + "const.335.wasm");
2013 backend_t bkend( code, &wa );
2014
2015 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14100770433297022978));
2016}
2017
2018BACKEND_TEST_CASE( "Testing wasm <const_336_wasm>", "[const_336_wasm_tests]" ) {
2019 using backend_t = backend<standalone_function_t, TestType>;
2020 auto code = read_wasm( std::string(wasm_directory) + "const.336.wasm");
2021 backend_t bkend( code, &wa );
2022
2023 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(0));
2024}
2025
2026BACKEND_TEST_CASE( "Testing wasm <const_337_wasm>", "[const_337_wasm_tests]" ) {
2027 using backend_t = backend<standalone_function_t, TestType>;
2028 auto code = read_wasm( std::string(wasm_directory) + "const.337.wasm");
2029 backend_t bkend( code, &wa );
2030
2031 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775808));
2032}
2033
2034BACKEND_TEST_CASE( "Testing wasm <const_338_wasm>", "[const_338_wasm_tests]" ) {
2035 using backend_t = backend<standalone_function_t, TestType>;
2036 auto code = read_wasm( std::string(wasm_directory) + "const.338.wasm");
2037 backend_t bkend( code, &wa );
2038
2039 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1));
2040}
2041
2042BACKEND_TEST_CASE( "Testing wasm <const_339_wasm>", "[const_339_wasm_tests]" ) {
2043 using backend_t = backend<standalone_function_t, TestType>;
2044 auto code = read_wasm( std::string(wasm_directory) + "const.339.wasm");
2045 backend_t bkend( code, &wa );
2046
2047 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775809));
2048}
2049
2050BACKEND_TEST_CASE( "Testing wasm <const_34_wasm>", "[const_34_wasm_tests]" ) {
2051 using backend_t = backend<standalone_function_t, TestType>;
2052 auto code = read_wasm( std::string(wasm_directory) + "const.34.wasm");
2053 backend_t bkend( code, &wa );
2054
2055}
2056
2057BACKEND_TEST_CASE( "Testing wasm <const_340_wasm>", "[const_340_wasm_tests]" ) {
2058 using backend_t = backend<standalone_function_t, TestType>;
2059 auto code = read_wasm( std::string(wasm_directory) + "const.340.wasm");
2060 backend_t bkend( code, &wa );
2061
2062 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1));
2063}
2064
2065BACKEND_TEST_CASE( "Testing wasm <const_341_wasm>", "[const_341_wasm_tests]" ) {
2066 using backend_t = backend<standalone_function_t, TestType>;
2067 auto code = read_wasm( std::string(wasm_directory) + "const.341.wasm");
2068 backend_t bkend( code, &wa );
2069
2070 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775809));
2071}
2072
2073BACKEND_TEST_CASE( "Testing wasm <const_342_wasm>", "[const_342_wasm_tests]" ) {
2074 using backend_t = backend<standalone_function_t, TestType>;
2075 auto code = read_wasm( std::string(wasm_directory) + "const.342.wasm");
2076 backend_t bkend( code, &wa );
2077
2078 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1));
2079}
2080
2081BACKEND_TEST_CASE( "Testing wasm <const_343_wasm>", "[const_343_wasm_tests]" ) {
2082 using backend_t = backend<standalone_function_t, TestType>;
2083 auto code = read_wasm( std::string(wasm_directory) + "const.343.wasm");
2084 backend_t bkend( code, &wa );
2085
2086 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775809));
2087}
2088
2089BACKEND_TEST_CASE( "Testing wasm <const_344_wasm>", "[const_344_wasm_tests]" ) {
2090 using backend_t = backend<standalone_function_t, TestType>;
2091 auto code = read_wasm( std::string(wasm_directory) + "const.344.wasm");
2092 backend_t bkend( code, &wa );
2093
2094 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1));
2095}
2096
2097BACKEND_TEST_CASE( "Testing wasm <const_345_wasm>", "[const_345_wasm_tests]" ) {
2098 using backend_t = backend<standalone_function_t, TestType>;
2099 auto code = read_wasm( std::string(wasm_directory) + "const.345.wasm");
2100 backend_t bkend( code, &wa );
2101
2102 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775809));
2103}
2104
2105BACKEND_TEST_CASE( "Testing wasm <const_346_wasm>", "[const_346_wasm_tests]" ) {
2106 using backend_t = backend<standalone_function_t, TestType>;
2107 auto code = read_wasm( std::string(wasm_directory) + "const.346.wasm");
2108 backend_t bkend( code, &wa );
2109
2110 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1));
2111}
2112
2113BACKEND_TEST_CASE( "Testing wasm <const_347_wasm>", "[const_347_wasm_tests]" ) {
2114 using backend_t = backend<standalone_function_t, TestType>;
2115 auto code = read_wasm( std::string(wasm_directory) + "const.347.wasm");
2116 backend_t bkend( code, &wa );
2117
2118 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775809));
2119}
2120
2121BACKEND_TEST_CASE( "Testing wasm <const_348_wasm>", "[const_348_wasm_tests]" ) {
2122 using backend_t = backend<standalone_function_t, TestType>;
2123 auto code = read_wasm( std::string(wasm_directory) + "const.348.wasm");
2124 backend_t bkend( code, &wa );
2125
2126 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2127}
2128
2129BACKEND_TEST_CASE( "Testing wasm <const_349_wasm>", "[const_349_wasm_tests]" ) {
2130 using backend_t = backend<standalone_function_t, TestType>;
2131 auto code = read_wasm( std::string(wasm_directory) + "const.349.wasm");
2132 backend_t bkend( code, &wa );
2133
2134 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2135}
2136
2137BACKEND_TEST_CASE( "Testing wasm <const_35_wasm>", "[const_35_wasm_tests]" ) {
2138 using backend_t = backend<standalone_function_t, TestType>;
2139 auto code = read_wasm( std::string(wasm_directory) + "const.35.wasm");
2140 backend_t bkend( code, &wa );
2141
2142}
2143
2144BACKEND_TEST_CASE( "Testing wasm <const_350_wasm>", "[const_350_wasm_tests]" ) {
2145 using backend_t = backend<standalone_function_t, TestType>;
2146 auto code = read_wasm( std::string(wasm_directory) + "const.350.wasm");
2147 backend_t bkend( code, &wa );
2148
2149 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2150}
2151
2152BACKEND_TEST_CASE( "Testing wasm <const_351_wasm>", "[const_351_wasm_tests]" ) {
2153 using backend_t = backend<standalone_function_t, TestType>;
2154 auto code = read_wasm( std::string(wasm_directory) + "const.351.wasm");
2155 backend_t bkend( code, &wa );
2156
2157 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2158}
2159
2160BACKEND_TEST_CASE( "Testing wasm <const_352_wasm>", "[const_352_wasm_tests]" ) {
2161 using backend_t = backend<standalone_function_t, TestType>;
2162 auto code = read_wasm( std::string(wasm_directory) + "const.352.wasm");
2163 backend_t bkend( code, &wa );
2164
2165 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2166}
2167
2168BACKEND_TEST_CASE( "Testing wasm <const_353_wasm>", "[const_353_wasm_tests]" ) {
2169 using backend_t = backend<standalone_function_t, TestType>;
2170 auto code = read_wasm( std::string(wasm_directory) + "const.353.wasm");
2171 backend_t bkend( code, &wa );
2172
2173 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2174}
2175
2176BACKEND_TEST_CASE( "Testing wasm <const_354_wasm>", "[const_354_wasm_tests]" ) {
2177 using backend_t = backend<standalone_function_t, TestType>;
2178 auto code = read_wasm( std::string(wasm_directory) + "const.354.wasm");
2179 backend_t bkend( code, &wa );
2180
2181 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2182}
2183
2184BACKEND_TEST_CASE( "Testing wasm <const_355_wasm>", "[const_355_wasm_tests]" ) {
2185 using backend_t = backend<standalone_function_t, TestType>;
2186 auto code = read_wasm( std::string(wasm_directory) + "const.355.wasm");
2187 backend_t bkend( code, &wa );
2188
2189 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2190}
2191
2192BACKEND_TEST_CASE( "Testing wasm <const_356_wasm>", "[const_356_wasm_tests]" ) {
2193 using backend_t = backend<standalone_function_t, TestType>;
2194 auto code = read_wasm( std::string(wasm_directory) + "const.356.wasm");
2195 backend_t bkend( code, &wa );
2196
2197 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2198}
2199
2200BACKEND_TEST_CASE( "Testing wasm <const_357_wasm>", "[const_357_wasm_tests]" ) {
2201 using backend_t = backend<standalone_function_t, TestType>;
2202 auto code = read_wasm( std::string(wasm_directory) + "const.357.wasm");
2203 backend_t bkend( code, &wa );
2204
2205 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2206}
2207
2208BACKEND_TEST_CASE( "Testing wasm <const_358_wasm>", "[const_358_wasm_tests]" ) {
2209 using backend_t = backend<standalone_function_t, TestType>;
2210 auto code = read_wasm( std::string(wasm_directory) + "const.358.wasm");
2211 backend_t bkend( code, &wa );
2212
2213 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2214}
2215
2216BACKEND_TEST_CASE( "Testing wasm <const_359_wasm>", "[const_359_wasm_tests]" ) {
2217 using backend_t = backend<standalone_function_t, TestType>;
2218 auto code = read_wasm( std::string(wasm_directory) + "const.359.wasm");
2219 backend_t bkend( code, &wa );
2220
2221 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2222}
2223
2224BACKEND_TEST_CASE( "Testing wasm <const_360_wasm>", "[const_360_wasm_tests]" ) {
2225 using backend_t = backend<standalone_function_t, TestType>;
2226 auto code = read_wasm( std::string(wasm_directory) + "const.360.wasm");
2227 backend_t bkend( code, &wa );
2228
2229 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2230}
2231
2232BACKEND_TEST_CASE( "Testing wasm <const_361_wasm>", "[const_361_wasm_tests]" ) {
2233 using backend_t = backend<standalone_function_t, TestType>;
2234 auto code = read_wasm( std::string(wasm_directory) + "const.361.wasm");
2235 backend_t bkend( code, &wa );
2236
2237 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2238}
2239
2240BACKEND_TEST_CASE( "Testing wasm <const_362_wasm>", "[const_362_wasm_tests]" ) {
2241 using backend_t = backend<standalone_function_t, TestType>;
2242 auto code = read_wasm( std::string(wasm_directory) + "const.362.wasm");
2243 backend_t bkend( code, &wa );
2244
2245 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(4503599627370499));
2246}
2247
2248BACKEND_TEST_CASE( "Testing wasm <const_363_wasm>", "[const_363_wasm_tests]" ) {
2249 using backend_t = backend<standalone_function_t, TestType>;
2250 auto code = read_wasm( std::string(wasm_directory) + "const.363.wasm");
2251 backend_t bkend( code, &wa );
2252
2253 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9227875636482146307));
2254}
2255
2256BACKEND_TEST_CASE( "Testing wasm <const_364_wasm>", "[const_364_wasm_tests]" ) {
2257 using backend_t = backend<standalone_function_t, TestType>;
2258 auto code = read_wasm( std::string(wasm_directory) + "const.364.wasm");
2259 backend_t bkend( code, &wa );
2260
2261 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9218868437227405311));
2262}
2263
2264BACKEND_TEST_CASE( "Testing wasm <const_365_wasm>", "[const_365_wasm_tests]" ) {
2265 using backend_t = backend<standalone_function_t, TestType>;
2266 auto code = read_wasm( std::string(wasm_directory) + "const.365.wasm");
2267 backend_t bkend( code, &wa );
2268
2269 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(18442240474082181119));
2270}
2271
2272BACKEND_TEST_CASE( "Testing wasm <const_366_wasm>", "[const_366_wasm_tests]" ) {
2273 using backend_t = backend<standalone_function_t, TestType>;
2274 auto code = read_wasm( std::string(wasm_directory) + "const.366.wasm");
2275 backend_t bkend( code, &wa );
2276
2277 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9218868437227405311));
2278}
2279
2280BACKEND_TEST_CASE( "Testing wasm <const_367_wasm>", "[const_367_wasm_tests]" ) {
2281 using backend_t = backend<standalone_function_t, TestType>;
2282 auto code = read_wasm( std::string(wasm_directory) + "const.367.wasm");
2283 backend_t bkend( code, &wa );
2284
2285 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(18442240474082181119));
2286}
2287
2288BACKEND_TEST_CASE( "Testing wasm <const_38_wasm>", "[const_38_wasm_tests]" ) {
2289 using backend_t = backend<standalone_function_t, TestType>;
2290 auto code = read_wasm( std::string(wasm_directory) + "const.38.wasm");
2291 backend_t bkend( code, &wa );
2292
2293}
2294
2295BACKEND_TEST_CASE( "Testing wasm <const_39_wasm>", "[const_39_wasm_tests]" ) {
2296 using backend_t = backend<standalone_function_t, TestType>;
2297 auto code = read_wasm( std::string(wasm_directory) + "const.39.wasm");
2298 backend_t bkend( code, &wa );
2299
2300}
2301
2302BACKEND_TEST_CASE( "Testing wasm <const_4_wasm>", "[const_4_wasm_tests]" ) {
2303 using backend_t = backend<standalone_function_t, TestType>;
2304 auto code = read_wasm( std::string(wasm_directory) + "const.4.wasm");
2305 backend_t bkend( code, &wa );
2306
2307}
2308
2309BACKEND_TEST_CASE( "Testing wasm <const_40_wasm>", "[const_40_wasm_tests]" ) {
2310 using backend_t = backend<standalone_function_t, TestType>;
2311 auto code = read_wasm( std::string(wasm_directory) + "const.40.wasm");
2312 backend_t bkend( code, &wa );
2313
2314}
2315
2316BACKEND_TEST_CASE( "Testing wasm <const_41_wasm>", "[const_41_wasm_tests]" ) {
2317 using backend_t = backend<standalone_function_t, TestType>;
2318 auto code = read_wasm( std::string(wasm_directory) + "const.41.wasm");
2319 backend_t bkend( code, &wa );
2320
2321}
2322
2323BACKEND_TEST_CASE( "Testing wasm <const_42_wasm>", "[const_42_wasm_tests]" ) {
2324 using backend_t = backend<standalone_function_t, TestType>;
2325 auto code = read_wasm( std::string(wasm_directory) + "const.42.wasm");
2326 backend_t bkend( code, &wa );
2327
2328}
2329
2330BACKEND_TEST_CASE( "Testing wasm <const_43_wasm>", "[const_43_wasm_tests]" ) {
2331 using backend_t = backend<standalone_function_t, TestType>;
2332 auto code = read_wasm( std::string(wasm_directory) + "const.43.wasm");
2333 backend_t bkend( code, &wa );
2334
2335}
2336
2337BACKEND_TEST_CASE( "Testing wasm <const_44_wasm>", "[const_44_wasm_tests]" ) {
2338 using backend_t = backend<standalone_function_t, TestType>;
2339 auto code = read_wasm( std::string(wasm_directory) + "const.44.wasm");
2340 backend_t bkend( code, &wa );
2341
2342}
2343
2344BACKEND_TEST_CASE( "Testing wasm <const_45_wasm>", "[const_45_wasm_tests]" ) {
2345 using backend_t = backend<standalone_function_t, TestType>;
2346 auto code = read_wasm( std::string(wasm_directory) + "const.45.wasm");
2347 backend_t bkend( code, &wa );
2348
2349}
2350
2351BACKEND_TEST_CASE( "Testing wasm <const_5_wasm>", "[const_5_wasm_tests]" ) {
2352 using backend_t = backend<standalone_function_t, TestType>;
2353 auto code = read_wasm( std::string(wasm_directory) + "const.5.wasm");
2354 backend_t bkend( code, &wa );
2355
2356}
2357
2358BACKEND_TEST_CASE( "Testing wasm <const_50_wasm>", "[const_50_wasm_tests]" ) {
2359 using backend_t = backend<standalone_function_t, TestType>;
2360 auto code = read_wasm( std::string(wasm_directory) + "const.50.wasm");
2361 backend_t bkend( code, &wa );
2362
2363}
2364
2365BACKEND_TEST_CASE( "Testing wasm <const_51_wasm>", "[const_51_wasm_tests]" ) {
2366 using backend_t = backend<standalone_function_t, TestType>;
2367 auto code = read_wasm( std::string(wasm_directory) + "const.51.wasm");
2368 backend_t bkend( code, &wa );
2369
2370}
2371
2372BACKEND_TEST_CASE( "Testing wasm <const_54_wasm>", "[const_54_wasm_tests]" ) {
2373 using backend_t = backend<standalone_function_t, TestType>;
2374 auto code = read_wasm( std::string(wasm_directory) + "const.54.wasm");
2375 backend_t bkend( code, &wa );
2376
2377}
2378
2379BACKEND_TEST_CASE( "Testing wasm <const_55_wasm>", "[const_55_wasm_tests]" ) {
2380 using backend_t = backend<standalone_function_t, TestType>;
2381 auto code = read_wasm( std::string(wasm_directory) + "const.55.wasm");
2382 backend_t bkend( code, &wa );
2383
2384}
2385
2386BACKEND_TEST_CASE( "Testing wasm <const_58_wasm>", "[const_58_wasm_tests]" ) {
2387 using backend_t = backend<standalone_function_t, TestType>;
2388 auto code = read_wasm( std::string(wasm_directory) + "const.58.wasm");
2389 backend_t bkend( code, &wa );
2390
2391}
2392
2393BACKEND_TEST_CASE( "Testing wasm <const_59_wasm>", "[const_59_wasm_tests]" ) {
2394 using backend_t = backend<standalone_function_t, TestType>;
2395 auto code = read_wasm( std::string(wasm_directory) + "const.59.wasm");
2396 backend_t bkend( code, &wa );
2397
2398}
2399
2400BACKEND_TEST_CASE( "Testing wasm <const_60_wasm>", "[const_60_wasm_tests]" ) {
2401 using backend_t = backend<standalone_function_t, TestType>;
2402 auto code = read_wasm( std::string(wasm_directory) + "const.60.wasm");
2403 backend_t bkend( code, &wa );
2404
2405}
2406
2407BACKEND_TEST_CASE( "Testing wasm <const_61_wasm>", "[const_61_wasm_tests]" ) {
2408 using backend_t = backend<standalone_function_t, TestType>;
2409 auto code = read_wasm( std::string(wasm_directory) + "const.61.wasm");
2410 backend_t bkend( code, &wa );
2411
2412}
2413
2414BACKEND_TEST_CASE( "Testing wasm <const_68_wasm>", "[const_68_wasm_tests]" ) {
2415 using backend_t = backend<standalone_function_t, TestType>;
2416 auto code = read_wasm( std::string(wasm_directory) + "const.68.wasm");
2417 backend_t bkend( code, &wa );
2418
2419 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922816));
2420}
2421
2422BACKEND_TEST_CASE( "Testing wasm <const_69_wasm>", "[const_69_wasm_tests]" ) {
2423 using backend_t = backend<standalone_function_t, TestType>;
2424 auto code = read_wasm( std::string(wasm_directory) + "const.69.wasm");
2425 backend_t bkend( code, &wa );
2426
2427 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406464));
2428}
2429
2430BACKEND_TEST_CASE( "Testing wasm <const_70_wasm>", "[const_70_wasm_tests]" ) {
2431 using backend_t = backend<standalone_function_t, TestType>;
2432 auto code = read_wasm( std::string(wasm_directory) + "const.70.wasm");
2433 backend_t bkend( code, &wa );
2434
2435 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
2436}
2437
2438BACKEND_TEST_CASE( "Testing wasm <const_71_wasm>", "[const_71_wasm_tests]" ) {
2439 using backend_t = backend<standalone_function_t, TestType>;
2440 auto code = read_wasm( std::string(wasm_directory) + "const.71.wasm");
2441 backend_t bkend( code, &wa );
2442
2443 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
2444}
2445
2446BACKEND_TEST_CASE( "Testing wasm <const_72_wasm>", "[const_72_wasm_tests]" ) {
2447 using backend_t = backend<standalone_function_t, TestType>;
2448 auto code = read_wasm( std::string(wasm_directory) + "const.72.wasm");
2449 backend_t bkend( code, &wa );
2450
2451 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
2452}
2453
2454BACKEND_TEST_CASE( "Testing wasm <const_73_wasm>", "[const_73_wasm_tests]" ) {
2455 using backend_t = backend<standalone_function_t, TestType>;
2456 auto code = read_wasm( std::string(wasm_directory) + "const.73.wasm");
2457 backend_t bkend( code, &wa );
2458
2459 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
2460}
2461
2462BACKEND_TEST_CASE( "Testing wasm <const_74_wasm>", "[const_74_wasm_tests]" ) {
2463 using backend_t = backend<standalone_function_t, TestType>;
2464 auto code = read_wasm( std::string(wasm_directory) + "const.74.wasm");
2465 backend_t bkend( code, &wa );
2466
2467 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
2468}
2469
2470BACKEND_TEST_CASE( "Testing wasm <const_75_wasm>", "[const_75_wasm_tests]" ) {
2471 using backend_t = backend<standalone_function_t, TestType>;
2472 auto code = read_wasm( std::string(wasm_directory) + "const.75.wasm");
2473 backend_t bkend( code, &wa );
2474
2475 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
2476}
2477
2478BACKEND_TEST_CASE( "Testing wasm <const_76_wasm>", "[const_76_wasm_tests]" ) {
2479 using backend_t = backend<standalone_function_t, TestType>;
2480 auto code = read_wasm( std::string(wasm_directory) + "const.76.wasm");
2481 backend_t bkend( code, &wa );
2482
2483 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
2484}
2485
2486BACKEND_TEST_CASE( "Testing wasm <const_77_wasm>", "[const_77_wasm_tests]" ) {
2487 using backend_t = backend<standalone_function_t, TestType>;
2488 auto code = read_wasm( std::string(wasm_directory) + "const.77.wasm");
2489 backend_t bkend( code, &wa );
2490
2491 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
2492}
2493
2494BACKEND_TEST_CASE( "Testing wasm <const_78_wasm>", "[const_78_wasm_tests]" ) {
2495 using backend_t = backend<standalone_function_t, TestType>;
2496 auto code = read_wasm( std::string(wasm_directory) + "const.78.wasm");
2497 backend_t bkend( code, &wa );
2498
2499 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
2500}
2501
2502BACKEND_TEST_CASE( "Testing wasm <const_79_wasm>", "[const_79_wasm_tests]" ) {
2503 using backend_t = backend<standalone_function_t, TestType>;
2504 auto code = read_wasm( std::string(wasm_directory) + "const.79.wasm");
2505 backend_t bkend( code, &wa );
2506
2507 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
2508}
2509
2510BACKEND_TEST_CASE( "Testing wasm <const_8_wasm>", "[const_8_wasm_tests]" ) {
2511 using backend_t = backend<standalone_function_t, TestType>;
2512 auto code = read_wasm( std::string(wasm_directory) + "const.8.wasm");
2513 backend_t bkend( code, &wa );
2514
2515}
2516
2517BACKEND_TEST_CASE( "Testing wasm <const_80_wasm>", "[const_80_wasm_tests]" ) {
2518 using backend_t = backend<standalone_function_t, TestType>;
2519 auto code = read_wasm( std::string(wasm_directory) + "const.80.wasm");
2520 backend_t bkend( code, &wa );
2521
2522 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2523}
2524
2525BACKEND_TEST_CASE( "Testing wasm <const_81_wasm>", "[const_81_wasm_tests]" ) {
2526 using backend_t = backend<standalone_function_t, TestType>;
2527 auto code = read_wasm( std::string(wasm_directory) + "const.81.wasm");
2528 backend_t bkend( code, &wa );
2529
2530 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2531}
2532
2533BACKEND_TEST_CASE( "Testing wasm <const_82_wasm>", "[const_82_wasm_tests]" ) {
2534 using backend_t = backend<standalone_function_t, TestType>;
2535 auto code = read_wasm( std::string(wasm_directory) + "const.82.wasm");
2536 backend_t bkend( code, &wa );
2537
2538 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2539}
2540
2541BACKEND_TEST_CASE( "Testing wasm <const_83_wasm>", "[const_83_wasm_tests]" ) {
2542 using backend_t = backend<standalone_function_t, TestType>;
2543 auto code = read_wasm( std::string(wasm_directory) + "const.83.wasm");
2544 backend_t bkend( code, &wa );
2545
2546 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2547}
2548
2549BACKEND_TEST_CASE( "Testing wasm <const_84_wasm>", "[const_84_wasm_tests]" ) {
2550 using backend_t = backend<standalone_function_t, TestType>;
2551 auto code = read_wasm( std::string(wasm_directory) + "const.84.wasm");
2552 backend_t bkend( code, &wa );
2553
2554 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2555}
2556
2557BACKEND_TEST_CASE( "Testing wasm <const_85_wasm>", "[const_85_wasm_tests]" ) {
2558 using backend_t = backend<standalone_function_t, TestType>;
2559 auto code = read_wasm( std::string(wasm_directory) + "const.85.wasm");
2560 backend_t bkend( code, &wa );
2561
2562 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2563}
2564
2565BACKEND_TEST_CASE( "Testing wasm <const_86_wasm>", "[const_86_wasm_tests]" ) {
2566 using backend_t = backend<standalone_function_t, TestType>;
2567 auto code = read_wasm( std::string(wasm_directory) + "const.86.wasm");
2568 backend_t bkend( code, &wa );
2569
2570 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2571}
2572
2573BACKEND_TEST_CASE( "Testing wasm <const_87_wasm>", "[const_87_wasm_tests]" ) {
2574 using backend_t = backend<standalone_function_t, TestType>;
2575 auto code = read_wasm( std::string(wasm_directory) + "const.87.wasm");
2576 backend_t bkend( code, &wa );
2577
2578 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2579}
2580
2581BACKEND_TEST_CASE( "Testing wasm <const_88_wasm>", "[const_88_wasm_tests]" ) {
2582 using backend_t = backend<standalone_function_t, TestType>;
2583 auto code = read_wasm( std::string(wasm_directory) + "const.88.wasm");
2584 backend_t bkend( code, &wa );
2585
2586 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2587}
2588
2589BACKEND_TEST_CASE( "Testing wasm <const_89_wasm>", "[const_89_wasm_tests]" ) {
2590 using backend_t = backend<standalone_function_t, TestType>;
2591 auto code = read_wasm( std::string(wasm_directory) + "const.89.wasm");
2592 backend_t bkend( code, &wa );
2593
2594 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2595}
2596
2597BACKEND_TEST_CASE( "Testing wasm <const_9_wasm>", "[const_9_wasm_tests]" ) {
2598 using backend_t = backend<standalone_function_t, TestType>;
2599 auto code = read_wasm( std::string(wasm_directory) + "const.9.wasm");
2600 backend_t bkend( code, &wa );
2601
2602}
2603
2604BACKEND_TEST_CASE( "Testing wasm <const_90_wasm>", "[const_90_wasm_tests]" ) {
2605 using backend_t = backend<standalone_function_t, TestType>;
2606 auto code = read_wasm( std::string(wasm_directory) + "const.90.wasm");
2607 backend_t bkend( code, &wa );
2608
2609 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2610}
2611
2612BACKEND_TEST_CASE( "Testing wasm <const_91_wasm>", "[const_91_wasm_tests]" ) {
2613 using backend_t = backend<standalone_function_t, TestType>;
2614 auto code = read_wasm( std::string(wasm_directory) + "const.91.wasm");
2615 backend_t bkend( code, &wa );
2616
2617 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2618}
2619
2620BACKEND_TEST_CASE( "Testing wasm <const_92_wasm>", "[const_92_wasm_tests]" ) {
2621 using backend_t = backend<standalone_function_t, TestType>;
2622 auto code = read_wasm( std::string(wasm_directory) + "const.92.wasm");
2623 backend_t bkend( code, &wa );
2624
2625 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2626}
2627
2628BACKEND_TEST_CASE( "Testing wasm <const_93_wasm>", "[const_93_wasm_tests]" ) {
2629 using backend_t = backend<standalone_function_t, TestType>;
2630 auto code = read_wasm( std::string(wasm_directory) + "const.93.wasm");
2631 backend_t bkend( code, &wa );
2632
2633 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2634}
2635
2636BACKEND_TEST_CASE( "Testing wasm <const_94_wasm>", "[const_94_wasm_tests]" ) {
2637 using backend_t = backend<standalone_function_t, TestType>;
2638 auto code = read_wasm( std::string(wasm_directory) + "const.94.wasm");
2639 backend_t bkend( code, &wa );
2640
2641 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922819));
2642}
2643
2644BACKEND_TEST_CASE( "Testing wasm <const_95_wasm>", "[const_95_wasm_tests]" ) {
2645 using backend_t = backend<standalone_function_t, TestType>;
2646 auto code = read_wasm( std::string(wasm_directory) + "const.95.wasm");
2647 backend_t bkend( code, &wa );
2648
2649 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406467));
2650}
2651
2652BACKEND_TEST_CASE( "Testing wasm <const_96_wasm>", "[const_96_wasm_tests]" ) {
2653 using backend_t = backend<standalone_function_t, TestType>;
2654 auto code = read_wasm( std::string(wasm_directory) + "const.96.wasm");
2655 backend_t bkend( code, &wa );
2656
2657 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922816));
2658}
2659
2660BACKEND_TEST_CASE( "Testing wasm <const_97_wasm>", "[const_97_wasm_tests]" ) {
2661 using backend_t = backend<standalone_function_t, TestType>;
2662 auto code = read_wasm( std::string(wasm_directory) + "const.97.wasm");
2663 backend_t bkend( code, &wa );
2664
2665 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406464));
2666}
2667
2668BACKEND_TEST_CASE( "Testing wasm <const_98_wasm>", "[const_98_wasm_tests]" ) {
2669 using backend_t = backend<standalone_function_t, TestType>;
2670 auto code = read_wasm( std::string(wasm_directory) + "const.98.wasm");
2671 backend_t bkend( code, &wa );
2672
2673 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
2674}
2675
2676BACKEND_TEST_CASE( "Testing wasm <const_99_wasm>", "[const_99_wasm_tests]" ) {
2677 using backend_t = backend<standalone_function_t, TestType>;
2678 auto code = read_wasm( std::string(wasm_directory) + "const.99.wasm");
2679 backend_t bkend( code, &wa );
2680
2681 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
2682}
2683
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
sysio::vm::wasm_allocator
Definition allocator.hpp:409
wa
wasm_allocator wa
Definition main.cpp:10
CHECK
#define CHECK(cond)
Definition util.h:80
bkend
backend_t bkend(hello_wasm, ehm, &wa)
sysio::vm::read_wasm
std::vector< uint8_t > read_wasm(const std::string &fname)
Definition utils.hpp:30
catch.hpp
UINT32_C
#define UINT32_C(val)
Definition stdint.h:283
UINT64_C
#define UINT64_C(val)
Definition stdint.h:284
BACKEND_TEST_CASE
#define BACKEND_TEST_CASE(name, tags)
Definition utils.hpp:59
bit_cast
T bit_cast(const U &u)
Definition utils.hpp:35
wasm_config.hpp