unreached-invalid_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 <unreached-invalid_0_wasm>", "[unreached-invalid_0_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.0.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_1_wasm>", "[unreached-invalid_1_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.1.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_10_wasm>", "[unreached-invalid_10_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.10.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_100_wasm>", "[unreached-invalid_100_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.100.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_101_wasm>", "[unreached-invalid_101_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.101.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_102_wasm>", "[unreached-invalid_102_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.102.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_103_wasm>", "[unreached-invalid_103_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.103.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_104_wasm>", "[unreached-invalid_104_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.104.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_105_wasm>", "[unreached-invalid_105_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.105.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_106_wasm>", "[unreached-invalid_106_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.106.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_107_wasm>", "[unreached-invalid_107_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.107.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_108_wasm>", "[unreached-invalid_108_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.108.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_109_wasm>", "[unreached-invalid_109_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.109.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_11_wasm>", "[unreached-invalid_11_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.11.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_110_wasm>", "[unreached-invalid_110_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.110.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_12_wasm>", "[unreached-invalid_12_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.12.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_13_wasm>", "[unreached-invalid_13_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.13.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_14_wasm>", "[unreached-invalid_14_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.14.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_15_wasm>", "[unreached-invalid_15_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.15.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_16_wasm>", "[unreached-invalid_16_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.16.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_17_wasm>", "[unreached-invalid_17_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.17.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_18_wasm>", "[unreached-invalid_18_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.18.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_19_wasm>", "[unreached-invalid_19_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.19.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_2_wasm>", "[unreached-invalid_2_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.2.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_20_wasm>", "[unreached-invalid_20_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.20.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_21_wasm>", "[unreached-invalid_21_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.21.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_22_wasm>", "[unreached-invalid_22_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.22.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_23_wasm>", "[unreached-invalid_23_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.23.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_24_wasm>", "[unreached-invalid_24_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.24.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_25_wasm>", "[unreached-invalid_25_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.25.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_26_wasm>", "[unreached-invalid_26_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.26.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_27_wasm>", "[unreached-invalid_27_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.27.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_28_wasm>", "[unreached-invalid_28_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.28.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_29_wasm>", "[unreached-invalid_29_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.29.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_3_wasm>", "[unreached-invalid_3_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.3.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_30_wasm>", "[unreached-invalid_30_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.30.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_31_wasm>", "[unreached-invalid_31_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.31.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_32_wasm>", "[unreached-invalid_32_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.32.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_33_wasm>", "[unreached-invalid_33_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.33.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_34_wasm>", "[unreached-invalid_34_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.34.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_35_wasm>", "[unreached-invalid_35_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.35.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_36_wasm>", "[unreached-invalid_36_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.36.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_37_wasm>", "[unreached-invalid_37_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.37.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_38_wasm>", "[unreached-invalid_38_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.38.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_39_wasm>", "[unreached-invalid_39_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.39.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_4_wasm>", "[unreached-invalid_4_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.4.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_40_wasm>", "[unreached-invalid_40_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.40.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_41_wasm>", "[unreached-invalid_41_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.41.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_42_wasm>", "[unreached-invalid_42_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.42.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_43_wasm>", "[unreached-invalid_43_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.43.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_44_wasm>", "[unreached-invalid_44_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.44.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_45_wasm>", "[unreached-invalid_45_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.45.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_46_wasm>", "[unreached-invalid_46_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.46.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_47_wasm>", "[unreached-invalid_47_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.47.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_48_wasm>", "[unreached-invalid_48_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.48.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_49_wasm>", "[unreached-invalid_49_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.49.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_5_wasm>", "[unreached-invalid_5_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.5.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_50_wasm>", "[unreached-invalid_50_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.50.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_51_wasm>", "[unreached-invalid_51_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.51.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_52_wasm>", "[unreached-invalid_52_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.52.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_53_wasm>", "[unreached-invalid_53_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.53.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_54_wasm>", "[unreached-invalid_54_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.54.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_55_wasm>", "[unreached-invalid_55_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.55.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_56_wasm>", "[unreached-invalid_56_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.56.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_57_wasm>", "[unreached-invalid_57_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.57.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_58_wasm>", "[unreached-invalid_58_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.58.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_59_wasm>", "[unreached-invalid_59_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.59.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_6_wasm>", "[unreached-invalid_6_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.6.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_60_wasm>", "[unreached-invalid_60_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.60.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_61_wasm>", "[unreached-invalid_61_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.61.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_62_wasm>", "[unreached-invalid_62_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.62.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_63_wasm>", "[unreached-invalid_63_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.63.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_64_wasm>", "[unreached-invalid_64_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.64.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_65_wasm>", "[unreached-invalid_65_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.65.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_66_wasm>", "[unreached-invalid_66_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.66.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_67_wasm>", "[unreached-invalid_67_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.67.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_68_wasm>", "[unreached-invalid_68_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.68.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_69_wasm>", "[unreached-invalid_69_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.69.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_7_wasm>", "[unreached-invalid_7_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.7.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_70_wasm>", "[unreached-invalid_70_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.70.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_71_wasm>", "[unreached-invalid_71_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.71.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_72_wasm>", "[unreached-invalid_72_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.72.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_73_wasm>", "[unreached-invalid_73_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.73.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_74_wasm>", "[unreached-invalid_74_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.74.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_75_wasm>", "[unreached-invalid_75_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.75.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_76_wasm>", "[unreached-invalid_76_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.76.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_77_wasm>", "[unreached-invalid_77_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.77.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_78_wasm>", "[unreached-invalid_78_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.78.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_79_wasm>", "[unreached-invalid_79_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.79.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_8_wasm>", "[unreached-invalid_8_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.8.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_80_wasm>", "[unreached-invalid_80_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.80.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_81_wasm>", "[unreached-invalid_81_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.81.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_82_wasm>", "[unreached-invalid_82_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.82.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_83_wasm>", "[unreached-invalid_83_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.83.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_84_wasm>", "[unreached-invalid_84_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.84.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_85_wasm>", "[unreached-invalid_85_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.85.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_86_wasm>", "[unreached-invalid_86_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.86.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_87_wasm>", "[unreached-invalid_87_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.87.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_88_wasm>", "[unreached-invalid_88_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.88.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_89_wasm>", "[unreached-invalid_89_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.89.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_9_wasm>", "[unreached-invalid_9_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.9.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_90_wasm>", "[unreached-invalid_90_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.90.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_91_wasm>", "[unreached-invalid_91_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.91.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_92_wasm>", "[unreached-invalid_92_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.92.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_93_wasm>", "[unreached-invalid_93_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.93.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_94_wasm>", "[unreached-invalid_94_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.94.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_95_wasm>", "[unreached-invalid_95_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.95.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_96_wasm>", "[unreached-invalid_96_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.96.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_97_wasm>", "[unreached-invalid_97_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.97.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_98_wasm>", "[unreached-invalid_98_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.98.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <unreached-invalid_99_wasm>", "[unreached-invalid_99_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "unreached-invalid.99.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}