typecheck_tests.cpp

Go to the documentation of this file.

// Generated by spec_test_generator.  DO NOT MODIFY THIS FILE.
 
#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>
 
using namespace sysio;
using namespace sysio::vm;
extern wasm_allocator wa;
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_0_wasm>", "[typecheck_0_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.0.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_1_wasm>", "[typecheck_1_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.1.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_10_wasm>", "[typecheck_10_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.10.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_100_wasm>", "[typecheck_100_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.100.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_101_wasm>", "[typecheck_101_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.101.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_102_wasm>", "[typecheck_102_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.102.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_103_wasm>", "[typecheck_103_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.103.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_104_wasm>", "[typecheck_104_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.104.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_105_wasm>", "[typecheck_105_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.105.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_106_wasm>", "[typecheck_106_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.106.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_107_wasm>", "[typecheck_107_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.107.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_108_wasm>", "[typecheck_108_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.108.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_109_wasm>", "[typecheck_109_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.109.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_11_wasm>", "[typecheck_11_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.11.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_110_wasm>", "[typecheck_110_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.110.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_111_wasm>", "[typecheck_111_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.111.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_112_wasm>", "[typecheck_112_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.112.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_113_wasm>", "[typecheck_113_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.113.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_114_wasm>", "[typecheck_114_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.114.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_115_wasm>", "[typecheck_115_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.115.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_116_wasm>", "[typecheck_116_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.116.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_117_wasm>", "[typecheck_117_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.117.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_118_wasm>", "[typecheck_118_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.118.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_119_wasm>", "[typecheck_119_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.119.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_12_wasm>", "[typecheck_12_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.12.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_120_wasm>", "[typecheck_120_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.120.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_121_wasm>", "[typecheck_121_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.121.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_122_wasm>", "[typecheck_122_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.122.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_123_wasm>", "[typecheck_123_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.123.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_124_wasm>", "[typecheck_124_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.124.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_125_wasm>", "[typecheck_125_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.125.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_126_wasm>", "[typecheck_126_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.126.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_127_wasm>", "[typecheck_127_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.127.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_128_wasm>", "[typecheck_128_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.128.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_129_wasm>", "[typecheck_129_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.129.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_13_wasm>", "[typecheck_13_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.13.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_130_wasm>", "[typecheck_130_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.130.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_131_wasm>", "[typecheck_131_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.131.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_132_wasm>", "[typecheck_132_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.132.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_133_wasm>", "[typecheck_133_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.133.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_134_wasm>", "[typecheck_134_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.134.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_135_wasm>", "[typecheck_135_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.135.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_136_wasm>", "[typecheck_136_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.136.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_137_wasm>", "[typecheck_137_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.137.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_138_wasm>", "[typecheck_138_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.138.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_139_wasm>", "[typecheck_139_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.139.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_14_wasm>", "[typecheck_14_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.14.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_140_wasm>", "[typecheck_140_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.140.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_141_wasm>", "[typecheck_141_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.141.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_142_wasm>", "[typecheck_142_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.142.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_143_wasm>", "[typecheck_143_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.143.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_144_wasm>", "[typecheck_144_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.144.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_145_wasm>", "[typecheck_145_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.145.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_146_wasm>", "[typecheck_146_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.146.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_147_wasm>", "[typecheck_147_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.147.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_148_wasm>", "[typecheck_148_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.148.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_149_wasm>", "[typecheck_149_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.149.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_15_wasm>", "[typecheck_15_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.15.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_150_wasm>", "[typecheck_150_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.150.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_151_wasm>", "[typecheck_151_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.151.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_152_wasm>", "[typecheck_152_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.152.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_153_wasm>", "[typecheck_153_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.153.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_154_wasm>", "[typecheck_154_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.154.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_155_wasm>", "[typecheck_155_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.155.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_156_wasm>", "[typecheck_156_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.156.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_157_wasm>", "[typecheck_157_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.157.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_158_wasm>", "[typecheck_158_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.158.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_159_wasm>", "[typecheck_159_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.159.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_16_wasm>", "[typecheck_16_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.16.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_160_wasm>", "[typecheck_160_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.160.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_161_wasm>", "[typecheck_161_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.161.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_162_wasm>", "[typecheck_162_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.162.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_163_wasm>", "[typecheck_163_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.163.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_17_wasm>", "[typecheck_17_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.17.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_18_wasm>", "[typecheck_18_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.18.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_19_wasm>", "[typecheck_19_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.19.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_2_wasm>", "[typecheck_2_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.2.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_20_wasm>", "[typecheck_20_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.20.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_21_wasm>", "[typecheck_21_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.21.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_22_wasm>", "[typecheck_22_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.22.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_23_wasm>", "[typecheck_23_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.23.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_24_wasm>", "[typecheck_24_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.24.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_25_wasm>", "[typecheck_25_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.25.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_26_wasm>", "[typecheck_26_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.26.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_27_wasm>", "[typecheck_27_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.27.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_28_wasm>", "[typecheck_28_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.28.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_29_wasm>", "[typecheck_29_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.29.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_3_wasm>", "[typecheck_3_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.3.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_30_wasm>", "[typecheck_30_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.30.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_31_wasm>", "[typecheck_31_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.31.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_32_wasm>", "[typecheck_32_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.32.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_33_wasm>", "[typecheck_33_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.33.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_34_wasm>", "[typecheck_34_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.34.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_35_wasm>", "[typecheck_35_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.35.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_36_wasm>", "[typecheck_36_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.36.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_37_wasm>", "[typecheck_37_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.37.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_38_wasm>", "[typecheck_38_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.38.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_39_wasm>", "[typecheck_39_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.39.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_4_wasm>", "[typecheck_4_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.4.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_40_wasm>", "[typecheck_40_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.40.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_41_wasm>", "[typecheck_41_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.41.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_42_wasm>", "[typecheck_42_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.42.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_43_wasm>", "[typecheck_43_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.43.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_44_wasm>", "[typecheck_44_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.44.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_45_wasm>", "[typecheck_45_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.45.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_46_wasm>", "[typecheck_46_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.46.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_47_wasm>", "[typecheck_47_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.47.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_48_wasm>", "[typecheck_48_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.48.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_49_wasm>", "[typecheck_49_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.49.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_5_wasm>", "[typecheck_5_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.5.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_50_wasm>", "[typecheck_50_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.50.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_51_wasm>", "[typecheck_51_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.51.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_52_wasm>", "[typecheck_52_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.52.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_53_wasm>", "[typecheck_53_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.53.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_54_wasm>", "[typecheck_54_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.54.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_55_wasm>", "[typecheck_55_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.55.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_56_wasm>", "[typecheck_56_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.56.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_57_wasm>", "[typecheck_57_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.57.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_58_wasm>", "[typecheck_58_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.58.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_59_wasm>", "[typecheck_59_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.59.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_6_wasm>", "[typecheck_6_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.6.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_60_wasm>", "[typecheck_60_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.60.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_61_wasm>", "[typecheck_61_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.61.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_62_wasm>", "[typecheck_62_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.62.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_63_wasm>", "[typecheck_63_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.63.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_64_wasm>", "[typecheck_64_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.64.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_65_wasm>", "[typecheck_65_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.65.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_66_wasm>", "[typecheck_66_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.66.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_67_wasm>", "[typecheck_67_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.67.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_68_wasm>", "[typecheck_68_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.68.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_69_wasm>", "[typecheck_69_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.69.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_7_wasm>", "[typecheck_7_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.7.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_70_wasm>", "[typecheck_70_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.70.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_71_wasm>", "[typecheck_71_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.71.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_72_wasm>", "[typecheck_72_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.72.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_73_wasm>", "[typecheck_73_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.73.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_74_wasm>", "[typecheck_74_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.74.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_75_wasm>", "[typecheck_75_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.75.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_76_wasm>", "[typecheck_76_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.76.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_77_wasm>", "[typecheck_77_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.77.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_78_wasm>", "[typecheck_78_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.78.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_79_wasm>", "[typecheck_79_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.79.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_8_wasm>", "[typecheck_8_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.8.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_80_wasm>", "[typecheck_80_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.80.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_81_wasm>", "[typecheck_81_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.81.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_82_wasm>", "[typecheck_82_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.82.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_83_wasm>", "[typecheck_83_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.83.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_84_wasm>", "[typecheck_84_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.84.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_85_wasm>", "[typecheck_85_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.85.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_86_wasm>", "[typecheck_86_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.86.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_87_wasm>", "[typecheck_87_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.87.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_88_wasm>", "[typecheck_88_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.88.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_89_wasm>", "[typecheck_89_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.89.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_9_wasm>", "[typecheck_9_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.9.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_90_wasm>", "[typecheck_90_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.90.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_91_wasm>", "[typecheck_91_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.91.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_92_wasm>", "[typecheck_92_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.92.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_93_wasm>", "[typecheck_93_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.93.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_94_wasm>", "[typecheck_94_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.94.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_95_wasm>", "[typecheck_95_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.95.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_96_wasm>", "[typecheck_96_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.96.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_97_wasm>", "[typecheck_97_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.97.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_98_wasm>", "[typecheck_98_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.98.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <typecheck_99_wasm>", "[typecheck_99_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "typecheck.99.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}