Wire Sysio Wire Sysion 1.0.0
Loading...
Searching...
No Matches
Functions | Variables
block_tests.cpp File Reference
#include <algorithm>
#include <vector>
#include <iostream>
#include <iterator>
#include <cmath>
#include <cstdlib>
#include <catch2/catch.hpp>
#include <utils.hpp>
#include <wasm_config.hpp>
#include <sysio/vm/backend.hpp>
Include dependency graph for block_tests.cpp:

Go to the source code of this file.

Functions

 BACKEND_TEST_CASE ("Testing wasm <block_0_wasm>", "[block_0_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_1_wasm>", "[block_1_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_10_wasm>", "[block_10_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_100_wasm>", "[block_100_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_101_wasm>", "[block_101_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_102_wasm>", "[block_102_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_103_wasm>", "[block_103_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_104_wasm>", "[block_104_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_105_wasm>", "[block_105_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_106_wasm>", "[block_106_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_107_wasm>", "[block_107_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_108_wasm>", "[block_108_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_109_wasm>", "[block_109_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_11_wasm>", "[block_11_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_110_wasm>", "[block_110_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_111_wasm>", "[block_111_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_112_wasm>", "[block_112_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_113_wasm>", "[block_113_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_114_wasm>", "[block_114_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_115_wasm>", "[block_115_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_116_wasm>", "[block_116_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_117_wasm>", "[block_117_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_118_wasm>", "[block_118_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_119_wasm>", "[block_119_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_12_wasm>", "[block_12_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_120_wasm>", "[block_120_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_121_wasm>", "[block_121_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_122_wasm>", "[block_122_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_123_wasm>", "[block_123_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_124_wasm>", "[block_124_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_125_wasm>", "[block_125_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_126_wasm>", "[block_126_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_127_wasm>", "[block_127_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_13_wasm>", "[block_13_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_14_wasm>", "[block_14_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_15_wasm>", "[block_15_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_16_wasm>", "[block_16_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_17_wasm>", "[block_17_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_18_wasm>", "[block_18_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_19_wasm>", "[block_19_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_2_wasm>", "[block_2_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_20_wasm>", "[block_20_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_21_wasm>", "[block_21_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_22_wasm>", "[block_22_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_23_wasm>", "[block_23_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_24_wasm>", "[block_24_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_25_wasm>", "[block_25_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_26_wasm>", "[block_26_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_27_wasm>", "[block_27_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_28_wasm>", "[block_28_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_29_wasm>", "[block_29_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_3_wasm>", "[block_3_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_30_wasm>", "[block_30_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_31_wasm>", "[block_31_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_32_wasm>", "[block_32_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_33_wasm>", "[block_33_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_34_wasm>", "[block_34_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_35_wasm>", "[block_35_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_36_wasm>", "[block_36_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_37_wasm>", "[block_37_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_38_wasm>", "[block_38_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_39_wasm>", "[block_39_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_4_wasm>", "[block_4_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_40_wasm>", "[block_40_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_41_wasm>", "[block_41_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_42_wasm>", "[block_42_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_43_wasm>", "[block_43_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_44_wasm>", "[block_44_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_45_wasm>", "[block_45_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_46_wasm>", "[block_46_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_47_wasm>", "[block_47_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_48_wasm>", "[block_48_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_49_wasm>", "[block_49_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_5_wasm>", "[block_5_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_50_wasm>", "[block_50_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_51_wasm>", "[block_51_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_52_wasm>", "[block_52_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_53_wasm>", "[block_53_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_54_wasm>", "[block_54_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_55_wasm>", "[block_55_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_56_wasm>", "[block_56_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_57_wasm>", "[block_57_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_58_wasm>", "[block_58_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_59_wasm>", "[block_59_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_6_wasm>", "[block_6_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_60_wasm>", "[block_60_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_61_wasm>", "[block_61_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_62_wasm>", "[block_62_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_63_wasm>", "[block_63_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_64_wasm>", "[block_64_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_65_wasm>", "[block_65_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_66_wasm>", "[block_66_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_67_wasm>", "[block_67_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_68_wasm>", "[block_68_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_69_wasm>", "[block_69_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_7_wasm>", "[block_7_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_70_wasm>", "[block_70_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_71_wasm>", "[block_71_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_72_wasm>", "[block_72_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_73_wasm>", "[block_73_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_74_wasm>", "[block_74_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_75_wasm>", "[block_75_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_76_wasm>", "[block_76_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_77_wasm>", "[block_77_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_78_wasm>", "[block_78_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_79_wasm>", "[block_79_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_8_wasm>", "[block_8_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_80_wasm>", "[block_80_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_81_wasm>", "[block_81_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_82_wasm>", "[block_82_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_83_wasm>", "[block_83_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_84_wasm>", "[block_84_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_85_wasm>", "[block_85_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_86_wasm>", "[block_86_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_87_wasm>", "[block_87_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_88_wasm>", "[block_88_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_89_wasm>", "[block_89_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_9_wasm>", "[block_9_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_90_wasm>", "[block_90_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_91_wasm>", "[block_91_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_92_wasm>", "[block_92_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_93_wasm>", "[block_93_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_94_wasm>", "[block_94_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_95_wasm>", "[block_95_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_96_wasm>", "[block_96_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_97_wasm>", "[block_97_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_98_wasm>", "[block_98_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <block_99_wasm>", "[block_99_wasm_tests]")
 

Variables

