utf8-custom-section-id_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 <utf8-custom-section-id_0_wasm>", "[utf8-custom-section-id_0_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.0.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_1_wasm>", "[utf8-custom-section-id_1_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.1.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_10_wasm>", "[utf8-custom-section-id_10_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.10.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_100_wasm>", "[utf8-custom-section-id_100_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.100.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_101_wasm>", "[utf8-custom-section-id_101_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.101.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_102_wasm>", "[utf8-custom-section-id_102_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.102.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_103_wasm>", "[utf8-custom-section-id_103_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.103.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_104_wasm>", "[utf8-custom-section-id_104_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.104.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_105_wasm>", "[utf8-custom-section-id_105_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.105.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_106_wasm>", "[utf8-custom-section-id_106_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.106.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_107_wasm>", "[utf8-custom-section-id_107_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.107.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_108_wasm>", "[utf8-custom-section-id_108_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.108.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_109_wasm>", "[utf8-custom-section-id_109_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.109.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_11_wasm>", "[utf8-custom-section-id_11_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.11.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_110_wasm>", "[utf8-custom-section-id_110_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.110.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_111_wasm>", "[utf8-custom-section-id_111_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.111.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_112_wasm>", "[utf8-custom-section-id_112_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.112.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_113_wasm>", "[utf8-custom-section-id_113_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.113.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_114_wasm>", "[utf8-custom-section-id_114_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.114.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_115_wasm>", "[utf8-custom-section-id_115_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.115.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_116_wasm>", "[utf8-custom-section-id_116_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.116.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_117_wasm>", "[utf8-custom-section-id_117_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.117.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_118_wasm>", "[utf8-custom-section-id_118_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.118.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_119_wasm>", "[utf8-custom-section-id_119_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.119.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_12_wasm>", "[utf8-custom-section-id_12_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.12.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_120_wasm>", "[utf8-custom-section-id_120_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.120.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_121_wasm>", "[utf8-custom-section-id_121_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.121.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_122_wasm>", "[utf8-custom-section-id_122_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.122.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_123_wasm>", "[utf8-custom-section-id_123_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.123.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_124_wasm>", "[utf8-custom-section-id_124_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.124.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_125_wasm>", "[utf8-custom-section-id_125_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.125.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_126_wasm>", "[utf8-custom-section-id_126_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.126.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_127_wasm>", "[utf8-custom-section-id_127_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.127.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_128_wasm>", "[utf8-custom-section-id_128_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.128.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_129_wasm>", "[utf8-custom-section-id_129_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.129.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_13_wasm>", "[utf8-custom-section-id_13_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.13.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_130_wasm>", "[utf8-custom-section-id_130_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.130.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_131_wasm>", "[utf8-custom-section-id_131_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.131.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_132_wasm>", "[utf8-custom-section-id_132_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.132.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_133_wasm>", "[utf8-custom-section-id_133_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.133.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_134_wasm>", "[utf8-custom-section-id_134_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.134.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_135_wasm>", "[utf8-custom-section-id_135_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.135.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_136_wasm>", "[utf8-custom-section-id_136_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.136.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_137_wasm>", "[utf8-custom-section-id_137_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.137.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_138_wasm>", "[utf8-custom-section-id_138_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.138.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_139_wasm>", "[utf8-custom-section-id_139_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.139.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_14_wasm>", "[utf8-custom-section-id_14_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.14.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_140_wasm>", "[utf8-custom-section-id_140_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.140.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_141_wasm>", "[utf8-custom-section-id_141_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.141.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_142_wasm>", "[utf8-custom-section-id_142_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.142.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_143_wasm>", "[utf8-custom-section-id_143_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.143.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_144_wasm>", "[utf8-custom-section-id_144_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.144.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_145_wasm>", "[utf8-custom-section-id_145_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.145.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_146_wasm>", "[utf8-custom-section-id_146_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.146.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_147_wasm>", "[utf8-custom-section-id_147_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.147.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_148_wasm>", "[utf8-custom-section-id_148_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.148.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_149_wasm>", "[utf8-custom-section-id_149_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.149.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_15_wasm>", "[utf8-custom-section-id_15_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.15.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_150_wasm>", "[utf8-custom-section-id_150_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.150.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_151_wasm>", "[utf8-custom-section-id_151_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.151.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_152_wasm>", "[utf8-custom-section-id_152_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.152.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_153_wasm>", "[utf8-custom-section-id_153_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.153.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_154_wasm>", "[utf8-custom-section-id_154_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.154.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_155_wasm>", "[utf8-custom-section-id_155_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.155.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_156_wasm>", "[utf8-custom-section-id_156_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.156.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_157_wasm>", "[utf8-custom-section-id_157_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.157.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_158_wasm>", "[utf8-custom-section-id_158_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.158.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_159_wasm>", "[utf8-custom-section-id_159_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.159.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_16_wasm>", "[utf8-custom-section-id_16_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.16.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_160_wasm>", "[utf8-custom-section-id_160_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.160.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_161_wasm>", "[utf8-custom-section-id_161_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.161.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_162_wasm>", "[utf8-custom-section-id_162_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.162.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_163_wasm>", "[utf8-custom-section-id_163_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.163.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_164_wasm>", "[utf8-custom-section-id_164_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.164.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_165_wasm>", "[utf8-custom-section-id_165_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.165.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_166_wasm>", "[utf8-custom-section-id_166_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.166.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_167_wasm>", "[utf8-custom-section-id_167_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.167.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_168_wasm>", "[utf8-custom-section-id_168_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.168.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_169_wasm>", "[utf8-custom-section-id_169_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.169.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_17_wasm>", "[utf8-custom-section-id_17_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.17.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_170_wasm>", "[utf8-custom-section-id_170_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.170.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_171_wasm>", "[utf8-custom-section-id_171_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.171.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_172_wasm>", "[utf8-custom-section-id_172_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.172.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_173_wasm>", "[utf8-custom-section-id_173_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.173.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_174_wasm>", "[utf8-custom-section-id_174_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.174.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_175_wasm>", "[utf8-custom-section-id_175_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.175.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_18_wasm>", "[utf8-custom-section-id_18_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.18.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_19_wasm>", "[utf8-custom-section-id_19_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.19.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_2_wasm>", "[utf8-custom-section-id_2_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.2.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_20_wasm>", "[utf8-custom-section-id_20_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.20.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_21_wasm>", "[utf8-custom-section-id_21_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.21.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_22_wasm>", "[utf8-custom-section-id_22_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.22.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_23_wasm>", "[utf8-custom-section-id_23_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.23.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_24_wasm>", "[utf8-custom-section-id_24_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.24.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_25_wasm>", "[utf8-custom-section-id_25_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.25.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_26_wasm>", "[utf8-custom-section-id_26_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.26.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_27_wasm>", "[utf8-custom-section-id_27_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.27.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_28_wasm>", "[utf8-custom-section-id_28_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.28.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_29_wasm>", "[utf8-custom-section-id_29_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.29.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_3_wasm>", "[utf8-custom-section-id_3_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.3.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_30_wasm>", "[utf8-custom-section-id_30_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.30.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_31_wasm>", "[utf8-custom-section-id_31_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.31.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_32_wasm>", "[utf8-custom-section-id_32_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.32.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_33_wasm>", "[utf8-custom-section-id_33_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.33.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_34_wasm>", "[utf8-custom-section-id_34_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.34.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_35_wasm>", "[utf8-custom-section-id_35_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.35.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_36_wasm>", "[utf8-custom-section-id_36_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.36.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_37_wasm>", "[utf8-custom-section-id_37_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.37.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_38_wasm>", "[utf8-custom-section-id_38_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.38.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_39_wasm>", "[utf8-custom-section-id_39_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.39.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_4_wasm>", "[utf8-custom-section-id_4_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.4.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_40_wasm>", "[utf8-custom-section-id_40_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.40.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_41_wasm>", "[utf8-custom-section-id_41_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.41.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_42_wasm>", "[utf8-custom-section-id_42_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.42.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_43_wasm>", "[utf8-custom-section-id_43_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.43.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_44_wasm>", "[utf8-custom-section-id_44_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.44.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_45_wasm>", "[utf8-custom-section-id_45_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.45.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_46_wasm>", "[utf8-custom-section-id_46_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.46.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_47_wasm>", "[utf8-custom-section-id_47_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.47.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_48_wasm>", "[utf8-custom-section-id_48_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.48.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_49_wasm>", "[utf8-custom-section-id_49_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.49.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_5_wasm>", "[utf8-custom-section-id_5_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.5.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_50_wasm>", "[utf8-custom-section-id_50_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.50.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_51_wasm>", "[utf8-custom-section-id_51_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.51.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_52_wasm>", "[utf8-custom-section-id_52_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.52.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_53_wasm>", "[utf8-custom-section-id_53_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.53.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_54_wasm>", "[utf8-custom-section-id_54_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.54.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_55_wasm>", "[utf8-custom-section-id_55_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.55.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_56_wasm>", "[utf8-custom-section-id_56_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.56.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_57_wasm>", "[utf8-custom-section-id_57_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.57.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_58_wasm>", "[utf8-custom-section-id_58_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.58.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_59_wasm>", "[utf8-custom-section-id_59_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.59.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_6_wasm>", "[utf8-custom-section-id_6_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.6.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_60_wasm>", "[utf8-custom-section-id_60_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.60.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_61_wasm>", "[utf8-custom-section-id_61_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.61.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_62_wasm>", "[utf8-custom-section-id_62_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.62.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_63_wasm>", "[utf8-custom-section-id_63_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.63.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_64_wasm>", "[utf8-custom-section-id_64_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.64.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_65_wasm>", "[utf8-custom-section-id_65_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.65.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_66_wasm>", "[utf8-custom-section-id_66_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.66.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_67_wasm>", "[utf8-custom-section-id_67_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.67.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_68_wasm>", "[utf8-custom-section-id_68_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.68.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_69_wasm>", "[utf8-custom-section-id_69_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.69.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_7_wasm>", "[utf8-custom-section-id_7_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.7.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_70_wasm>", "[utf8-custom-section-id_70_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.70.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_71_wasm>", "[utf8-custom-section-id_71_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.71.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_72_wasm>", "[utf8-custom-section-id_72_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.72.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_73_wasm>", "[utf8-custom-section-id_73_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.73.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_74_wasm>", "[utf8-custom-section-id_74_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.74.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_75_wasm>", "[utf8-custom-section-id_75_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.75.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_76_wasm>", "[utf8-custom-section-id_76_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.76.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_77_wasm>", "[utf8-custom-section-id_77_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.77.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_78_wasm>", "[utf8-custom-section-id_78_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.78.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_79_wasm>", "[utf8-custom-section-id_79_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.79.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_8_wasm>", "[utf8-custom-section-id_8_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.8.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_80_wasm>", "[utf8-custom-section-id_80_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.80.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_81_wasm>", "[utf8-custom-section-id_81_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.81.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_82_wasm>", "[utf8-custom-section-id_82_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.82.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_83_wasm>", "[utf8-custom-section-id_83_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.83.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_84_wasm>", "[utf8-custom-section-id_84_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.84.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_85_wasm>", "[utf8-custom-section-id_85_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.85.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_86_wasm>", "[utf8-custom-section-id_86_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.86.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_87_wasm>", "[utf8-custom-section-id_87_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.87.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_88_wasm>", "[utf8-custom-section-id_88_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.88.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_89_wasm>", "[utf8-custom-section-id_89_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.89.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_9_wasm>", "[utf8-custom-section-id_9_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.9.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_90_wasm>", "[utf8-custom-section-id_90_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.90.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_91_wasm>", "[utf8-custom-section-id_91_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.91.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_92_wasm>", "[utf8-custom-section-id_92_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.92.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_93_wasm>", "[utf8-custom-section-id_93_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.93.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_94_wasm>", "[utf8-custom-section-id_94_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.94.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_95_wasm>", "[utf8-custom-section-id_95_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.95.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_96_wasm>", "[utf8-custom-section-id_96_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.96.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_97_wasm>", "[utf8-custom-section-id_97_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.97.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_98_wasm>", "[utf8-custom-section-id_98_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.98.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <utf8-custom-section-id_99_wasm>", "[utf8-custom-section-id_99_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.99.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}