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

Go to the source code of this file.

Functions

 BACKEND_TEST_CASE ("Testing wasm <typecheck_0_wasm>", "[typecheck_0_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_1_wasm>", "[typecheck_1_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_10_wasm>", "[typecheck_10_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_100_wasm>", "[typecheck_100_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_101_wasm>", "[typecheck_101_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_102_wasm>", "[typecheck_102_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_103_wasm>", "[typecheck_103_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_104_wasm>", "[typecheck_104_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_105_wasm>", "[typecheck_105_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_106_wasm>", "[typecheck_106_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_107_wasm>", "[typecheck_107_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_108_wasm>", "[typecheck_108_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_109_wasm>", "[typecheck_109_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_11_wasm>", "[typecheck_11_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_110_wasm>", "[typecheck_110_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_111_wasm>", "[typecheck_111_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_112_wasm>", "[typecheck_112_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_113_wasm>", "[typecheck_113_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_114_wasm>", "[typecheck_114_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_115_wasm>", "[typecheck_115_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_116_wasm>", "[typecheck_116_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_117_wasm>", "[typecheck_117_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_118_wasm>", "[typecheck_118_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_119_wasm>", "[typecheck_119_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_12_wasm>", "[typecheck_12_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_120_wasm>", "[typecheck_120_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_121_wasm>", "[typecheck_121_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_122_wasm>", "[typecheck_122_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_123_wasm>", "[typecheck_123_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_124_wasm>", "[typecheck_124_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_125_wasm>", "[typecheck_125_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_126_wasm>", "[typecheck_126_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_127_wasm>", "[typecheck_127_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_128_wasm>", "[typecheck_128_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_129_wasm>", "[typecheck_129_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_13_wasm>", "[typecheck_13_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_130_wasm>", "[typecheck_130_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_131_wasm>", "[typecheck_131_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_132_wasm>", "[typecheck_132_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_133_wasm>", "[typecheck_133_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_134_wasm>", "[typecheck_134_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_135_wasm>", "[typecheck_135_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_136_wasm>", "[typecheck_136_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_137_wasm>", "[typecheck_137_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_138_wasm>", "[typecheck_138_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_139_wasm>", "[typecheck_139_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_14_wasm>", "[typecheck_14_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_140_wasm>", "[typecheck_140_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_141_wasm>", "[typecheck_141_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_142_wasm>", "[typecheck_142_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_143_wasm>", "[typecheck_143_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_144_wasm>", "[typecheck_144_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_145_wasm>", "[typecheck_145_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_146_wasm>", "[typecheck_146_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_147_wasm>", "[typecheck_147_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_148_wasm>", "[typecheck_148_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_149_wasm>", "[typecheck_149_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_15_wasm>", "[typecheck_15_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_150_wasm>", "[typecheck_150_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_151_wasm>", "[typecheck_151_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_152_wasm>", "[typecheck_152_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_153_wasm>", "[typecheck_153_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_154_wasm>", "[typecheck_154_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_155_wasm>", "[typecheck_155_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_156_wasm>", "[typecheck_156_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_157_wasm>", "[typecheck_157_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_158_wasm>", "[typecheck_158_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_159_wasm>", "[typecheck_159_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_16_wasm>", "[typecheck_16_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_160_wasm>", "[typecheck_160_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_161_wasm>", "[typecheck_161_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_162_wasm>", "[typecheck_162_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_163_wasm>", "[typecheck_163_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_17_wasm>", "[typecheck_17_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_18_wasm>", "[typecheck_18_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_19_wasm>", "[typecheck_19_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_2_wasm>", "[typecheck_2_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_20_wasm>", "[typecheck_20_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_21_wasm>", "[typecheck_21_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_22_wasm>", "[typecheck_22_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_23_wasm>", "[typecheck_23_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_24_wasm>", "[typecheck_24_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_25_wasm>", "[typecheck_25_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_26_wasm>", "[typecheck_26_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_27_wasm>", "[typecheck_27_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_28_wasm>", "[typecheck_28_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_29_wasm>", "[typecheck_29_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_3_wasm>", "[typecheck_3_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_30_wasm>", "[typecheck_30_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_31_wasm>", "[typecheck_31_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_32_wasm>", "[typecheck_32_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_33_wasm>", "[typecheck_33_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_34_wasm>", "[typecheck_34_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_35_wasm>", "[typecheck_35_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_36_wasm>", "[typecheck_36_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_37_wasm>", "[typecheck_37_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_38_wasm>", "[typecheck_38_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_39_wasm>", "[typecheck_39_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_4_wasm>", "[typecheck_4_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_40_wasm>", "[typecheck_40_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_41_wasm>", "[typecheck_41_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_42_wasm>", "[typecheck_42_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_43_wasm>", "[typecheck_43_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_44_wasm>", "[typecheck_44_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_45_wasm>", "[typecheck_45_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_46_wasm>", "[typecheck_46_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_47_wasm>", "[typecheck_47_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_48_wasm>", "[typecheck_48_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_49_wasm>", "[typecheck_49_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_5_wasm>", "[typecheck_5_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_50_wasm>", "[typecheck_50_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_51_wasm>", "[typecheck_51_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_52_wasm>", "[typecheck_52_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_53_wasm>", "[typecheck_53_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_54_wasm>", "[typecheck_54_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_55_wasm>", "[typecheck_55_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_56_wasm>", "[typecheck_56_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_57_wasm>", "[typecheck_57_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_58_wasm>", "[typecheck_58_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_59_wasm>", "[typecheck_59_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_6_wasm>", "[typecheck_6_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_60_wasm>", "[typecheck_60_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_61_wasm>", "[typecheck_61_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_62_wasm>", "[typecheck_62_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_63_wasm>", "[typecheck_63_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_64_wasm>", "[typecheck_64_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_65_wasm>", "[typecheck_65_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_66_wasm>", "[typecheck_66_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_67_wasm>", "[typecheck_67_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_68_wasm>", "[typecheck_68_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_69_wasm>", "[typecheck_69_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_7_wasm>", "[typecheck_7_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_70_wasm>", "[typecheck_70_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_71_wasm>", "[typecheck_71_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_72_wasm>", "[typecheck_72_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_73_wasm>", "[typecheck_73_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_74_wasm>", "[typecheck_74_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_75_wasm>", "[typecheck_75_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_76_wasm>", "[typecheck_76_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_77_wasm>", "[typecheck_77_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_78_wasm>", "[typecheck_78_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_79_wasm>", "[typecheck_79_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_8_wasm>", "[typecheck_8_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_80_wasm>", "[typecheck_80_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_81_wasm>", "[typecheck_81_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_82_wasm>", "[typecheck_82_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_83_wasm>", "[typecheck_83_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_84_wasm>", "[typecheck_84_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_85_wasm>", "[typecheck_85_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_86_wasm>", "[typecheck_86_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_87_wasm>", "[typecheck_87_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_88_wasm>", "[typecheck_88_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_89_wasm>", "[typecheck_89_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_9_wasm>", "[typecheck_9_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_90_wasm>", "[typecheck_90_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_91_wasm>", "[typecheck_91_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_92_wasm>", "[typecheck_92_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_93_wasm>", "[typecheck_93_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_94_wasm>", "[typecheck_94_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_95_wasm>", "[typecheck_95_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_96_wasm>", "[typecheck_96_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_97_wasm>", "[typecheck_97_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_98_wasm>", "[typecheck_98_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <typecheck_99_wasm>", "[typecheck_99_wasm_tests]")
 