wasm_allocator wa
 

Function Documentation

◆ BACKEND_TEST_CASE() [1/128]

BACKEND_TEST_CASE ( "Testing wasm <block_0_wasm>" ,
"" [block_0_wasm_tests] )

Definition at line 18 of file block_tests.cpp.

18 {
19 using backend_t = backend<standalone_function_t, TestType>;
20 auto code = read_wasm( std::string(wasm_directory) + "block.0.wasm");
21 backend_t bkend( code, &wa );
22
23 CHECK(!bkend.call_with_return("env", "empty"));
24 CHECK(bkend.call_with_return("env", "singular")->to_ui32() == UINT32_C(7));
25 CHECK(bkend.call_with_return("env", "multi")->to_ui32() == UINT32_C(8));
26 CHECK(bkend.call_with_return("env", "nested")->to_ui32() == UINT32_C(9));
27 CHECK(bkend.call_with_return("env", "deep")->to_ui32() == UINT32_C(150));
28 CHECK(bkend.call_with_return("env", "as-select-first")->to_ui32() == UINT32_C(1));
29 CHECK(bkend.call_with_return("env", "as-select-mid")->to_ui32() == UINT32_C(2));
30 CHECK(bkend.call_with_return("env", "as-select-last")->to_ui32() == UINT32_C(2));
31 CHECK(bkend.call_with_return("env", "as-loop-first")->to_ui32() == UINT32_C(1));
32 CHECK(bkend.call_with_return("env", "as-loop-mid")->to_ui32() == UINT32_C(1));
33 CHECK(bkend.call_with_return("env", "as-loop-last")->to_ui32() == UINT32_C(1));
34 CHECK(!bkend.call_with_return("env", "as-if-condition"));
35 CHECK(bkend.call_with_return("env", "as-if-then")->to_ui32() == UINT32_C(1));
36 CHECK(bkend.call_with_return("env", "as-if-else")->to_ui32() == UINT32_C(2));
37 CHECK(bkend.call_with_return("env", "as-br_if-first")->to_ui32() == UINT32_C(1));
38 CHECK(bkend.call_with_return("env", "as-br_if-last")->to_ui32() == UINT32_C(2));
39 CHECK(bkend.call_with_return("env", "as-br_table-first")->to_ui32() == UINT32_C(1));
40 CHECK(bkend.call_with_return("env", "as-br_table-last")->to_ui32() == UINT32_C(2));
41 CHECK(bkend.call_with_return("env", "as-call_indirect-first")->to_ui32() == UINT32_C(1));
42 CHECK(bkend.call_with_return("env", "as-call_indirect-mid")->to_ui32() == UINT32_C(2));
43 CHECK(bkend.call_with_return("env", "as-call_indirect-last")->to_ui32() == UINT32_C(1));
44 CHECK(!bkend.call_with_return("env", "as-store-first"));
45 CHECK(!bkend.call_with_return("env", "as-store-last"));
46 CHECK(bkend.call_with_return("env", "as-memory.grow-value")->to_ui32() == UINT32_C(1));
47 CHECK(bkend.call_with_return("env", "as-call-value")->to_ui32() == UINT32_C(1));
48 CHECK(bkend.call_with_return("env", "as-return-value")->to_ui32() == UINT32_C(1));
49 CHECK(!bkend.call_with_return("env", "as-drop-operand"));
50 CHECK(bkend.call_with_return("env", "as-br-value")->to_ui32() == UINT32_C(1));
51 CHECK(bkend.call_with_return("env", "as-local.set-value")->to_ui32() == UINT32_C(1));
52 CHECK(bkend.call_with_return("env", "as-local.tee-value")->to_ui32() == UINT32_C(1));
53 CHECK(bkend.call_with_return("env", "as-global.set-value")->to_ui32() == UINT32_C(1));
54 CHECK(bkend.call_with_return("env", "as-load-operand")->to_ui32() == UINT32_C(1));
55 CHECK(bkend.call_with_return("env", "as-unary-operand")->to_ui32() == UINT32_C(0));
56 CHECK(bkend.call_with_return("env", "as-binary-operand")->to_ui32() == UINT32_C(12));
57 CHECK(bkend.call_with_return("env", "as-test-operand")->to_ui32() == UINT32_C(0));
58 CHECK(bkend.call_with_return("env", "as-compare-operand")->to_ui32() == UINT32_C(0));
59 CHECK(bkend.call_with_return("env", "break-bare")->to_ui32() == UINT32_C(19));
60 CHECK(bkend.call_with_return("env", "break-value")->to_ui32() == UINT32_C(18));
61 CHECK(bkend.call_with_return("env", "break-repeated")->to_ui32() == UINT32_C(18));
62 CHECK(bkend.call_with_return("env", "break-inner")->to_ui32() == UINT32_C(15));
63 CHECK(bkend.call_with_return("env", "effects")->to_ui32() == UINT32_C(1));
64}
wa
wasm_allocator wa
Definition main.cpp:10
sysio::vm::backend::call_with_return
auto call_with_return(host_t &host, const std::string_view &mod, const std::string_view &func, Args... args)
Definition backend.hpp:178
CHECK
#define CHECK(cond)
Definition util.h:80
bkend
backend_t bkend(hello_wasm, ehm, &wa)
sysio::vm::read_wasm
std::vector< uint8_t > read_wasm(const std::string &fname)
Definition utils.hpp:30
UINT32_C
#define UINT32_C(val)
Definition stdint.h:283
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [2/128]

