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

Go to the source code of this file.

Functions

 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_0_wasm>", "[unreached-invalid_0_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_1_wasm>", "[unreached-invalid_1_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_10_wasm>", "[unreached-invalid_10_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_100_wasm>", "[unreached-invalid_100_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_101_wasm>", "[unreached-invalid_101_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_102_wasm>", "[unreached-invalid_102_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_103_wasm>", "[unreached-invalid_103_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_104_wasm>", "[unreached-invalid_104_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_105_wasm>", "[unreached-invalid_105_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_106_wasm>", "[unreached-invalid_106_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_107_wasm>", "[unreached-invalid_107_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_108_wasm>", "[unreached-invalid_108_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_109_wasm>", "[unreached-invalid_109_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_11_wasm>", "[unreached-invalid_11_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_110_wasm>", "[unreached-invalid_110_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_12_wasm>", "[unreached-invalid_12_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_13_wasm>", "[unreached-invalid_13_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_14_wasm>", "[unreached-invalid_14_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_15_wasm>", "[unreached-invalid_15_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_16_wasm>", "[unreached-invalid_16_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_17_wasm>", "[unreached-invalid_17_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_18_wasm>", "[unreached-invalid_18_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_19_wasm>", "[unreached-invalid_19_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_2_wasm>", "[unreached-invalid_2_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_20_wasm>", "[unreached-invalid_20_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_21_wasm>", "[unreached-invalid_21_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_22_wasm>", "[unreached-invalid_22_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_23_wasm>", "[unreached-invalid_23_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_24_wasm>", "[unreached-invalid_24_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_25_wasm>", "[unreached-invalid_25_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_26_wasm>", "[unreached-invalid_26_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_27_wasm>", "[unreached-invalid_27_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_28_wasm>", "[unreached-invalid_28_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_29_wasm>", "[unreached-invalid_29_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_3_wasm>", "[unreached-invalid_3_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_30_wasm>", "[unreached-invalid_30_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_31_wasm>", "[unreached-invalid_31_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_32_wasm>", "[unreached-invalid_32_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_33_wasm>", "[unreached-invalid_33_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_34_wasm>", "[unreached-invalid_34_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_35_wasm>", "[unreached-invalid_35_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_36_wasm>", "[unreached-invalid_36_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_37_wasm>", "[unreached-invalid_37_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_38_wasm>", "[unreached-invalid_38_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_39_wasm>", "[unreached-invalid_39_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_4_wasm>", "[unreached-invalid_4_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_40_wasm>", "[unreached-invalid_40_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_41_wasm>", "[unreached-invalid_41_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_42_wasm>", "[unreached-invalid_42_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_43_wasm>", "[unreached-invalid_43_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_44_wasm>", "[unreached-invalid_44_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_45_wasm>", "[unreached-invalid_45_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_46_wasm>", "[unreached-invalid_46_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_47_wasm>", "[unreached-invalid_47_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_48_wasm>", "[unreached-invalid_48_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_49_wasm>", "[unreached-invalid_49_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_5_wasm>", "[unreached-invalid_5_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_50_wasm>", "[unreached-invalid_50_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_51_wasm>", "[unreached-invalid_51_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_52_wasm>", "[unreached-invalid_52_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_53_wasm>", "[unreached-invalid_53_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_54_wasm>", "[unreached-invalid_54_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_55_wasm>", "[unreached-invalid_55_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_56_wasm>", "[unreached-invalid_56_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_57_wasm>", "[unreached-invalid_57_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_58_wasm>", "[unreached-invalid_58_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_59_wasm>", "[unreached-invalid_59_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_6_wasm>", "[unreached-invalid_6_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_60_wasm>", "[unreached-invalid_60_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_61_wasm>", "[unreached-invalid_61_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_62_wasm>", "[unreached-invalid_62_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_63_wasm>", "[unreached-invalid_63_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_64_wasm>", "[unreached-invalid_64_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_65_wasm>", "[unreached-invalid_65_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_66_wasm>", "[unreached-invalid_66_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_67_wasm>", "[unreached-invalid_67_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_68_wasm>", "[unreached-invalid_68_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_69_wasm>", "[unreached-invalid_69_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_7_wasm>", "[unreached-invalid_7_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_70_wasm>", "[unreached-invalid_70_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_71_wasm>", "[unreached-invalid_71_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_72_wasm>", "[unreached-invalid_72_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_73_wasm>", "[unreached-invalid_73_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_74_wasm>", "[unreached-invalid_74_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_75_wasm>", "[unreached-invalid_75_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_76_wasm>", "[unreached-invalid_76_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_77_wasm>", "[unreached-invalid_77_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_78_wasm>", "[unreached-invalid_78_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_79_wasm>", "[unreached-invalid_79_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_8_wasm>", "[unreached-invalid_8_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_80_wasm>", "[unreached-invalid_80_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_81_wasm>", "[unreached-invalid_81_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_82_wasm>", "[unreached-invalid_82_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_83_wasm>", "[unreached-invalid_83_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_84_wasm>", "[unreached-invalid_84_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_85_wasm>", "[unreached-invalid_85_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_86_wasm>", "[unreached-invalid_86_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_87_wasm>", "[unreached-invalid_87_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_88_wasm>", "[unreached-invalid_88_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_89_wasm>", "[unreached-invalid_89_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_9_wasm>", "[unreached-invalid_9_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_90_wasm>", "[unreached-invalid_90_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_91_wasm>", "[unreached-invalid_91_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_92_wasm>", "[unreached-invalid_92_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_93_wasm>", "[unreached-invalid_93_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_94_wasm>", "[unreached-invalid_94_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_95_wasm>", "[unreached-invalid_95_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_96_wasm>", "[unreached-invalid_96_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_97_wasm>", "[unreached-invalid_97_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_98_wasm>", "[unreached-invalid_98_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <unreached-invalid_99_wasm>", "[unreached-invalid_99_wasm_tests]")
 

Variables

wasm_allocator wa
 

Function Documentation

◆ BACKEND_TEST_CASE() [1/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_0_wasm>" ,
"" [unreached-invalid_0_wasm_tests] )

Definition at line 18 of file unreached-invalid_tests.cpp.

18 {
19 using backend_t = backend<standalone_function_t, TestType>;
20 auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.0.wasm");
21 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
22}
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
sysio::vm::read_wasm
std::vector< uint8_t > read_wasm(const std::string &fname)
Definition utils.hpp:30
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [2/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_100_wasm>" ,
"" [unreached-invalid_100_wasm_tests] )

Definition at line 36 of file unreached-invalid_tests.cpp.

36 {
37 using backend_t = backend<standalone_function_t, TestType>;
38 auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.100.wasm");
39 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
40}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [3/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_101_wasm>" ,
"" [unreached-invalid_101_wasm_tests] )

Definition at line 42 of file unreached-invalid_tests.cpp.

42 {
43 using backend_t = backend<standalone_function_t, TestType>;
44 auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.101.wasm");
45 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
46}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [4/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_102_wasm>" ,
"" [unreached-invalid_102_wasm_tests] )

Definition at line 48 of file unreached-invalid_tests.cpp.

48 {
49 using backend_t = backend<standalone_function_t, TestType>;
50 auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.102.wasm");
51 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
52}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [5/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_103_wasm>" ,
"" [unreached-invalid_103_wasm_tests] )

Definition at line 54 of file unreached-invalid_tests.cpp.

54 {
55 using backend_t = backend<standalone_function_t, TestType>;
56 auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.103.wasm");
57 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
58}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [6/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_104_wasm>" ,
"" [unreached-invalid_104_wasm_tests] )

Definition at line 60 of file unreached-invalid_tests.cpp.

60 {
61 using backend_t = backend<standalone_function_t, TestType>;
62 auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.104.wasm");
63 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
64}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [7/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_105_wasm>" ,
"" [unreached-invalid_105_wasm_tests] )

Definition at line 66 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [8/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_106_wasm>" ,
"" [unreached-invalid_106_wasm_tests] )

Definition at line 72 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [9/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_107_wasm>" ,
"" [unreached-invalid_107_wasm_tests] )

Definition at line 78 of file unreached-invalid_tests.cpp.

78 {
79 using backend_t = backend<standalone_function_t, TestType>;
80 auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.107.wasm");
81 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
82}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [10/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_108_wasm>" ,
"" [unreached-invalid_108_wasm_tests] )

Definition at line 84 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [11/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_109_wasm>" ,
"" [unreached-invalid_109_wasm_tests] )

Definition at line 90 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [12/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_10_wasm>" ,
"" [unreached-invalid_10_wasm_tests] )

Definition at line 30 of file unreached-invalid_tests.cpp.

30 {
31 using backend_t = backend<standalone_function_t, TestType>;
32 auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.10.wasm");
33 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
34}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [13/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_110_wasm>" ,
"" [unreached-invalid_110_wasm_tests] )

Definition at line 102 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [14/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_11_wasm>" ,
"" [unreached-invalid_11_wasm_tests] )

Definition at line 96 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [15/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_12_wasm>" ,
"" [unreached-invalid_12_wasm_tests] )

Definition at line 108 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [16/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_13_wasm>" ,
"" [unreached-invalid_13_wasm_tests] )

Definition at line 114 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [17/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_14_wasm>" ,
"" [unreached-invalid_14_wasm_tests] )

Definition at line 120 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [18/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_15_wasm>" ,
"" [unreached-invalid_15_wasm_tests] )

Definition at line 126 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [19/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_16_wasm>" ,
"" [unreached-invalid_16_wasm_tests] )

Definition at line 132 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [20/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_17_wasm>" ,
"" [unreached-invalid_17_wasm_tests] )

Definition at line 138 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [21/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_18_wasm>" ,
"" [unreached-invalid_18_wasm_tests] )

Definition at line 144 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [22/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_19_wasm>" ,
"" [unreached-invalid_19_wasm_tests] )

Definition at line 150 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [23/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_1_wasm>" ,
"" [unreached-invalid_1_wasm_tests] )

Definition at line 24 of file unreached-invalid_tests.cpp.

24 {
25 using backend_t = backend<standalone_function_t, TestType>;
26 auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.1.wasm");
27 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
28}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [24/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_20_wasm>" ,
"" [unreached-invalid_20_wasm_tests] )

Definition at line 162 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [25/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_21_wasm>" ,
"" [unreached-invalid_21_wasm_tests] )

Definition at line 168 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [26/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_22_wasm>" ,
"" [unreached-invalid_22_wasm_tests] )

Definition at line 174 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [27/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_23_wasm>" ,
"" [unreached-invalid_23_wasm_tests] )

Definition at line 180 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [28/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_24_wasm>" ,
"" [unreached-invalid_24_wasm_tests] )

Definition at line 186 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [29/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_25_wasm>" ,
"" [unreached-invalid_25_wasm_tests] )

Definition at line 192 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [30/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_26_wasm>" ,
"" [unreached-invalid_26_wasm_tests] )

Definition at line 198 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [31/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_27_wasm>" ,
"" [unreached-invalid_27_wasm_tests] )

Definition at line 204 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [32/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_28_wasm>" ,
"" [unreached-invalid_28_wasm_tests] )

Definition at line 210 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [33/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_29_wasm>" ,
"" [unreached-invalid_29_wasm_tests] )

Definition at line 216 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [34/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_2_wasm>" ,
"" [unreached-invalid_2_wasm_tests] )

Definition at line 156 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [35/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_30_wasm>" ,
"" [unreached-invalid_30_wasm_tests] )

Definition at line 228 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [36/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_31_wasm>" ,
"" [unreached-invalid_31_wasm_tests] )

Definition at line 234 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [37/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_32_wasm>" ,
"" [unreached-invalid_32_wasm_tests] )

Definition at line 240 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [38/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_33_wasm>" ,
"" [unreached-invalid_33_wasm_tests] )

Definition at line 246 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [39/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_34_wasm>" ,
"" [unreached-invalid_34_wasm_tests] )

Definition at line 252 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [40/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_35_wasm>" ,
"" [unreached-invalid_35_wasm_tests] )

Definition at line 258 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [41/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_36_wasm>" ,
"" [unreached-invalid_36_wasm_tests] )

Definition at line 264 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [42/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_37_wasm>" ,
"" [unreached-invalid_37_wasm_tests] )

Definition at line 270 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [43/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_38_wasm>" ,
"" [unreached-invalid_38_wasm_tests] )

Definition at line 276 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [44/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_39_wasm>" ,
"" [unreached-invalid_39_wasm_tests] )

Definition at line 282 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [45/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_3_wasm>" ,
"" [unreached-invalid_3_wasm_tests] )

Definition at line 222 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [46/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_40_wasm>" ,
"" [unreached-invalid_40_wasm_tests] )

Definition at line 294 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [47/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_41_wasm>" ,
"" [unreached-invalid_41_wasm_tests] )

Definition at line 300 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [48/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_42_wasm>" ,
"" [unreached-invalid_42_wasm_tests] )

Definition at line 306 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [49/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_43_wasm>" ,
"" [unreached-invalid_43_wasm_tests] )

Definition at line 312 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [50/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_44_wasm>" ,
"" [unreached-invalid_44_wasm_tests] )

Definition at line 318 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [51/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_45_wasm>" ,
"" [unreached-invalid_45_wasm_tests] )

Definition at line 324 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [52/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_46_wasm>" ,
"" [unreached-invalid_46_wasm_tests] )

Definition at line 330 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [53/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_47_wasm>" ,
"" [unreached-invalid_47_wasm_tests] )

Definition at line 336 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [54/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_48_wasm>" ,
"" [unreached-invalid_48_wasm_tests] )

Definition at line 342 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [55/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_49_wasm>" ,
"" [unreached-invalid_49_wasm_tests] )

Definition at line 348 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [56/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_4_wasm>" ,
"" [unreached-invalid_4_wasm_tests] )

Definition at line 288 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [57/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_50_wasm>" ,
"" [unreached-invalid_50_wasm_tests] )

Definition at line 360 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [58/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_51_wasm>" ,
"" [unreached-invalid_51_wasm_tests] )

Definition at line 366 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [59/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_52_wasm>" ,
"" [unreached-invalid_52_wasm_tests] )

Definition at line 372 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [60/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_53_wasm>" ,
"" [unreached-invalid_53_wasm_tests] )

Definition at line 378 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [61/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_54_wasm>" ,
"" [unreached-invalid_54_wasm_tests] )

Definition at line 384 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [62/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_55_wasm>" ,
"" [unreached-invalid_55_wasm_tests] )

Definition at line 390 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [63/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_56_wasm>" ,
"" [unreached-invalid_56_wasm_tests] )

Definition at line 396 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [64/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_57_wasm>" ,
"" [unreached-invalid_57_wasm_tests] )

Definition at line 402 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [65/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_58_wasm>" ,
"" [unreached-invalid_58_wasm_tests] )

Definition at line 408 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [66/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_59_wasm>" ,
"" [unreached-invalid_59_wasm_tests] )

Definition at line 414 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [67/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_5_wasm>" ,
"" [unreached-invalid_5_wasm_tests] )

Definition at line 354 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [68/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_60_wasm>" ,
"" [unreached-invalid_60_wasm_tests] )

Definition at line 426 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [69/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_61_wasm>" ,
"" [unreached-invalid_61_wasm_tests] )

Definition at line 432 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [70/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_62_wasm>" ,
"" [unreached-invalid_62_wasm_tests] )

Definition at line 438 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [71/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_63_wasm>" ,
"" [unreached-invalid_63_wasm_tests] )

Definition at line 444 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [72/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_64_wasm>" ,
"" [unreached-invalid_64_wasm_tests] )

Definition at line 450 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [73/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_65_wasm>" ,
"" [unreached-invalid_65_wasm_tests] )

Definition at line 456 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [74/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_66_wasm>" ,
"" [unreached-invalid_66_wasm_tests] )

Definition at line 462 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [75/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_67_wasm>" ,
"" [unreached-invalid_67_wasm_tests] )

Definition at line 468 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [76/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_68_wasm>" ,
"" [unreached-invalid_68_wasm_tests] )

Definition at line 474 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [77/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_69_wasm>" ,
"" [unreached-invalid_69_wasm_tests] )

Definition at line 480 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [78/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_6_wasm>" ,
"" [unreached-invalid_6_wasm_tests] )

Definition at line 420 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [79/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_70_wasm>" ,
"" [unreached-invalid_70_wasm_tests] )

Definition at line 492 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [80/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_71_wasm>" ,
"" [unreached-invalid_71_wasm_tests] )

Definition at line 498 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [81/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_72_wasm>" ,
"" [unreached-invalid_72_wasm_tests] )

Definition at line 504 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [82/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_73_wasm>" ,
"" [unreached-invalid_73_wasm_tests] )

Definition at line 510 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [83/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_74_wasm>" ,
"" [unreached-invalid_74_wasm_tests] )

Definition at line 516 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [84/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_75_wasm>" ,
"" [unreached-invalid_75_wasm_tests] )

Definition at line 522 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [85/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_76_wasm>" ,
"" [unreached-invalid_76_wasm_tests] )

Definition at line 528 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [86/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_77_wasm>" ,
"" [unreached-invalid_77_wasm_tests] )

Definition at line 534 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [87/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_78_wasm>" ,
"" [unreached-invalid_78_wasm_tests] )

Definition at line 540 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [88/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_79_wasm>" ,
"" [unreached-invalid_79_wasm_tests] )

Definition at line 546 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [89/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_7_wasm>" ,
"" [unreached-invalid_7_wasm_tests] )

Definition at line 486 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [90/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_80_wasm>" ,
"" [unreached-invalid_80_wasm_tests] )

Definition at line 558 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [91/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_81_wasm>" ,
"" [unreached-invalid_81_wasm_tests] )

Definition at line 564 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [92/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_82_wasm>" ,
"" [unreached-invalid_82_wasm_tests] )

Definition at line 570 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [93/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_83_wasm>" ,
"" [unreached-invalid_83_wasm_tests] )

Definition at line 576 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [94/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_84_wasm>" ,
"" [unreached-invalid_84_wasm_tests] )

Definition at line 582 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [95/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_85_wasm>" ,
"" [unreached-invalid_85_wasm_tests] )

Definition at line 588 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [96/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_86_wasm>" ,
"" [unreached-invalid_86_wasm_tests] )

Definition at line 594 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [97/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_87_wasm>" ,
"" [unreached-invalid_87_wasm_tests] )

Definition at line 600 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [98/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_88_wasm>" ,
"" [unreached-invalid_88_wasm_tests] )

Definition at line 606 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [99/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_89_wasm>" ,
"" [unreached-invalid_89_wasm_tests] )

Definition at line 612 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [100/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_8_wasm>" ,
"" [unreached-invalid_8_wasm_tests] )

Definition at line 552 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [101/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_90_wasm>" ,
"" [unreached-invalid_90_wasm_tests] )

Definition at line 624 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [102/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_91_wasm>" ,
"" [unreached-invalid_91_wasm_tests] )

Definition at line 630 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [103/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_92_wasm>" ,
"" [unreached-invalid_92_wasm_tests] )

Definition at line 636 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [104/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_93_wasm>" ,
"" [unreached-invalid_93_wasm_tests] )

Definition at line 642 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [105/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_94_wasm>" ,
"" [unreached-invalid_94_wasm_tests] )

Definition at line 648 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [106/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_95_wasm>" ,
"" [unreached-invalid_95_wasm_tests] )

Definition at line 654 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [107/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_96_wasm>" ,
"" [unreached-invalid_96_wasm_tests] )

Definition at line 660 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [108/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_97_wasm>" ,
"" [unreached-invalid_97_wasm_tests] )

Definition at line 666 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [109/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_98_wasm>" ,
"" [unreached-invalid_98_wasm_tests] )

Definition at line 672 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [110/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_99_wasm>" ,
"" [unreached-invalid_99_wasm_tests] )

Definition at line 678 of file unreached-invalid_tests.cpp.

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

◆ BACKEND_TEST_CASE() [111/111]

BACKEND_TEST_CASE ( "Testing wasm <unreached-invalid_9_wasm>" ,
"" [unreached-invalid_9_wasm_tests] )

Definition at line 618 of file unreached-invalid_tests.cpp.

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

Variable Documentation

◆ wa

wasm_allocator wa
extern

Definition at line 10 of file main.cpp.