block_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 <block_0_wasm>", "[block_0_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.0.wasm");
   backend_t bkend( code, &wa );
 
   CHECK(!bkend.call_with_return("env", "empty"));
   CHECK(bkend.call_with_return("env", "singular")->to_ui32() == UINT32_C(7));
   CHECK(bkend.call_with_return("env", "multi")->to_ui32() == UINT32_C(8));
   CHECK(bkend.call_with_return("env", "nested")->to_ui32() == UINT32_C(9));
   CHECK(bkend.call_with_return("env", "deep")->to_ui32() == UINT32_C(150));
   CHECK(bkend.call_with_return("env", "as-select-first")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-select-mid")->to_ui32() == UINT32_C(2));
   CHECK(bkend.call_with_return("env", "as-select-last")->to_ui32() == UINT32_C(2));
   CHECK(bkend.call_with_return("env", "as-loop-first")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-loop-mid")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-loop-last")->to_ui32() == UINT32_C(1));
   CHECK(!bkend.call_with_return("env", "as-if-condition"));
   CHECK(bkend.call_with_return("env", "as-if-then")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-if-else")->to_ui32() == UINT32_C(2));
   CHECK(bkend.call_with_return("env", "as-br_if-first")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-br_if-last")->to_ui32() == UINT32_C(2));
   CHECK(bkend.call_with_return("env", "as-br_table-first")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-br_table-last")->to_ui32() == UINT32_C(2));
   CHECK(bkend.call_with_return("env", "as-call_indirect-first")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-call_indirect-mid")->to_ui32() == UINT32_C(2));
   CHECK(bkend.call_with_return("env", "as-call_indirect-last")->to_ui32() == UINT32_C(1));
   CHECK(!bkend.call_with_return("env", "as-store-first"));
   CHECK(!bkend.call_with_return("env", "as-store-last"));
   CHECK(bkend.call_with_return("env", "as-memory.grow-value")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-call-value")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-return-value")->to_ui32() == UINT32_C(1));
   CHECK(!bkend.call_with_return("env", "as-drop-operand"));
   CHECK(bkend.call_with_return("env", "as-br-value")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-local.set-value")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-local.tee-value")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-global.set-value")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-load-operand")->to_ui32() == UINT32_C(1));
   CHECK(bkend.call_with_return("env", "as-unary-operand")->to_ui32() == UINT32_C(0));
   CHECK(bkend.call_with_return("env", "as-binary-operand")->to_ui32() == UINT32_C(12));
   CHECK(bkend.call_with_return("env", "as-test-operand")->to_ui32() == UINT32_C(0));
   CHECK(bkend.call_with_return("env", "as-compare-operand")->to_ui32() == UINT32_C(0));
   CHECK(bkend.call_with_return("env", "break-bare")->to_ui32() == UINT32_C(19));
   CHECK(bkend.call_with_return("env", "break-value")->to_ui32() == UINT32_C(18));
   CHECK(bkend.call_with_return("env", "break-repeated")->to_ui32() == UINT32_C(18));
   CHECK(bkend.call_with_return("env", "break-inner")->to_ui32() == UINT32_C(15));
   CHECK(bkend.call_with_return("env", "effects")->to_ui32() == UINT32_C(1));
}
 
BACKEND_TEST_CASE( "Testing wasm <block_1_wasm>", "[block_1_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.1.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_10_wasm>", "[block_10_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.10.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_100_wasm>", "[block_100_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.100.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_101_wasm>", "[block_101_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.101.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_102_wasm>", "[block_102_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.102.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_103_wasm>", "[block_103_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.103.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_104_wasm>", "[block_104_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.104.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_105_wasm>", "[block_105_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.105.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_106_wasm>", "[block_106_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.106.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_107_wasm>", "[block_107_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.107.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_108_wasm>", "[block_108_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.108.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_109_wasm>", "[block_109_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.109.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_11_wasm>", "[block_11_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.11.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_110_wasm>", "[block_110_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.110.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_111_wasm>", "[block_111_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.111.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_112_wasm>", "[block_112_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.112.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_113_wasm>", "[block_113_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.113.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_114_wasm>", "[block_114_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.114.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_115_wasm>", "[block_115_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.115.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_116_wasm>", "[block_116_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.116.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_117_wasm>", "[block_117_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.117.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_118_wasm>", "[block_118_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.118.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_119_wasm>", "[block_119_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.119.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_12_wasm>", "[block_12_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.12.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_120_wasm>", "[block_120_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.120.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_121_wasm>", "[block_121_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.121.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_122_wasm>", "[block_122_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.122.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_123_wasm>", "[block_123_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.123.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_124_wasm>", "[block_124_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.124.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_125_wasm>", "[block_125_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.125.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_126_wasm>", "[block_126_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.126.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_127_wasm>", "[block_127_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.127.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_13_wasm>", "[block_13_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.13.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_14_wasm>", "[block_14_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.14.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_15_wasm>", "[block_15_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.15.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_16_wasm>", "[block_16_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.16.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_17_wasm>", "[block_17_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.17.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_18_wasm>", "[block_18_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.18.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_19_wasm>", "[block_19_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.19.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_2_wasm>", "[block_2_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.2.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_20_wasm>", "[block_20_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.20.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_21_wasm>", "[block_21_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.21.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_22_wasm>", "[block_22_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.22.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_23_wasm>", "[block_23_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.23.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_24_wasm>", "[block_24_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.24.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_25_wasm>", "[block_25_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.25.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_26_wasm>", "[block_26_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.26.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_27_wasm>", "[block_27_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.27.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_28_wasm>", "[block_28_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.28.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_29_wasm>", "[block_29_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.29.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_3_wasm>", "[block_3_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.3.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_30_wasm>", "[block_30_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.30.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_31_wasm>", "[block_31_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.31.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_32_wasm>", "[block_32_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.32.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_33_wasm>", "[block_33_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.33.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_34_wasm>", "[block_34_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.34.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_35_wasm>", "[block_35_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.35.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_36_wasm>", "[block_36_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.36.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_37_wasm>", "[block_37_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.37.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_38_wasm>", "[block_38_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.38.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_39_wasm>", "[block_39_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.39.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_4_wasm>", "[block_4_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.4.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_40_wasm>", "[block_40_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.40.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_41_wasm>", "[block_41_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.41.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_42_wasm>", "[block_42_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.42.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_43_wasm>", "[block_43_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.43.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_44_wasm>", "[block_44_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.44.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_45_wasm>", "[block_45_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.45.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_46_wasm>", "[block_46_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.46.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_47_wasm>", "[block_47_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.47.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_48_wasm>", "[block_48_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.48.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_49_wasm>", "[block_49_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.49.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_5_wasm>", "[block_5_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.5.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_50_wasm>", "[block_50_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.50.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_51_wasm>", "[block_51_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.51.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_52_wasm>", "[block_52_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.52.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_53_wasm>", "[block_53_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.53.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_54_wasm>", "[block_54_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.54.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_55_wasm>", "[block_55_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.55.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_56_wasm>", "[block_56_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.56.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_57_wasm>", "[block_57_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.57.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_58_wasm>", "[block_58_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.58.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_59_wasm>", "[block_59_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.59.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_6_wasm>", "[block_6_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.6.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_60_wasm>", "[block_60_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.60.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_61_wasm>", "[block_61_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.61.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_62_wasm>", "[block_62_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.62.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_63_wasm>", "[block_63_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.63.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_64_wasm>", "[block_64_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.64.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_65_wasm>", "[block_65_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.65.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_66_wasm>", "[block_66_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.66.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_67_wasm>", "[block_67_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.67.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_68_wasm>", "[block_68_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.68.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_69_wasm>", "[block_69_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.69.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_7_wasm>", "[block_7_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.7.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_70_wasm>", "[block_70_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.70.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_71_wasm>", "[block_71_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.71.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_72_wasm>", "[block_72_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.72.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_73_wasm>", "[block_73_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.73.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_74_wasm>", "[block_74_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.74.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_75_wasm>", "[block_75_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.75.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_76_wasm>", "[block_76_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.76.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_77_wasm>", "[block_77_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.77.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_78_wasm>", "[block_78_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.78.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_79_wasm>", "[block_79_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.79.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_8_wasm>", "[block_8_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.8.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_80_wasm>", "[block_80_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.80.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_81_wasm>", "[block_81_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.81.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_82_wasm>", "[block_82_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.82.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_83_wasm>", "[block_83_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.83.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_84_wasm>", "[block_84_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.84.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_85_wasm>", "[block_85_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.85.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_86_wasm>", "[block_86_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.86.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_87_wasm>", "[block_87_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.87.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_88_wasm>", "[block_88_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.88.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_89_wasm>", "[block_89_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.89.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_9_wasm>", "[block_9_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.9.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_90_wasm>", "[block_90_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.90.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_91_wasm>", "[block_91_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.91.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_92_wasm>", "[block_92_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.92.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_93_wasm>", "[block_93_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.93.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_94_wasm>", "[block_94_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.94.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_95_wasm>", "[block_95_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.95.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_96_wasm>", "[block_96_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.96.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_97_wasm>", "[block_97_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.97.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_98_wasm>", "[block_98_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.98.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}
 
BACKEND_TEST_CASE( "Testing wasm <block_99_wasm>", "[block_99_wasm_tests]" ) {
   using backend_t = backend<standalone_function_t, TestType>;
   auto code = read_wasm( std::string(wasm_directory) + "block.99.wasm");
   CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
}