BACKEND_TEST_CASE ( "Testing wasm <block_100_wasm>" ,
"" [block_100_wasm_tests] )

Definition at line 78 of file block_tests.cpp.

78 {
79 using backend_t = backend<standalone_function_t, TestType>;
80 auto code = read_wasm( std::string(wasm_directory) + "block.100.wasm");
81 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
82}
backend_t
sysio::vm::backend< rhf_t > backend_t
Definition hello_driver.cpp:61
CHECK_THROWS_AS
#define CHECK_THROWS_AS(expr, exceptionType)
Definition catch.hpp:203
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [3/128]

BACKEND_TEST_CASE ( "Testing wasm <block_101_wasm>" ,
"" [block_101_wasm_tests] )

Definition at line 84 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [4/128]

BACKEND_TEST_CASE ( "Testing wasm <block_102_wasm>" ,
"" [block_102_wasm_tests] )

Definition at line 90 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [5/128]

BACKEND_TEST_CASE ( "Testing wasm <block_103_wasm>" ,
"" [block_103_wasm_tests] )

Definition at line 96 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [6/128]

BACKEND_TEST_CASE ( "Testing wasm <block_104_wasm>" ,
"" [block_104_wasm_tests] )

Definition at line 102 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [7/128]

BACKEND_TEST_CASE ( "Testing wasm <block_105_wasm>" ,
"" [block_105_wasm_tests] )

Definition at line 108 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [8/128]

BACKEND_TEST_CASE ( "Testing wasm <block_106_wasm>" ,
"" [block_106_wasm_tests] )

Definition at line 114 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [9/128]

BACKEND_TEST_CASE ( "Testing wasm <block_107_wasm>" ,
"" [block_107_wasm_tests] )

Definition at line 120 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [10/128]

BACKEND_TEST_CASE ( "Testing wasm <block_108_wasm>" ,
"" [block_108_wasm_tests] )

Definition at line 126 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [11/128]

BACKEND_TEST_CASE ( "Testing wasm <block_109_wasm>" ,
"" [block_109_wasm_tests] )

Definition at line 132 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [12/128]

BACKEND_TEST_CASE ( "Testing wasm <block_10_wasm>" ,
"" [block_10_wasm_tests] )

Definition at line 72 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [13/128]

BACKEND_TEST_CASE ( "Testing wasm <block_110_wasm>" ,
"" [block_110_wasm_tests] )

Definition at line 144 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [14/128]

BACKEND_TEST_CASE ( "Testing wasm <block_111_wasm>" ,
"" [block_111_wasm_tests] )

Definition at line 150 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [15/128]

BACKEND_TEST_CASE ( "Testing wasm <block_112_wasm>" ,
"" [block_112_wasm_tests] )

Definition at line 156 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [16/128]

BACKEND_TEST_CASE ( "Testing wasm <block_113_wasm>" ,
"" [block_113_wasm_tests] )

Definition at line 162 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [17/128]

BACKEND_TEST_CASE ( "Testing wasm <block_114_wasm>" ,
"" [block_114_wasm_tests] )

Definition at line 168 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [18/128]

BACKEND_TEST_CASE ( "Testing wasm <block_115_wasm>" ,
"" [block_115_wasm_tests] )

Definition at line 174 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [19/128]

BACKEND_TEST_CASE ( "Testing wasm <block_116_wasm>" ,
"" [block_116_wasm_tests] )

Definition at line 180 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [20/128]

BACKEND_TEST_CASE ( "Testing wasm <block_117_wasm>" ,
"" [block_117_wasm_tests] )

Definition at line 186 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [21/128]

BACKEND_TEST_CASE ( "Testing wasm <block_118_wasm>" ,
"" [block_118_wasm_tests] )

Definition at line 192 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [22/128]

BACKEND_TEST_CASE ( "Testing wasm <block_119_wasm>" ,
"" [block_119_wasm_tests] )

Definition at line 198 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [23/128]

BACKEND_TEST_CASE ( "Testing wasm <block_11_wasm>" ,
"" [block_11_wasm_tests] )

Definition at line 138 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [24/128]

BACKEND_TEST_CASE ( "Testing wasm <block_120_wasm>" ,
"" [block_120_wasm_tests] )

Definition at line 210 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [25/128]

BACKEND_TEST_CASE ( "Testing wasm <block_121_wasm>" ,
"" [block_121_wasm_tests] )

Definition at line 216 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [26/128]

BACKEND_TEST_CASE ( "Testing wasm <block_122_wasm>" ,
"" [block_122_wasm_tests] )

Definition at line 222 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [27/128]

BACKEND_TEST_CASE ( "Testing wasm <block_123_wasm>" ,
"" [block_123_wasm_tests] )

Definition at line 228 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [28/128]

BACKEND_TEST_CASE ( "Testing wasm <block_124_wasm>" ,
"" [block_124_wasm_tests] )

Definition at line 234 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [29/128]

BACKEND_TEST_CASE ( "Testing wasm <block_125_wasm>" ,
"" [block_125_wasm_tests] )

Definition at line 240 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [30/128]

BACKEND_TEST_CASE ( "Testing wasm <block_126_wasm>" ,
"" [block_126_wasm_tests] )

Definition at line 246 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [31/128]

BACKEND_TEST_CASE ( "Testing wasm <block_127_wasm>" ,
"" [block_127_wasm_tests] )