Variables

wasm_allocator wa
 

Function Documentation

◆ BACKEND_TEST_CASE() [1/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_0_wasm>" ,
"" [typecheck_0_wasm_tests] )

Definition at line 18 of file typecheck_tests.cpp.

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

BACKEND_TEST_CASE ( "Testing wasm <typecheck_100_wasm>" ,
"" [typecheck_100_wasm_tests] )

Definition at line 36 of file typecheck_tests.cpp.

36 {
37 using backend_t = backend<standalone_function_t, TestType>;
38 auto code = read_wasm( std::string(wasm_directory) + "typecheck.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/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_101_wasm>" ,
"" [typecheck_101_wasm_tests] )

Definition at line 42 of file typecheck_tests.cpp.

42 {
43 using backend_t = backend<standalone_function_t, TestType>;
44 auto code = read_wasm( std::string(wasm_directory) + "typecheck.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/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_102_wasm>" ,
"" [typecheck_102_wasm_tests] )

Definition at line 48 of file typecheck_tests.cpp.

48 {
49 using backend_t = backend<standalone_function_t, TestType>;
50 auto code = read_wasm( std::string(wasm_directory) + "typecheck.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/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_103_wasm>" ,
"" [typecheck_103_wasm_tests] )

Definition at line 54 of file typecheck_tests.cpp.

54 {
55 using backend_t = backend<standalone_function_t, TestType>;
56 auto code = read_wasm( std::string(wasm_directory) + "typecheck.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/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_104_wasm>" ,
"" [typecheck_104_wasm_tests] )

Definition at line 60 of file typecheck_tests.cpp.

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

BACKEND_TEST_CASE ( "Testing wasm <typecheck_105_wasm>" ,
"" [typecheck_105_wasm_tests] )

Definition at line 66 of file typecheck_tests.cpp.

66 {
67 using backend_t = backend<standalone_function_t, TestType>;
68 auto code = read_wasm( std::string(wasm_directory) + "typecheck.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/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_106_wasm>" ,
"" [typecheck_106_wasm_tests] )

Definition at line 72 of file typecheck_tests.cpp.

72 {
73 using backend_t = backend<standalone_function_t, TestType>;
74 auto code = read_wasm( std::string(wasm_directory) + "typecheck.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/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_107_wasm>" ,
"" [typecheck_107_wasm_tests] )

Definition at line 78 of file typecheck_tests.cpp.

78 {
79 using backend_t = backend<standalone_function_t, TestType>;
80 auto code = read_wasm( std::string(wasm_directory) + "typecheck.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/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_108_wasm>" ,
"" [typecheck_108_wasm_tests] )

Definition at line 84 of file typecheck_tests.cpp.

84 {
85 using backend_t = backend<standalone_function_t, TestType>;
86 auto code = read_wasm( std::string(wasm_directory) + "typecheck.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/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_109_wasm>" ,
"" [typecheck_109_wasm_tests] )

Definition at line 90 of file typecheck_tests.cpp.

90 {
91 using backend_t = backend<standalone_function_t, TestType>;
92 auto code = read_wasm( std::string(wasm_directory) + "typecheck.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/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_10_wasm>" ,
"" [typecheck_10_wasm_tests] )

Definition at line 30 of file typecheck_tests.cpp.

30 {
31 using backend_t = backend<standalone_function_t, TestType>;
32 auto code = read_wasm( std::string(wasm_directory) + "typecheck.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/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_110_wasm>" ,
"" [typecheck_110_wasm_tests] )

Definition at line 102 of file typecheck_tests.cpp.

102 {
103 using backend_t = backend<standalone_function_t, TestType>;
104 auto code = read_wasm( std::string(wasm_directory) + "typecheck.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/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_111_wasm>" ,
"" [typecheck_111_wasm_tests] )

Definition at line 108 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [15/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_112_wasm>" ,
"" [typecheck_112_wasm_tests] )

Definition at line 114 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [16/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_113_wasm>" ,
"" [typecheck_113_wasm_tests] )

Definition at line 120 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [17/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_114_wasm>" ,
"" [typecheck_114_wasm_tests] )

Definition at line 126 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [18/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_115_wasm>" ,
"" [typecheck_115_wasm_tests] )

Definition at line 132 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [19/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_116_wasm>" ,
"" [typecheck_116_wasm_tests] )

Definition at line 138 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [20/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_117_wasm>" ,
"" [typecheck_117_wasm_tests] )

Definition at line 144 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [21/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_118_wasm>" ,
"" [typecheck_118_wasm_tests] )

Definition at line 150 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [22/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_119_wasm>" ,
"" [typecheck_119_wasm_tests] )

Definition at line 156 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [23/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_11_wasm>" ,
"" [typecheck_11_wasm_tests] )

Definition at line 96 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [24/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_120_wasm>" ,
"" [typecheck_120_wasm_tests] )

Definition at line 168 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [25/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_121_wasm>" ,
"" [typecheck_121_wasm_tests] )

Definition at line 174 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [26/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_122_wasm>" ,
"" [typecheck_122_wasm_tests] )

Definition at line 180 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [27/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_123_wasm>" ,
"" [typecheck_123_wasm_tests] )

Definition at line 186 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [28/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_124_wasm>" ,
"" [typecheck_124_wasm_tests] )

Definition at line 192 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [29/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_125_wasm>" ,
"" [typecheck_125_wasm_tests] )

Definition at line 198 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [30/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_126_wasm>" ,
"" [typecheck_126_wasm_tests] )

Definition at line 204 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [31/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_127_wasm>" ,
"" [typecheck_127_wasm_tests] )

Definition at line 210 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [32/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_128_wasm>" ,
"" [typecheck_128_wasm_tests] )

Definition at line 216 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [33/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_129_wasm>" ,
"" [typecheck_129_wasm_tests] )

Definition at line 222 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [34/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_12_wasm>" ,
"" [typecheck_12_wasm_tests] )

Definition at line 162 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [35/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_130_wasm>" ,
"" [typecheck_130_wasm_tests] )

Definition at line 234 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [36/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_131_wasm>" ,
"" [typecheck_131_wasm_tests] )

Definition at line 240 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [37/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_132_wasm>" ,
"" [typecheck_132_wasm_tests] )

Definition at line 246 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [38/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_133_wasm>" ,
"" [typecheck_133_wasm_tests] )

Definition at line 252 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [39/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_134_wasm>" ,
"" [typecheck_134_wasm_tests] )

Definition at line 258 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [40/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_135_wasm>" ,
"" [typecheck_135_wasm_tests] )

Definition at line 264 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [41/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_136_wasm>" ,
"" [typecheck_136_wasm_tests] )

Definition at line 270 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [42/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_137_wasm>" ,
"" [typecheck_137_wasm_tests] )

Definition at line 276 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [43/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_138_wasm>" ,
"" [typecheck_138_wasm_tests] )

Definition at line 282 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [44/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_139_wasm>" ,
"" [typecheck_139_wasm_tests] )

Definition at line 288 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [45/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_13_wasm>" ,
"" [typecheck_13_wasm_tests] )

Definition at line 228 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [46/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_140_wasm>" ,
"" [typecheck_140_wasm_tests] )

Definition at line 300 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [47/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_141_wasm>" ,
"" [typecheck_141_wasm_tests] )

Definition at line 306 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [48/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_142_wasm>" ,
"" [typecheck_142_wasm_tests] )

Definition at line 312 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [49/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_143_wasm>" ,
"" [typecheck_143_wasm_tests] )

Definition at line 318 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [50/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_144_wasm>" ,
"" [typecheck_144_wasm_tests] )

Definition at line 324 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [51/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_145_wasm>" ,
"" [typecheck_145_wasm_tests] )

Definition at line 330 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [52/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_146_wasm>" ,
"" [typecheck_146_wasm_tests] )

Definition at line 336 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [53/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_147_wasm>" ,
"" [typecheck_147_wasm_tests] )

Definition at line 342 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [54/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_148_wasm>" ,
"" [typecheck_148_wasm_tests] )

Definition at line 348 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [55/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_149_wasm>" ,
"" [typecheck_149_wasm_tests] )

Definition at line 354 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [56/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_14_wasm>" ,
"" [typecheck_14_wasm_tests] )

Definition at line 294 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [57/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_150_wasm>" ,
"" [typecheck_150_wasm_tests] )

Definition at line 366 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [58/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_151_wasm>" ,
"" [typecheck_151_wasm_tests] )

Definition at line 372 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [59/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_152_wasm>" ,
"" [typecheck_152_wasm_tests] )

Definition at line 378 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [60/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_153_wasm>" ,
"" [typecheck_153_wasm_tests] )

Definition at line 384 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [61/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_154_wasm>" ,
"" [typecheck_154_wasm_tests] )

Definition at line 390 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [62/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_155_wasm>" ,
"" [typecheck_155_wasm_tests] )

Definition at line 396 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [63/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_156_wasm>" ,
"" [typecheck_156_wasm_tests] )

Definition at line 402 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [64/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_157_wasm>" ,
"" [typecheck_157_wasm_tests] )

Definition at line 408 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [65/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_158_wasm>" ,
"" [typecheck_158_wasm_tests] )

Definition at line 414 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [66/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_159_wasm>" ,
"" [typecheck_159_wasm_tests] )

Definition at line 420 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [67/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_15_wasm>" ,
"" [typecheck_15_wasm_tests] )

Definition at line 360 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [68/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_160_wasm>" ,
"" [typecheck_160_wasm_tests] )

Definition at line 432 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [69/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_161_wasm>" ,
"" [typecheck_161_wasm_tests] )

Definition at line 438 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [70/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_162_wasm>" ,
"" [typecheck_162_wasm_tests] )

Definition at line 444 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [71/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_163_wasm>" ,
"" [typecheck_163_wasm_tests] )

Definition at line 450 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [72/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_16_wasm>" ,
"" [typecheck_16_wasm_tests] )

Definition at line 426 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [73/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_17_wasm>" ,
"" [typecheck_17_wasm_tests] )

Definition at line 456 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [74/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_18_wasm>" ,
"" [typecheck_18_wasm_tests] )

Definition at line 462 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [75/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_19_wasm>" ,
"" [typecheck_19_wasm_tests] )

Definition at line 468 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [76/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_1_wasm>" ,
"" [typecheck_1_wasm_tests] )

Definition at line 24 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [77/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_20_wasm>" ,
"" [typecheck_20_wasm_tests] )

Definition at line 480 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [78/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_21_wasm>" ,
"" [typecheck_21_wasm_tests] )

Definition at line 486 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [79/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_22_wasm>" ,
"" [typecheck_22_wasm_tests] )

Definition at line 492 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [80/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_23_wasm>" ,
"" [typecheck_23_wasm_tests] )

Definition at line 498 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [81/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_24_wasm>" ,
"" [typecheck_24_wasm_tests] )

Definition at line 504 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [82/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_25_wasm>" ,
"" [typecheck_25_wasm_tests] )

Definition at line 510 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [83/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_26_wasm>" ,
"" [typecheck_26_wasm_tests] )

Definition at line 516 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [84/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_27_wasm>" ,
"" [typecheck_27_wasm_tests] )

Definition at line 522 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [85/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_28_wasm>" ,
"" [typecheck_28_wasm_tests] )

Definition at line 528 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [86/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_29_wasm>" ,
"" [typecheck_29_wasm_tests] )

Definition at line 534 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [87/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_2_wasm>" ,
"" [typecheck_2_wasm_tests] )

Definition at line 474 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [88/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_30_wasm>" ,
"" [typecheck_30_wasm_tests] )

Definition at line 546 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [89/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_31_wasm>" ,
"" [typecheck_31_wasm_tests] )

Definition at line 552 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [90/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_32_wasm>" ,
"" [typecheck_32_wasm_tests] )

Definition at line 558 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [91/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_33_wasm>" ,
"" [typecheck_33_wasm_tests] )

Definition at line 564 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [92/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_34_wasm>" ,
"" [typecheck_34_wasm_tests] )

Definition at line 570 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [93/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_35_wasm>" ,
"" [typecheck_35_wasm_tests] )

Definition at line 576 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [94/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_36_wasm>" ,
"" [typecheck_36_wasm_tests] )

Definition at line 582 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [95/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_37_wasm>" ,
"" [typecheck_37_wasm_tests] )

Definition at line 588 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [96/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_38_wasm>" ,
"" [typecheck_38_wasm_tests] )

Definition at line 594 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [97/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_39_wasm>" ,
"" [typecheck_39_wasm_tests] )

Definition at line 600 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [98/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_3_wasm>" ,
"" [typecheck_3_wasm_tests] )

Definition at line 540 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [99/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_40_wasm>" ,
"" [typecheck_40_wasm_tests] )

Definition at line 612 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [100/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_41_wasm>" ,
"" [typecheck_41_wasm_tests] )

Definition at line 618 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [101/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_42_wasm>" ,
"" [typecheck_42_wasm_tests] )

Definition at line 624 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [102/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_43_wasm>" ,
"" [typecheck_43_wasm_tests] )

Definition at line 630 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [103/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_44_wasm>" ,
"" [typecheck_44_wasm_tests] )

Definition at line 636 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [104/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_45_wasm>" ,
"" [typecheck_45_wasm_tests] )

Definition at line 642 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [105/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_46_wasm>" ,
"" [typecheck_46_wasm_tests] )

Definition at line 648 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [106/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_47_wasm>" ,
"" [typecheck_47_wasm_tests] )

Definition at line 654 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [107/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_48_wasm>" ,
"" [typecheck_48_wasm_tests] )

Definition at line 660 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [108/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_49_wasm>" ,
"" [typecheck_49_wasm_tests] )

Definition at line 666 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [109/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_4_wasm>" ,
"" [typecheck_4_wasm_tests] )

Definition at line 606 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [110/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_50_wasm>" ,
"" [typecheck_50_wasm_tests] )

Definition at line 678 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [111/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_51_wasm>" ,
"" [typecheck_51_wasm_tests] )

Definition at line 684 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [112/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_52_wasm>" ,
"" [typecheck_52_wasm_tests] )

Definition at line 690 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [113/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_53_wasm>" ,
"" [typecheck_53_wasm_tests] )

Definition at line 696 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [114/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_54_wasm>" ,
"" [typecheck_54_wasm_tests] )

Definition at line 702 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [115/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_55_wasm>" ,
"" [typecheck_55_wasm_tests] )

Definition at line 708 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [116/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_56_wasm>" ,
"" [typecheck_56_wasm_tests] )

Definition at line 714 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [117/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_57_wasm>" ,
"" [typecheck_57_wasm_tests] )

Definition at line 720 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [118/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_58_wasm>" ,
"" [typecheck_58_wasm_tests] )

Definition at line 726 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [119/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_59_wasm>" ,
"" [typecheck_59_wasm_tests] )

Definition at line 732 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [120/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_5_wasm>" ,
"" [typecheck_5_wasm_tests] )

Definition at line 672 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [121/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_60_wasm>" ,
"" [typecheck_60_wasm_tests] )

Definition at line 744 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [122/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_61_wasm>" ,
"" [typecheck_61_wasm_tests] )

Definition at line 750 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [123/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_62_wasm>" ,
"" [typecheck_62_wasm_tests] )

Definition at line 756 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [124/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_63_wasm>" ,
"" [typecheck_63_wasm_tests] )

Definition at line 762 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [125/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_64_wasm>" ,
"" [typecheck_64_wasm_tests] )

Definition at line 768 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [126/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_65_wasm>" ,
"" [typecheck_65_wasm_tests] )

Definition at line 774 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [127/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_66_wasm>" ,
"" [typecheck_66_wasm_tests] )

Definition at line 780 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [128/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_67_wasm>" ,
"" [typecheck_67_wasm_tests] )

Definition at line 786 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [129/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_68_wasm>" ,
"" [typecheck_68_wasm_tests] )

Definition at line 792 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [130/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_69_wasm>" ,
"" [typecheck_69_wasm_tests] )

Definition at line 798 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [131/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_6_wasm>" ,
"" [typecheck_6_wasm_tests] )

Definition at line 738 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [132/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_70_wasm>" ,
"" [typecheck_70_wasm_tests] )

Definition at line 810 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [133/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_71_wasm>" ,
"" [typecheck_71_wasm_tests] )

Definition at line 816 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [134/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_72_wasm>" ,
"" [typecheck_72_wasm_tests] )

Definition at line 822 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [135/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_73_wasm>" ,
"" [typecheck_73_wasm_tests] )

Definition at line 828 of file typecheck_tests.cpp.

828 {
829 using backend_t = backend<standalone_function_t, TestType>;
830 auto code = read_wasm( std::string(wasm_directory) + "typecheck.73.wasm");
831 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
832}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [136/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_74_wasm>" ,
"" [typecheck_74_wasm_tests] )

Definition at line 834 of file typecheck_tests.cpp.

834 {
835 using backend_t = backend<standalone_function_t, TestType>;
836 auto code = read_wasm( std::string(wasm_directory) + "typecheck.74.wasm");
837 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
838}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [137/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_75_wasm>" ,
"" [typecheck_75_wasm_tests] )

Definition at line 840 of file typecheck_tests.cpp.

840 {
841 using backend_t = backend<standalone_function_t, TestType>;
842 auto code = read_wasm( std::string(wasm_directory) + "typecheck.75.wasm");
843 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
844}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [138/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_76_wasm>" ,
"" [typecheck_76_wasm_tests] )

Definition at line 846 of file typecheck_tests.cpp.

846 {
847 using backend_t = backend<standalone_function_t, TestType>;
848 auto code = read_wasm( std::string(wasm_directory) + "typecheck.76.wasm");
849 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
850}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [139/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_77_wasm>" ,
"" [typecheck_77_wasm_tests] )

Definition at line 852 of file typecheck_tests.cpp.

852 {
853 using backend_t = backend<standalone_function_t, TestType>;
854 auto code = read_wasm( std::string(wasm_directory) + "typecheck.77.wasm");
855 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
856}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [140/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_78_wasm>" ,
"" [typecheck_78_wasm_tests] )

Definition at line 858 of file typecheck_tests.cpp.

858 {
859 using backend_t = backend<standalone_function_t, TestType>;
860 auto code = read_wasm( std::string(wasm_directory) + "typecheck.78.wasm");
861 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
862}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [141/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_79_wasm>" ,
"" [typecheck_79_wasm_tests] )

Definition at line 864 of file typecheck_tests.cpp.

864 {
865 using backend_t = backend<standalone_function_t, TestType>;
866 auto code = read_wasm( std::string(wasm_directory) + "typecheck.79.wasm");
867 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
868}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [142/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_7_wasm>" ,
"" [typecheck_7_wasm_tests] )

Definition at line 804 of file typecheck_tests.cpp.

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

◆ BACKEND_TEST_CASE() [143/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_80_wasm>" ,
"" [typecheck_80_wasm_tests] )

Definition at line 876 of file typecheck_tests.cpp.

876 {
877 using backend_t = backend<standalone_function_t, TestType>;
878 auto code = read_wasm( std::string(wasm_directory) + "typecheck.80.wasm");
879 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
880}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [144/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_81_wasm>" ,
"" [typecheck_81_wasm_tests] )

Definition at line 882 of file typecheck_tests.cpp.

882 {
883 using backend_t = backend<standalone_function_t, TestType>;
884 auto code = read_wasm( std::string(wasm_directory) + "typecheck.81.wasm");
885 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
886}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [145/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_82_wasm>" ,
"" [typecheck_82_wasm_tests] )

Definition at line 888 of file typecheck_tests.cpp.

888 {
889 using backend_t = backend<standalone_function_t, TestType>;
890 auto code = read_wasm( std::string(wasm_directory) + "typecheck.82.wasm");
891 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
892}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [146/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_83_wasm>" ,
"" [typecheck_83_wasm_tests] )

Definition at line 894 of file typecheck_tests.cpp.

894 {
895 using backend_t = backend<standalone_function_t, TestType>;
896 auto code = read_wasm( std::string(wasm_directory) + "typecheck.83.wasm");
897 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
898}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [147/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_84_wasm>" ,
"" [typecheck_84_wasm_tests] )

Definition at line 900 of file typecheck_tests.cpp.

900 {
901 using backend_t = backend<standalone_function_t, TestType>;
902 auto code = read_wasm( std::string(wasm_directory) + "typecheck.84.wasm");
903 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
904}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [148/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_85_wasm>" ,
"" [typecheck_85_wasm_tests] )

Definition at line 906 of file typecheck_tests.cpp.

906 {
907 using backend_t = backend<standalone_function_t, TestType>;
908 auto code = read_wasm( std::string(wasm_directory) + "typecheck.85.wasm");
909 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
910}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [149/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_86_wasm>" ,
"" [typecheck_86_wasm_tests] )

Definition at line 912 of file typecheck_tests.cpp.

912 {
913 using backend_t = backend<standalone_function_t, TestType>;
914 auto code = read_wasm( std::string(wasm_directory) + "typecheck.86.wasm");
915 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
916}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [150/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_87_wasm>" ,
"" [typecheck_87_wasm_tests] )

Definition at line 918 of file typecheck_tests.cpp.

918 {
919 using backend_t = backend<standalone_function_t, TestType>;
920 auto code = read_wasm( std::string(wasm_directory) + "typecheck.87.wasm");
921 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
922}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [151/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_88_wasm>" ,
"" [typecheck_88_wasm_tests] )

Definition at line 924 of file typecheck_tests.cpp.

924 {
925 using backend_t = backend<standalone_function_t, TestType>;
926 auto code = read_wasm( std::string(wasm_directory) + "typecheck.88.wasm");
927 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
928}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [152/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_89_wasm>" ,
"" [typecheck_89_wasm_tests] )

Definition at line 930 of file typecheck_tests.cpp.

930 {
931 using backend_t = backend<standalone_function_t, TestType>;
932 auto code = read_wasm( std::string(wasm_directory) + "typecheck.89.wasm");
933 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
934}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [153/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_8_wasm>" ,
"" [typecheck_8_wasm_tests] )

Definition at line 870 of file typecheck_tests.cpp.

870 {
871 using backend_t = backend<standalone_function_t, TestType>;
872 auto code = read_wasm( std::string(wasm_directory) + "typecheck.8.wasm");
873 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
874}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [154/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_90_wasm>" ,
"" [typecheck_90_wasm_tests] )

Definition at line 942 of file typecheck_tests.cpp.

942 {
943 using backend_t = backend<standalone_function_t, TestType>;
944 auto code = read_wasm( std::string(wasm_directory) + "typecheck.90.wasm");
945 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
946}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [155/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_91_wasm>" ,
"" [typecheck_91_wasm_tests] )

Definition at line 948 of file typecheck_tests.cpp.

948 {
949 using backend_t = backend<standalone_function_t, TestType>;
950 auto code = read_wasm( std::string(wasm_directory) + "typecheck.91.wasm");
951 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
952}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [156/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_92_wasm>" ,
"" [typecheck_92_wasm_tests] )

Definition at line 954 of file typecheck_tests.cpp.

954 {
955 using backend_t = backend<standalone_function_t, TestType>;
956 auto code = read_wasm( std::string(wasm_directory) + "typecheck.92.wasm");
957 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
958}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [157/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_93_wasm>" ,
"" [typecheck_93_wasm_tests] )

Definition at line 960 of file typecheck_tests.cpp.

960 {
961 using backend_t = backend<standalone_function_t, TestType>;
962 auto code = read_wasm( std::string(wasm_directory) + "typecheck.93.wasm");
963 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
964}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [158/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_94_wasm>" ,
"" [typecheck_94_wasm_tests] )

Definition at line 966 of file typecheck_tests.cpp.

966 {
967 using backend_t = backend<standalone_function_t, TestType>;
968 auto code = read_wasm( std::string(wasm_directory) + "typecheck.94.wasm");
969 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
970}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [159/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_95_wasm>" ,
"" [typecheck_95_wasm_tests] )

Definition at line 972 of file typecheck_tests.cpp.

972 {
973 using backend_t = backend<standalone_function_t, TestType>;
974 auto code = read_wasm( std::string(wasm_directory) + "typecheck.95.wasm");
975 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
976}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [160/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_96_wasm>" ,
"" [typecheck_96_wasm_tests] )

Definition at line 978 of file typecheck_tests.cpp.

978 {
979 using backend_t = backend<standalone_function_t, TestType>;
980 auto code = read_wasm( std::string(wasm_directory) + "typecheck.96.wasm");
981 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
982}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [161/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_97_wasm>" ,
"" [typecheck_97_wasm_tests] )

Definition at line 984 of file typecheck_tests.cpp.

984 {
985 using backend_t = backend<standalone_function_t, TestType>;
986 auto code = read_wasm( std::string(wasm_directory) + "typecheck.97.wasm");
987 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
988}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [162/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_98_wasm>" ,
"" [typecheck_98_wasm_tests] )

Definition at line 990 of file typecheck_tests.cpp.

990 {
991 using backend_t = backend<standalone_function_t, TestType>;
992 auto code = read_wasm( std::string(wasm_directory) + "typecheck.98.wasm");
993 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
994}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [163/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_99_wasm>" ,
"" [typecheck_99_wasm_tests] )

Definition at line 996 of file typecheck_tests.cpp.

996 {
997 using backend_t = backend<standalone_function_t, TestType>;
998 auto code = read_wasm( std::string(wasm_directory) + "typecheck.99.wasm");
999 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
1000}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [164/164]

BACKEND_TEST_CASE ( "Testing wasm <typecheck_9_wasm>" ,
"" [typecheck_9_wasm_tests] )

Definition at line 936 of file typecheck_tests.cpp.

936 {
937 using backend_t = backend<standalone_function_t, TestType>;
938 auto code = read_wasm( std::string(wasm_directory) + "typecheck.9.wasm");
939 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
940}
Here is the call graph for this function:

Variable Documentation

◆ wa

wasm_allocator wa
extern

Definition at line 10 of file main.cpp.