Definition at line 252 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [32/128]

BACKEND_TEST_CASE ( "Testing wasm <block_12_wasm>" ,
"" [block_12_wasm_tests] )

Definition at line 204 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [33/128]

BACKEND_TEST_CASE ( "Testing wasm <block_13_wasm>" ,
"" [block_13_wasm_tests] )

Definition at line 258 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [34/128]

BACKEND_TEST_CASE ( "Testing wasm <block_14_wasm>" ,
"" [block_14_wasm_tests] )

Definition at line 264 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [35/128]

BACKEND_TEST_CASE ( "Testing wasm <block_15_wasm>" ,
"" [block_15_wasm_tests] )

Definition at line 270 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [36/128]

BACKEND_TEST_CASE ( "Testing wasm <block_16_wasm>" ,
"" [block_16_wasm_tests] )

Definition at line 276 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [37/128]

BACKEND_TEST_CASE ( "Testing wasm <block_17_wasm>" ,
"" [block_17_wasm_tests] )

Definition at line 282 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [38/128]

BACKEND_TEST_CASE ( "Testing wasm <block_18_wasm>" ,
"" [block_18_wasm_tests] )

Definition at line 288 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [39/128]

BACKEND_TEST_CASE ( "Testing wasm <block_19_wasm>" ,
"" [block_19_wasm_tests] )

Definition at line 294 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [40/128]

BACKEND_TEST_CASE ( "Testing wasm <block_1_wasm>" ,
"" [block_1_wasm_tests] )

Definition at line 66 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [41/128]

BACKEND_TEST_CASE ( "Testing wasm <block_20_wasm>" ,
"" [block_20_wasm_tests] )

Definition at line 306 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [42/128]

BACKEND_TEST_CASE ( "Testing wasm <block_21_wasm>" ,
"" [block_21_wasm_tests] )

Definition at line 312 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [43/128]

BACKEND_TEST_CASE ( "Testing wasm <block_22_wasm>" ,
"" [block_22_wasm_tests] )

Definition at line 318 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [44/128]

BACKEND_TEST_CASE ( "Testing wasm <block_23_wasm>" ,
"" [block_23_wasm_tests] )

Definition at line 324 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [45/128]

BACKEND_TEST_CASE ( "Testing wasm <block_24_wasm>" ,
"" [block_24_wasm_tests] )

Definition at line 330 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [46/128]

BACKEND_TEST_CASE ( "Testing wasm <block_25_wasm>" ,
"" [block_25_wasm_tests] )

Definition at line 336 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [47/128]

BACKEND_TEST_CASE ( "Testing wasm <block_26_wasm>" ,
"" [block_26_wasm_tests] )

Definition at line 342 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [48/128]

BACKEND_TEST_CASE ( "Testing wasm <block_27_wasm>" ,
"" [block_27_wasm_tests] )

Definition at line 348 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [49/128]

BACKEND_TEST_CASE ( "Testing wasm <block_28_wasm>" ,
"" [block_28_wasm_tests] )

Definition at line 354 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [50/128]

BACKEND_TEST_CASE ( "Testing wasm <block_29_wasm>" ,
"" [block_29_wasm_tests] )

Definition at line 360 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [51/128]

BACKEND_TEST_CASE ( "Testing wasm <block_2_wasm>" ,
"" [block_2_wasm_tests] )

Definition at line 300 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [52/128]

BACKEND_TEST_CASE ( "Testing wasm <block_30_wasm>" ,
"" [block_30_wasm_tests] )

Definition at line 372 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [53/128]

BACKEND_TEST_CASE ( "Testing wasm <block_31_wasm>" ,
"" [block_31_wasm_tests] )

Definition at line 378 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [54/128]

BACKEND_TEST_CASE ( "Testing wasm <block_32_wasm>" ,
"" [block_32_wasm_tests] )

Definition at line 384 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [55/128]

BACKEND_TEST_CASE ( "Testing wasm <block_33_wasm>" ,
"" [block_33_wasm_tests] )

Definition at line 390 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [56/128]

BACKEND_TEST_CASE ( "Testing wasm <block_34_wasm>" ,
"" [block_34_wasm_tests] )

Definition at line 396 of file block_tests.cpp.

396 {
397 using backend_t = backend<standalone_function_t, TestType>;
398 auto code = read_wasm( std::string(wasm_directory) + "block.34.wasm");
399 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
400}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [57/128]

BACKEND_TEST_CASE ( "Testing wasm <block_35_wasm>" ,
"" [block_35_wasm_tests] )

Definition at line 402 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [58/128]

BACKEND_TEST_CASE ( "Testing wasm <block_36_wasm>" ,
"" [block_36_wasm_tests] )

Definition at line 408 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [59/128]

BACKEND_TEST_CASE ( "Testing wasm <block_37_wasm>" ,
"" [block_37_wasm_tests] )

Definition at line 414 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [60/128]

BACKEND_TEST_CASE ( "Testing wasm <block_38_wasm>" ,
"" [block_38_wasm_tests] )

Definition at line 420 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [61/128]

BACKEND_TEST_CASE ( "Testing wasm <block_39_wasm>" ,
"" [block_39_wasm_tests] )

Definition at line 426 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [62/128]

BACKEND_TEST_CASE ( "Testing wasm <block_3_wasm>" ,
"" [block_3_wasm_tests] )

Definition at line 366 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [63/128]

BACKEND_TEST_CASE ( "Testing wasm <block_40_wasm>" ,
"" [block_40_wasm_tests] )

Definition at line 438 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [64/128]

BACKEND_TEST_CASE ( "Testing wasm <block_41_wasm>" ,
"" [block_41_wasm_tests] )

Definition at line 444 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [65/128]

BACKEND_TEST_CASE ( "Testing wasm <block_42_wasm>" ,
"" [block_42_wasm_tests] )

Definition at line 450 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [66/128]

BACKEND_TEST_CASE ( "Testing wasm <block_43_wasm>" ,
"" [block_43_wasm_tests] )

Definition at line 456 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [67/128]

BACKEND_TEST_CASE ( "Testing wasm <block_44_wasm>" ,
"" [block_44_wasm_tests] )

Definition at line 462 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [68/128]

BACKEND_TEST_CASE ( "Testing wasm <block_45_wasm>" ,
"" [block_45_wasm_tests] )

Definition at line 468 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [69/128]

BACKEND_TEST_CASE ( "Testing wasm <block_46_wasm>" ,
"" [block_46_wasm_tests] )

Definition at line 474 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [70/128]

BACKEND_TEST_CASE ( "Testing wasm <block_47_wasm>" ,
"" [block_47_wasm_tests] )

Definition at line 480 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [71/128]

BACKEND_TEST_CASE ( "Testing wasm <block_48_wasm>" ,
"" [block_48_wasm_tests] )

Definition at line 486 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [72/128]

BACKEND_TEST_CASE ( "Testing wasm <block_49_wasm>" ,
"" [block_49_wasm_tests] )

Definition at line 492 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [73/128]

BACKEND_TEST_CASE ( "Testing wasm <block_4_wasm>" ,
"" [block_4_wasm_tests] )

Definition at line 432 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [74/128]

BACKEND_TEST_CASE ( "Testing wasm <block_50_wasm>" ,
"" [block_50_wasm_tests] )

Definition at line 504 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [75/128]

BACKEND_TEST_CASE ( "Testing wasm <block_51_wasm>" ,
"" [block_51_wasm_tests] )

Definition at line 510 of file block_tests.cpp.

510 {
511 using backend_t = backend<standalone_function_t, TestType>;
512 auto code = read_wasm( std::string(wasm_directory) + "block.51.wasm");
513 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
514}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [76/128]

BACKEND_TEST_CASE ( "Testing wasm <block_52_wasm>" ,
"" [block_52_wasm_tests] )

Definition at line 516 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [77/128]

BACKEND_TEST_CASE ( "Testing wasm <block_53_wasm>" ,
"" [block_53_wasm_tests] )

Definition at line 522 of file block_tests.cpp.

522 {
523 using backend_t = backend<standalone_function_t, TestType>;
524 auto code = read_wasm( std::string(wasm_directory) + "block.53.wasm");
525 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
526}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [78/128]

BACKEND_TEST_CASE ( "Testing wasm <block_54_wasm>" ,
"" [block_54_wasm_tests] )

Definition at line 528 of file block_tests.cpp.

528 {
529 using backend_t = backend<standalone_function_t, TestType>;
530 auto code = read_wasm( std::string(wasm_directory) + "block.54.wasm");
531 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
532}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [79/128]

BACKEND_TEST_CASE ( "Testing wasm <block_55_wasm>" ,
"" [block_55_wasm_tests] )

Definition at line 534 of file block_tests.cpp.

534 {
535 using backend_t = backend<standalone_function_t, TestType>;
536 auto code = read_wasm( std::string(wasm_directory) + "block.55.wasm");
537 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
538}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [80/128]

BACKEND_TEST_CASE ( "Testing wasm <block_56_wasm>" ,
"" [block_56_wasm_tests] )

Definition at line 540 of file block_tests.cpp.

540 {
541 using backend_t = backend<standalone_function_t, TestType>;
542 auto code = read_wasm( std::string(wasm_directory) + "block.56.wasm");
543 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
544}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [81/128]

BACKEND_TEST_CASE ( "Testing wasm <block_57_wasm>" ,
"" [block_57_wasm_tests] )

Definition at line 546 of file block_tests.cpp.

546 {
547 using backend_t = backend<standalone_function_t, TestType>;
548 auto code = read_wasm( std::string(wasm_directory) + "block.57.wasm");
549 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
550}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [82/128]

BACKEND_TEST_CASE ( "Testing wasm <block_58_wasm>" ,
"" [block_58_wasm_tests] )

Definition at line 552 of file block_tests.cpp.

552 {
553 using backend_t = backend<standalone_function_t, TestType>;
554 auto code = read_wasm( std::string(wasm_directory) + "block.58.wasm");
555 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
556}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [83/128]

BACKEND_TEST_CASE ( "Testing wasm <block_59_wasm>" ,
"" [block_59_wasm_tests] )

Definition at line 558 of file block_tests.cpp.

558 {
559 using backend_t = backend<standalone_function_t, TestType>;
560 auto code = read_wasm( std::string(wasm_directory) + "block.59.wasm");
561 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
562}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [84/128]

BACKEND_TEST_CASE ( "Testing wasm <block_5_wasm>" ,
"" [block_5_wasm_tests] )

Definition at line 498 of file block_tests.cpp.

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

◆ BACKEND_TEST_CASE() [85/128]

BACKEND_TEST_CASE ( "Testing wasm <block_60_wasm>" ,
"" [block_60_wasm_tests] )

Definition at line 570 of file block_tests.cpp.

570 {
571 using backend_t = backend<standalone_function_t, TestType>;
572 auto code = read_wasm( std::string(wasm_directory) + "block.60.wasm");
573 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
574}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [86/128]

BACKEND_TEST_CASE ( "Testing wasm <block_61_wasm>" ,
"" [block_61_wasm_tests] )

Definition at line 576 of file block_tests.cpp.

576 {
577 using backend_t = backend<standalone_function_t, TestType>;
578 auto code = read_wasm( std::string(wasm_directory) + "block.61.wasm");
579 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
580}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [87/128]

BACKEND_TEST_CASE ( "Testing wasm <block_62_wasm>" ,
"" [block_62_wasm_tests] )

Definition at line 582 of file block_tests.cpp.

582 {
583 using backend_t = backend<standalone_function_t, TestType>;
584 auto code = read_wasm( std::string(wasm_directory) + "block.62.wasm");
585 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
586}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [88/128]

BACKEND_TEST_CASE ( "Testing wasm <block_63_wasm>" ,
"" [block_63_wasm_tests] )

Definition at line 588 of file block_tests.cpp.

588 {
589 using backend_t = backend<standalone_function_t, TestType>;
590 auto code = read_wasm( std::string(wasm_directory) + "block.63.wasm");
591 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
592}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [89/128]

BACKEND_TEST_CASE ( "Testing wasm <block_64_wasm>" ,
"" [block_64_wasm_tests] )

Definition at line 594 of file block_tests.cpp.

594 {
595 using backend_t = backend<standalone_function_t, TestType>;
596 auto code = read_wasm( std::string(wasm_directory) + "block.64.wasm");
597 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
598}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [90/128]

BACKEND_TEST_CASE ( "Testing wasm <block_65_wasm>" ,
"" [block_65_wasm_tests] )

Definition at line 600 of file block_tests.cpp.

600 {
601 using backend_t = backend<standalone_function_t, TestType>;
602 auto code = read_wasm( std::string(wasm_directory) + "block.65.wasm");
603 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
604}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [91/128]

BACKEND_TEST_CASE ( "Testing wasm <block_66_wasm>" ,
"" [block_66_wasm_tests] )

Definition at line 606 of file block_tests.cpp.

606 {
607 using backend_t = backend<standalone_function_t, TestType>;
608 auto code = read_wasm( std::string(wasm_directory) + "block.66.wasm");
609 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
610}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [92/128]

BACKEND_TEST_CASE ( "Testing wasm <block_67_wasm>" ,
"" [block_67_wasm_tests] )

Definition at line 612 of file block_tests.cpp.

612 {
613 using backend_t = backend<standalone_function_t, TestType>;
614 auto code = read_wasm( std::string(wasm_directory) + "block.67.wasm");
615 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
616}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [93/128]

BACKEND_TEST_CASE ( "Testing wasm <block_68_wasm>" ,
"" [block_68_wasm_tests] )

Definition at line 618 of file block_tests.cpp.

618 {
619 using backend_t = backend<standalone_function_t, TestType>;
620 auto code = read_wasm( std::string(wasm_directory) + "block.68.wasm");
621 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
622}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [94/128]

BACKEND_TEST_CASE ( "Testing wasm <block_69_wasm>" ,
"" [block_69_wasm_tests] )

Definition at line 624 of file block_tests.cpp.

624 {
625 using backend_t = backend<standalone_function_t, TestType>;
626 auto code = read_wasm( std::string(wasm_directory) + "block.69.wasm");
627 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
628}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [95/128]

BACKEND_TEST_CASE ( "Testing wasm <block_6_wasm>" ,
"" [block_6_wasm_tests] )

Definition at line 564 of file block_tests.cpp.

564 {
565 using backend_t = backend<standalone_function_t, TestType>;
566 auto code = read_wasm( std::string(wasm_directory) + "block.6.wasm");
567 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
568}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [96/128]

BACKEND_TEST_CASE ( "Testing wasm <block_70_wasm>" ,
"" [block_70_wasm_tests] )

Definition at line 636 of file block_tests.cpp.

636 {
637 using backend_t = backend<standalone_function_t, TestType>;
638 auto code = read_wasm( std::string(wasm_directory) + "block.70.wasm");
639 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
640}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [97/128]

BACKEND_TEST_CASE ( "Testing wasm <block_71_wasm>" ,
"" [block_71_wasm_tests] )

Definition at line 642 of file block_tests.cpp.

642 {
643 using backend_t = backend<standalone_function_t, TestType>;
644 auto code = read_wasm( std::string(wasm_directory) + "block.71.wasm");
645 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
646}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [98/128]

BACKEND_TEST_CASE ( "Testing wasm <block_72_wasm>" ,
"" [block_72_wasm_tests] )

Definition at line 648 of file block_tests.cpp.

648 {
649 using backend_t = backend<standalone_function_t, TestType>;
650 auto code = read_wasm( std::string(wasm_directory) + "block.72.wasm");
651 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
652}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [99/128]

BACKEND_TEST_CASE ( "Testing wasm <block_73_wasm>" ,
"" [block_73_wasm_tests] )

Definition at line 654 of file block_tests.cpp.

654 {
655 using backend_t = backend<standalone_function_t, TestType>;
656 auto code = read_wasm( std::string(wasm_directory) + "block.73.wasm");
657 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
658}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [100/128]

BACKEND_TEST_CASE ( "Testing wasm <block_74_wasm>" ,
"" [block_74_wasm_tests] )

Definition at line 660 of file block_tests.cpp.

660 {
661 using backend_t = backend<standalone_function_t, TestType>;
662 auto code = read_wasm( std::string(wasm_directory) + "block.74.wasm");
663 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
664}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [101/128]

BACKEND_TEST_CASE ( "Testing wasm <block_75_wasm>" ,
"" [block_75_wasm_tests] )

Definition at line 666 of file block_tests.cpp.

666 {
667 using backend_t = backend<standalone_function_t, TestType>;
668 auto code = read_wasm( std::string(wasm_directory) + "block.75.wasm");
669 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
670}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [102/128]

BACKEND_TEST_CASE ( "Testing wasm <block_76_wasm>" ,
"" [block_76_wasm_tests] )

Definition at line 672 of file block_tests.cpp.

672 {
673 using backend_t = backend<standalone_function_t, TestType>;
674 auto code = read_wasm( std::string(wasm_directory) + "block.76.wasm");
675 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
676}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [103/128]

BACKEND_TEST_CASE ( "Testing wasm <block_77_wasm>" ,
"" [block_77_wasm_tests] )

Definition at line 678 of file block_tests.cpp.

678 {
679 using backend_t = backend<standalone_function_t, TestType>;
680 auto code = read_wasm( std::string(wasm_directory) + "block.77.wasm");
681 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
682}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [104/128]

BACKEND_TEST_CASE ( "Testing wasm <block_78_wasm>" ,
"" [block_78_wasm_tests] )

Definition at line 684 of file block_tests.cpp.

684 {
685 using backend_t = backend<standalone_function_t, TestType>;
686 auto code = read_wasm( std::string(wasm_directory) + "block.78.wasm");
687 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
688}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [105/128]

BACKEND_TEST_CASE ( "Testing wasm <block_79_wasm>" ,
"" [block_79_wasm_tests] )

Definition at line 690 of file block_tests.cpp.

690 {
691 using backend_t = backend<standalone_function_t, TestType>;
692 auto code = read_wasm( std::string(wasm_directory) + "block.79.wasm");
693 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
694}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [106/128]

BACKEND_TEST_CASE ( "Testing wasm <block_7_wasm>" ,
"" [block_7_wasm_tests] )

Definition at line 630 of file block_tests.cpp.

630 {
631 using backend_t = backend<standalone_function_t, TestType>;
632 auto code = read_wasm( std::string(wasm_directory) + "block.7.wasm");
633 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
634}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [107/128]

BACKEND_TEST_CASE ( "Testing wasm <block_80_wasm>" ,
"" [block_80_wasm_tests] )

Definition at line 702 of file block_tests.cpp.

702 {
703 using backend_t = backend<standalone_function_t, TestType>;
704 auto code = read_wasm( std::string(wasm_directory) + "block.80.wasm");
705 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
706}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [108/128]

BACKEND_TEST_CASE ( "Testing wasm <block_81_wasm>" ,
"" [block_81_wasm_tests] )

Definition at line 708 of file block_tests.cpp.

708 {
709 using backend_t = backend<standalone_function_t, TestType>;
710 auto code = read_wasm( std::string(wasm_directory) + "block.81.wasm");
711 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
712}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [109/128]

BACKEND_TEST_CASE ( "Testing wasm <block_82_wasm>" ,
"" [block_82_wasm_tests] )

Definition at line 714 of file block_tests.cpp.

714 {
715 using backend_t = backend<standalone_function_t, TestType>;
716 auto code = read_wasm( std::string(wasm_directory) + "block.82.wasm");
717 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
718}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [110/128]

BACKEND_TEST_CASE ( "Testing wasm <block_83_wasm>" ,
"" [block_83_wasm_tests] )

Definition at line 720 of file block_tests.cpp.

720 {
721 using backend_t = backend<standalone_function_t, TestType>;
722 auto code = read_wasm( std::string(wasm_directory) + "block.83.wasm");
723 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
724}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [111/128]

BACKEND_TEST_CASE ( "Testing wasm <block_84_wasm>" ,
"" [block_84_wasm_tests] )

Definition at line 726 of file block_tests.cpp.

726 {
727 using backend_t = backend<standalone_function_t, TestType>;
728 auto code = read_wasm( std::string(wasm_directory) + "block.84.wasm");
729 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
730}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [112/128]

BACKEND_TEST_CASE ( "Testing wasm <block_85_wasm>" ,
"" [block_85_wasm_tests] )

Definition at line 732 of file block_tests.cpp.

732 {
733 using backend_t = backend<standalone_function_t, TestType>;
734 auto code = read_wasm( std::string(wasm_directory) + "block.85.wasm");
735 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
736}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [113/128]

BACKEND_TEST_CASE ( "Testing wasm <block_86_wasm>" ,
"" [block_86_wasm_tests] )

Definition at line 738 of file block_tests.cpp.

738 {
739 using backend_t = backend<standalone_function_t, TestType>;
740 auto code = read_wasm( std::string(wasm_directory) + "block.86.wasm");
741 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
742}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [114/128]

BACKEND_TEST_CASE ( "Testing wasm <block_87_wasm>" ,
"" [block_87_wasm_tests] )

Definition at line 744 of file block_tests.cpp.

744 {
745 using backend_t = backend<standalone_function_t, TestType>;
746 auto code = read_wasm( std::string(wasm_directory) + "block.87.wasm");
747 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
748}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [115/128]

BACKEND_TEST_CASE ( "Testing wasm <block_88_wasm>" ,
"" [block_88_wasm_tests] )

Definition at line 750 of file block_tests.cpp.

750 {
751 using backend_t = backend<standalone_function_t, TestType>;
752 auto code = read_wasm( std::string(wasm_directory) + "block.88.wasm");
753 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
754}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [116/128]

BACKEND_TEST_CASE ( "Testing wasm <block_89_wasm>" ,
"" [block_89_wasm_tests] )

Definition at line 756 of file block_tests.cpp.

756 {
757 using backend_t = backend<standalone_function_t, TestType>;
758 auto code = read_wasm( std::string(wasm_directory) + "block.89.wasm");
759 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
760}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [117/128]

BACKEND_TEST_CASE ( "Testing wasm <block_8_wasm>" ,
"" [block_8_wasm_tests] )

Definition at line 696 of file block_tests.cpp.

696 {
697 using backend_t = backend<standalone_function_t, TestType>;
698 auto code = read_wasm( std::string(wasm_directory) + "block.8.wasm");
699 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
700}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [118/128]

BACKEND_TEST_CASE ( "Testing wasm <block_90_wasm>" ,
"" [block_90_wasm_tests] )

Definition at line 768 of file block_tests.cpp.

768 {
769 using backend_t = backend<standalone_function_t, TestType>;
770 auto code = read_wasm( std::string(wasm_directory) + "block.90.wasm");
771 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
772}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [119/128]

BACKEND_TEST_CASE ( "Testing wasm <block_91_wasm>" ,
"" [block_91_wasm_tests] )

Definition at line 774 of file block_tests.cpp.

774 {
775 using backend_t = backend<standalone_function_t, TestType>;
776 auto code = read_wasm( std::string(wasm_directory) + "block.91.wasm");
777 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
778}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [120/128]

BACKEND_TEST_CASE ( "Testing wasm <block_92_wasm>" ,
"" [block_92_wasm_tests] )

Definition at line 780 of file block_tests.cpp.

780 {
781 using backend_t = backend<standalone_function_t, TestType>;
782 auto code = read_wasm( std::string(wasm_directory) + "block.92.wasm");
783 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
784}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [121/128]

BACKEND_TEST_CASE ( "Testing wasm <block_93_wasm>" ,
"" [block_93_wasm_tests] )

Definition at line 786 of file block_tests.cpp.

786 {
787 using backend_t = backend<standalone_function_t, TestType>;
788 auto code = read_wasm( std::string(wasm_directory) + "block.93.wasm");
789 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
790}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [122/128]

BACKEND_TEST_CASE ( "Testing wasm <block_94_wasm>" ,
"" [block_94_wasm_tests] )

Definition at line 792 of file block_tests.cpp.

792 {
793 using backend_t = backend<standalone_function_t, TestType>;
794 auto code = read_wasm( std::string(wasm_directory) + "block.94.wasm");
795 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
796}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [123/128]

BACKEND_TEST_CASE ( "Testing wasm <block_95_wasm>" ,
"" [block_95_wasm_tests] )

Definition at line 798 of file block_tests.cpp.

798 {
799 using backend_t = backend<standalone_function_t, TestType>;
800 auto code = read_wasm( std::string(wasm_directory) + "block.95.wasm");
801 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
802}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [124/128]

BACKEND_TEST_CASE ( "Testing wasm <block_96_wasm>" ,
"" [block_96_wasm_tests] )

Definition at line 804 of file block_tests.cpp.

804 {
805 using backend_t = backend<standalone_function_t, TestType>;
806 auto code = read_wasm( std::string(wasm_directory) + "block.96.wasm");
807 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
808}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [125/128]

BACKEND_TEST_CASE ( "Testing wasm <block_97_wasm>" ,
"" [block_97_wasm_tests] )

Definition at line 810 of file block_tests.cpp.

810 {
811 using backend_t = backend<standalone_function_t, TestType>;
812 auto code = read_wasm( std::string(wasm_directory) + "block.97.wasm");
813 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
814}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [126/128]

BACKEND_TEST_CASE ( "Testing wasm <block_98_wasm>" ,
"" [block_98_wasm_tests] )

Definition at line 816 of file block_tests.cpp.

816 {
817 using backend_t = backend<standalone_function_t, TestType>;
818 auto code = read_wasm( std::string(wasm_directory) + "block.98.wasm");
819 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
820}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [127/128]

BACKEND_TEST_CASE ( "Testing wasm <block_99_wasm>" ,
"" [block_99_wasm_tests] )

Definition at line 822 of file block_tests.cpp.

822 {
823 using backend_t = backend<standalone_function_t, TestType>;
824 auto code = read_wasm( std::string(wasm_directory) + "block.99.wasm");
825 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
826}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [128/128]

BACKEND_TEST_CASE ( "Testing wasm <block_9_wasm>" ,
"" [block_9_wasm_tests] )

Definition at line 762 of file block_tests.cpp.

762 {
763 using backend_t = backend<standalone_function_t, TestType>;
764 auto code = read_wasm( std::string(wasm_directory) + "block.9.wasm");
765 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
766}
Here is the call graph for this function:

Variable Documentation

◆ wa

wasm_allocator wa
extern

Definition at line 10 of file main.cpp.