Wire Sysio Wire Sysion 1.0.0
Loading...
Searching...
No Matches
Functions | Variables
utf8-custom-section-id_tests.cpp File Reference
#include <algorithm>
#include <vector>
#include <iostream>
#include <iterator>
#include <cmath>
#include <cstdlib>
#include <catch2/catch.hpp>
#include <utils.hpp>
#include <wasm_config.hpp>
#include <sysio/vm/backend.hpp>
Include dependency graph for utf8-custom-section-id_tests.cpp:

Go to the source code of this file.

Functions

 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_0_wasm>", "[utf8-custom-section-id_0_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_1_wasm>", "[utf8-custom-section-id_1_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_10_wasm>", "[utf8-custom-section-id_10_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_100_wasm>", "[utf8-custom-section-id_100_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_101_wasm>", "[utf8-custom-section-id_101_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_102_wasm>", "[utf8-custom-section-id_102_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_103_wasm>", "[utf8-custom-section-id_103_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_104_wasm>", "[utf8-custom-section-id_104_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_105_wasm>", "[utf8-custom-section-id_105_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_106_wasm>", "[utf8-custom-section-id_106_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_107_wasm>", "[utf8-custom-section-id_107_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_108_wasm>", "[utf8-custom-section-id_108_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_109_wasm>", "[utf8-custom-section-id_109_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_11_wasm>", "[utf8-custom-section-id_11_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_110_wasm>", "[utf8-custom-section-id_110_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_111_wasm>", "[utf8-custom-section-id_111_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_112_wasm>", "[utf8-custom-section-id_112_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_113_wasm>", "[utf8-custom-section-id_113_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_114_wasm>", "[utf8-custom-section-id_114_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_115_wasm>", "[utf8-custom-section-id_115_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_116_wasm>", "[utf8-custom-section-id_116_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_117_wasm>", "[utf8-custom-section-id_117_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_118_wasm>", "[utf8-custom-section-id_118_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_119_wasm>", "[utf8-custom-section-id_119_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_12_wasm>", "[utf8-custom-section-id_12_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_120_wasm>", "[utf8-custom-section-id_120_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_121_wasm>", "[utf8-custom-section-id_121_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_122_wasm>", "[utf8-custom-section-id_122_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_123_wasm>", "[utf8-custom-section-id_123_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_124_wasm>", "[utf8-custom-section-id_124_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_125_wasm>", "[utf8-custom-section-id_125_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_126_wasm>", "[utf8-custom-section-id_126_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_127_wasm>", "[utf8-custom-section-id_127_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_128_wasm>", "[utf8-custom-section-id_128_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_129_wasm>", "[utf8-custom-section-id_129_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_13_wasm>", "[utf8-custom-section-id_13_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_130_wasm>", "[utf8-custom-section-id_130_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_131_wasm>", "[utf8-custom-section-id_131_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_132_wasm>", "[utf8-custom-section-id_132_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_133_wasm>", "[utf8-custom-section-id_133_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_134_wasm>", "[utf8-custom-section-id_134_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_135_wasm>", "[utf8-custom-section-id_135_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_136_wasm>", "[utf8-custom-section-id_136_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_137_wasm>", "[utf8-custom-section-id_137_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_138_wasm>", "[utf8-custom-section-id_138_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_139_wasm>", "[utf8-custom-section-id_139_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_14_wasm>", "[utf8-custom-section-id_14_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_140_wasm>", "[utf8-custom-section-id_140_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_141_wasm>", "[utf8-custom-section-id_141_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_142_wasm>", "[utf8-custom-section-id_142_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_143_wasm>", "[utf8-custom-section-id_143_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_144_wasm>", "[utf8-custom-section-id_144_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_145_wasm>", "[utf8-custom-section-id_145_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_146_wasm>", "[utf8-custom-section-id_146_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_147_wasm>", "[utf8-custom-section-id_147_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_148_wasm>", "[utf8-custom-section-id_148_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_149_wasm>", "[utf8-custom-section-id_149_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_15_wasm>", "[utf8-custom-section-id_15_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_150_wasm>", "[utf8-custom-section-id_150_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_151_wasm>", "[utf8-custom-section-id_151_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_152_wasm>", "[utf8-custom-section-id_152_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_153_wasm>", "[utf8-custom-section-id_153_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_154_wasm>", "[utf8-custom-section-id_154_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_155_wasm>", "[utf8-custom-section-id_155_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_156_wasm>", "[utf8-custom-section-id_156_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_157_wasm>", "[utf8-custom-section-id_157_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_158_wasm>", "[utf8-custom-section-id_158_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_159_wasm>", "[utf8-custom-section-id_159_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_16_wasm>", "[utf8-custom-section-id_16_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_160_wasm>", "[utf8-custom-section-id_160_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_161_wasm>", "[utf8-custom-section-id_161_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_162_wasm>", "[utf8-custom-section-id_162_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_163_wasm>", "[utf8-custom-section-id_163_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_164_wasm>", "[utf8-custom-section-id_164_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_165_wasm>", "[utf8-custom-section-id_165_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_166_wasm>", "[utf8-custom-section-id_166_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_167_wasm>", "[utf8-custom-section-id_167_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_168_wasm>", "[utf8-custom-section-id_168_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_169_wasm>", "[utf8-custom-section-id_169_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_17_wasm>", "[utf8-custom-section-id_17_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_170_wasm>", "[utf8-custom-section-id_170_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_171_wasm>", "[utf8-custom-section-id_171_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_172_wasm>", "[utf8-custom-section-id_172_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_173_wasm>", "[utf8-custom-section-id_173_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_174_wasm>", "[utf8-custom-section-id_174_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_175_wasm>", "[utf8-custom-section-id_175_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_18_wasm>", "[utf8-custom-section-id_18_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_19_wasm>", "[utf8-custom-section-id_19_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_2_wasm>", "[utf8-custom-section-id_2_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_20_wasm>", "[utf8-custom-section-id_20_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_21_wasm>", "[utf8-custom-section-id_21_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_22_wasm>", "[utf8-custom-section-id_22_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_23_wasm>", "[utf8-custom-section-id_23_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_24_wasm>", "[utf8-custom-section-id_24_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_25_wasm>", "[utf8-custom-section-id_25_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_26_wasm>", "[utf8-custom-section-id_26_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_27_wasm>", "[utf8-custom-section-id_27_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_28_wasm>", "[utf8-custom-section-id_28_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_29_wasm>", "[utf8-custom-section-id_29_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_3_wasm>", "[utf8-custom-section-id_3_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_30_wasm>", "[utf8-custom-section-id_30_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_31_wasm>", "[utf8-custom-section-id_31_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_32_wasm>", "[utf8-custom-section-id_32_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_33_wasm>", "[utf8-custom-section-id_33_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_34_wasm>", "[utf8-custom-section-id_34_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_35_wasm>", "[utf8-custom-section-id_35_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_36_wasm>", "[utf8-custom-section-id_36_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_37_wasm>", "[utf8-custom-section-id_37_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_38_wasm>", "[utf8-custom-section-id_38_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_39_wasm>", "[utf8-custom-section-id_39_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_4_wasm>", "[utf8-custom-section-id_4_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_40_wasm>", "[utf8-custom-section-id_40_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_41_wasm>", "[utf8-custom-section-id_41_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_42_wasm>", "[utf8-custom-section-id_42_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_43_wasm>", "[utf8-custom-section-id_43_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_44_wasm>", "[utf8-custom-section-id_44_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_45_wasm>", "[utf8-custom-section-id_45_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_46_wasm>", "[utf8-custom-section-id_46_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_47_wasm>", "[utf8-custom-section-id_47_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_48_wasm>", "[utf8-custom-section-id_48_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_49_wasm>", "[utf8-custom-section-id_49_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_5_wasm>", "[utf8-custom-section-id_5_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_50_wasm>", "[utf8-custom-section-id_50_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_51_wasm>", "[utf8-custom-section-id_51_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_52_wasm>", "[utf8-custom-section-id_52_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_53_wasm>", "[utf8-custom-section-id_53_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_54_wasm>", "[utf8-custom-section-id_54_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_55_wasm>", "[utf8-custom-section-id_55_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_56_wasm>", "[utf8-custom-section-id_56_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_57_wasm>", "[utf8-custom-section-id_57_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_58_wasm>", "[utf8-custom-section-id_58_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_59_wasm>", "[utf8-custom-section-id_59_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_6_wasm>", "[utf8-custom-section-id_6_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_60_wasm>", "[utf8-custom-section-id_60_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_61_wasm>", "[utf8-custom-section-id_61_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_62_wasm>", "[utf8-custom-section-id_62_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_63_wasm>", "[utf8-custom-section-id_63_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_64_wasm>", "[utf8-custom-section-id_64_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_65_wasm>", "[utf8-custom-section-id_65_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_66_wasm>", "[utf8-custom-section-id_66_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_67_wasm>", "[utf8-custom-section-id_67_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_68_wasm>", "[utf8-custom-section-id_68_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_69_wasm>", "[utf8-custom-section-id_69_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_7_wasm>", "[utf8-custom-section-id_7_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_70_wasm>", "[utf8-custom-section-id_70_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_71_wasm>", "[utf8-custom-section-id_71_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_72_wasm>", "[utf8-custom-section-id_72_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_73_wasm>", "[utf8-custom-section-id_73_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_74_wasm>", "[utf8-custom-section-id_74_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_75_wasm>", "[utf8-custom-section-id_75_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_76_wasm>", "[utf8-custom-section-id_76_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_77_wasm>", "[utf8-custom-section-id_77_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_78_wasm>", "[utf8-custom-section-id_78_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_79_wasm>", "[utf8-custom-section-id_79_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_8_wasm>", "[utf8-custom-section-id_8_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_80_wasm>", "[utf8-custom-section-id_80_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_81_wasm>", "[utf8-custom-section-id_81_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_82_wasm>", "[utf8-custom-section-id_82_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_83_wasm>", "[utf8-custom-section-id_83_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_84_wasm>", "[utf8-custom-section-id_84_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_85_wasm>", "[utf8-custom-section-id_85_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_86_wasm>", "[utf8-custom-section-id_86_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_87_wasm>", "[utf8-custom-section-id_87_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_88_wasm>", "[utf8-custom-section-id_88_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_89_wasm>", "[utf8-custom-section-id_89_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_9_wasm>", "[utf8-custom-section-id_9_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_90_wasm>", "[utf8-custom-section-id_90_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_91_wasm>", "[utf8-custom-section-id_91_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_92_wasm>", "[utf8-custom-section-id_92_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_93_wasm>", "[utf8-custom-section-id_93_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_94_wasm>", "[utf8-custom-section-id_94_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_95_wasm>", "[utf8-custom-section-id_95_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_96_wasm>", "[utf8-custom-section-id_96_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_97_wasm>", "[utf8-custom-section-id_97_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_98_wasm>", "[utf8-custom-section-id_98_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-custom-section-id_99_wasm>", "[utf8-custom-section-id_99_wasm_tests]")
 

Variables

wasm_allocator wa
 

Function Documentation

◆ BACKEND_TEST_CASE() [1/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_0_wasm>" ,
"" [utf8-custom-section-id_0_wasm_tests] )

Definition at line 18 of file utf8-custom-section-id_tests.cpp.

18 {
19 using backend_t = backend<standalone_function_t, TestType>;
20 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.0.wasm");
21 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
22}
backend_t
sysio::vm::backend< rhf_t > backend_t
Definition hello_driver.cpp:61
CHECK_THROWS_AS
#define CHECK_THROWS_AS(expr, exceptionType)
Definition catch.hpp:203
sysio::vm::read_wasm
std::vector< uint8_t > read_wasm(const std::string &fname)
Definition utils.hpp:30
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [2/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_100_wasm>" ,
"" [utf8-custom-section-id_100_wasm_tests] )

Definition at line 36 of file utf8-custom-section-id_tests.cpp.

36 {
37 using backend_t = backend<standalone_function_t, TestType>;
38 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.100.wasm");
39 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
40}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [3/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_101_wasm>" ,
"" [utf8-custom-section-id_101_wasm_tests] )

Definition at line 42 of file utf8-custom-section-id_tests.cpp.

42 {
43 using backend_t = backend<standalone_function_t, TestType>;
44 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.101.wasm");
45 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
46}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [4/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_102_wasm>" ,
"" [utf8-custom-section-id_102_wasm_tests] )

Definition at line 48 of file utf8-custom-section-id_tests.cpp.

48 {
49 using backend_t = backend<standalone_function_t, TestType>;
50 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.102.wasm");
51 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
52}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [5/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_103_wasm>" ,
"" [utf8-custom-section-id_103_wasm_tests] )

Definition at line 54 of file utf8-custom-section-id_tests.cpp.

54 {
55 using backend_t = backend<standalone_function_t, TestType>;
56 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.103.wasm");
57 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
58}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [6/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_104_wasm>" ,
"" [utf8-custom-section-id_104_wasm_tests] )

Definition at line 60 of file utf8-custom-section-id_tests.cpp.

60 {
61 using backend_t = backend<standalone_function_t, TestType>;
62 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.104.wasm");
63 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
64}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [7/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_105_wasm>" ,
"" [utf8-custom-section-id_105_wasm_tests] )

Definition at line 66 of file utf8-custom-section-id_tests.cpp.

66 {
67 using backend_t = backend<standalone_function_t, TestType>;
68 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.105.wasm");
69 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
70}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [8/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_106_wasm>" ,
"" [utf8-custom-section-id_106_wasm_tests] )

Definition at line 72 of file utf8-custom-section-id_tests.cpp.

72 {
73 using backend_t = backend<standalone_function_t, TestType>;
74 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.106.wasm");
75 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
76}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [9/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_107_wasm>" ,
"" [utf8-custom-section-id_107_wasm_tests] )

Definition at line 78 of file utf8-custom-section-id_tests.cpp.

78 {
79 using backend_t = backend<standalone_function_t, TestType>;
80 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.107.wasm");
81 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
82}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [10/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_108_wasm>" ,
"" [utf8-custom-section-id_108_wasm_tests] )

Definition at line 84 of file utf8-custom-section-id_tests.cpp.

84 {
85 using backend_t = backend<standalone_function_t, TestType>;
86 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.108.wasm");
87 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
88}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [11/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_109_wasm>" ,
"" [utf8-custom-section-id_109_wasm_tests] )

Definition at line 90 of file utf8-custom-section-id_tests.cpp.

90 {
91 using backend_t = backend<standalone_function_t, TestType>;
92 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.109.wasm");
93 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
94}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [12/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_10_wasm>" ,
"" [utf8-custom-section-id_10_wasm_tests] )

Definition at line 30 of file utf8-custom-section-id_tests.cpp.

30 {
31 using backend_t = backend<standalone_function_t, TestType>;
32 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.10.wasm");
33 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
34}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [13/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_110_wasm>" ,
"" [utf8-custom-section-id_110_wasm_tests] )

Definition at line 102 of file utf8-custom-section-id_tests.cpp.

102 {
103 using backend_t = backend<standalone_function_t, TestType>;
104 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.110.wasm");
105 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
106}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [14/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_111_wasm>" ,
"" [utf8-custom-section-id_111_wasm_tests] )

Definition at line 108 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [15/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_112_wasm>" ,
"" [utf8-custom-section-id_112_wasm_tests] )

Definition at line 114 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [16/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_113_wasm>" ,
"" [utf8-custom-section-id_113_wasm_tests] )

Definition at line 120 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [17/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_114_wasm>" ,
"" [utf8-custom-section-id_114_wasm_tests] )

Definition at line 126 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [18/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_115_wasm>" ,
"" [utf8-custom-section-id_115_wasm_tests] )

Definition at line 132 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [19/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_116_wasm>" ,
"" [utf8-custom-section-id_116_wasm_tests] )

Definition at line 138 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [20/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_117_wasm>" ,
"" [utf8-custom-section-id_117_wasm_tests] )

Definition at line 144 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [21/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_118_wasm>" ,
"" [utf8-custom-section-id_118_wasm_tests] )

Definition at line 150 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [22/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_119_wasm>" ,
"" [utf8-custom-section-id_119_wasm_tests] )

Definition at line 156 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [23/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_11_wasm>" ,
"" [utf8-custom-section-id_11_wasm_tests] )

Definition at line 96 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [24/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_120_wasm>" ,
"" [utf8-custom-section-id_120_wasm_tests] )

Definition at line 168 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [25/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_121_wasm>" ,
"" [utf8-custom-section-id_121_wasm_tests] )

Definition at line 174 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [26/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_122_wasm>" ,
"" [utf8-custom-section-id_122_wasm_tests] )

Definition at line 180 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [27/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_123_wasm>" ,
"" [utf8-custom-section-id_123_wasm_tests] )

Definition at line 186 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [28/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_124_wasm>" ,
"" [utf8-custom-section-id_124_wasm_tests] )

Definition at line 192 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [29/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_125_wasm>" ,
"" [utf8-custom-section-id_125_wasm_tests] )

Definition at line 198 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [30/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_126_wasm>" ,
"" [utf8-custom-section-id_126_wasm_tests] )

Definition at line 204 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [31/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_127_wasm>" ,
"" [utf8-custom-section-id_127_wasm_tests] )

Definition at line 210 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [32/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_128_wasm>" ,
"" [utf8-custom-section-id_128_wasm_tests] )

Definition at line 216 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [33/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_129_wasm>" ,
"" [utf8-custom-section-id_129_wasm_tests] )

Definition at line 222 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [34/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_12_wasm>" ,
"" [utf8-custom-section-id_12_wasm_tests] )

Definition at line 162 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [35/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_130_wasm>" ,
"" [utf8-custom-section-id_130_wasm_tests] )

Definition at line 234 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [36/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_131_wasm>" ,
"" [utf8-custom-section-id_131_wasm_tests] )

Definition at line 240 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [37/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_132_wasm>" ,
"" [utf8-custom-section-id_132_wasm_tests] )

Definition at line 246 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [38/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_133_wasm>" ,
"" [utf8-custom-section-id_133_wasm_tests] )

Definition at line 252 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [39/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_134_wasm>" ,
"" [utf8-custom-section-id_134_wasm_tests] )

Definition at line 258 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [40/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_135_wasm>" ,
"" [utf8-custom-section-id_135_wasm_tests] )

Definition at line 264 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [41/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_136_wasm>" ,
"" [utf8-custom-section-id_136_wasm_tests] )

Definition at line 270 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [42/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_137_wasm>" ,
"" [utf8-custom-section-id_137_wasm_tests] )

Definition at line 276 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [43/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_138_wasm>" ,
"" [utf8-custom-section-id_138_wasm_tests] )

Definition at line 282 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [44/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_139_wasm>" ,
"" [utf8-custom-section-id_139_wasm_tests] )

Definition at line 288 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [45/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_13_wasm>" ,
"" [utf8-custom-section-id_13_wasm_tests] )

Definition at line 228 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [46/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_140_wasm>" ,
"" [utf8-custom-section-id_140_wasm_tests] )

Definition at line 300 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [47/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_141_wasm>" ,
"" [utf8-custom-section-id_141_wasm_tests] )

Definition at line 306 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [48/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_142_wasm>" ,
"" [utf8-custom-section-id_142_wasm_tests] )

Definition at line 312 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [49/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_143_wasm>" ,
"" [utf8-custom-section-id_143_wasm_tests] )

Definition at line 318 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [50/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_144_wasm>" ,
"" [utf8-custom-section-id_144_wasm_tests] )

Definition at line 324 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [51/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_145_wasm>" ,
"" [utf8-custom-section-id_145_wasm_tests] )

Definition at line 330 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [52/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_146_wasm>" ,
"" [utf8-custom-section-id_146_wasm_tests] )

Definition at line 336 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [53/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_147_wasm>" ,
"" [utf8-custom-section-id_147_wasm_tests] )

Definition at line 342 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [54/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_148_wasm>" ,
"" [utf8-custom-section-id_148_wasm_tests] )

Definition at line 348 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [55/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_149_wasm>" ,
"" [utf8-custom-section-id_149_wasm_tests] )

Definition at line 354 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [56/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_14_wasm>" ,
"" [utf8-custom-section-id_14_wasm_tests] )

Definition at line 294 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [57/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_150_wasm>" ,
"" [utf8-custom-section-id_150_wasm_tests] )

Definition at line 366 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [58/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_151_wasm>" ,
"" [utf8-custom-section-id_151_wasm_tests] )

Definition at line 372 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [59/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_152_wasm>" ,
"" [utf8-custom-section-id_152_wasm_tests] )

Definition at line 378 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [60/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_153_wasm>" ,
"" [utf8-custom-section-id_153_wasm_tests] )

Definition at line 384 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [61/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_154_wasm>" ,
"" [utf8-custom-section-id_154_wasm_tests] )

Definition at line 390 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [62/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_155_wasm>" ,
"" [utf8-custom-section-id_155_wasm_tests] )

Definition at line 396 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [63/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_156_wasm>" ,
"" [utf8-custom-section-id_156_wasm_tests] )

Definition at line 402 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [64/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_157_wasm>" ,
"" [utf8-custom-section-id_157_wasm_tests] )

Definition at line 408 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [65/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_158_wasm>" ,
"" [utf8-custom-section-id_158_wasm_tests] )

Definition at line 414 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [66/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_159_wasm>" ,
"" [utf8-custom-section-id_159_wasm_tests] )

Definition at line 420 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [67/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_15_wasm>" ,
"" [utf8-custom-section-id_15_wasm_tests] )

Definition at line 360 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [68/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_160_wasm>" ,
"" [utf8-custom-section-id_160_wasm_tests] )

Definition at line 432 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [69/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_161_wasm>" ,
"" [utf8-custom-section-id_161_wasm_tests] )

Definition at line 438 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [70/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_162_wasm>" ,
"" [utf8-custom-section-id_162_wasm_tests] )

Definition at line 444 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [71/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_163_wasm>" ,
"" [utf8-custom-section-id_163_wasm_tests] )

Definition at line 450 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [72/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_164_wasm>" ,
"" [utf8-custom-section-id_164_wasm_tests] )

Definition at line 456 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [73/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_165_wasm>" ,
"" [utf8-custom-section-id_165_wasm_tests] )

Definition at line 462 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [74/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_166_wasm>" ,
"" [utf8-custom-section-id_166_wasm_tests] )

Definition at line 468 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [75/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_167_wasm>" ,
"" [utf8-custom-section-id_167_wasm_tests] )

Definition at line 474 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [76/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_168_wasm>" ,
"" [utf8-custom-section-id_168_wasm_tests] )

Definition at line 480 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [77/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_169_wasm>" ,
"" [utf8-custom-section-id_169_wasm_tests] )

Definition at line 486 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [78/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_16_wasm>" ,
"" [utf8-custom-section-id_16_wasm_tests] )

Definition at line 426 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [79/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_170_wasm>" ,
"" [utf8-custom-section-id_170_wasm_tests] )

Definition at line 498 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [80/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_171_wasm>" ,
"" [utf8-custom-section-id_171_wasm_tests] )

Definition at line 504 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [81/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_172_wasm>" ,
"" [utf8-custom-section-id_172_wasm_tests] )

Definition at line 510 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [82/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_173_wasm>" ,
"" [utf8-custom-section-id_173_wasm_tests] )

Definition at line 516 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [83/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_174_wasm>" ,
"" [utf8-custom-section-id_174_wasm_tests] )

Definition at line 522 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [84/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_175_wasm>" ,
"" [utf8-custom-section-id_175_wasm_tests] )

Definition at line 528 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [85/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_17_wasm>" ,
"" [utf8-custom-section-id_17_wasm_tests] )

Definition at line 492 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [86/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_18_wasm>" ,
"" [utf8-custom-section-id_18_wasm_tests] )

Definition at line 534 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [87/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_19_wasm>" ,
"" [utf8-custom-section-id_19_wasm_tests] )

Definition at line 540 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [88/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_1_wasm>" ,
"" [utf8-custom-section-id_1_wasm_tests] )

Definition at line 24 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [89/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_20_wasm>" ,
"" [utf8-custom-section-id_20_wasm_tests] )

Definition at line 552 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [90/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_21_wasm>" ,
"" [utf8-custom-section-id_21_wasm_tests] )

Definition at line 558 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [91/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_22_wasm>" ,
"" [utf8-custom-section-id_22_wasm_tests] )

Definition at line 564 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [92/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_23_wasm>" ,
"" [utf8-custom-section-id_23_wasm_tests] )

Definition at line 570 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [93/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_24_wasm>" ,
"" [utf8-custom-section-id_24_wasm_tests] )

Definition at line 576 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [94/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_25_wasm>" ,
"" [utf8-custom-section-id_25_wasm_tests] )

Definition at line 582 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [95/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_26_wasm>" ,
"" [utf8-custom-section-id_26_wasm_tests] )

Definition at line 588 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [96/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_27_wasm>" ,
"" [utf8-custom-section-id_27_wasm_tests] )

Definition at line 594 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [97/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_28_wasm>" ,
"" [utf8-custom-section-id_28_wasm_tests] )

Definition at line 600 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [98/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_29_wasm>" ,
"" [utf8-custom-section-id_29_wasm_tests] )

Definition at line 606 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [99/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_2_wasm>" ,
"" [utf8-custom-section-id_2_wasm_tests] )

Definition at line 546 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [100/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_30_wasm>" ,
"" [utf8-custom-section-id_30_wasm_tests] )

Definition at line 618 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [101/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_31_wasm>" ,
"" [utf8-custom-section-id_31_wasm_tests] )

Definition at line 624 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [102/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_32_wasm>" ,
"" [utf8-custom-section-id_32_wasm_tests] )

Definition at line 630 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [103/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_33_wasm>" ,
"" [utf8-custom-section-id_33_wasm_tests] )

Definition at line 636 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [104/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_34_wasm>" ,
"" [utf8-custom-section-id_34_wasm_tests] )

Definition at line 642 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [105/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_35_wasm>" ,
"" [utf8-custom-section-id_35_wasm_tests] )

Definition at line 648 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [106/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_36_wasm>" ,
"" [utf8-custom-section-id_36_wasm_tests] )

Definition at line 654 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [107/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_37_wasm>" ,
"" [utf8-custom-section-id_37_wasm_tests] )

Definition at line 660 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [108/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_38_wasm>" ,
"" [utf8-custom-section-id_38_wasm_tests] )

Definition at line 666 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [109/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_39_wasm>" ,
"" [utf8-custom-section-id_39_wasm_tests] )

Definition at line 672 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [110/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_3_wasm>" ,
"" [utf8-custom-section-id_3_wasm_tests] )

Definition at line 612 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [111/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_40_wasm>" ,
"" [utf8-custom-section-id_40_wasm_tests] )

Definition at line 684 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [112/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_41_wasm>" ,
"" [utf8-custom-section-id_41_wasm_tests] )

Definition at line 690 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [113/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_42_wasm>" ,
"" [utf8-custom-section-id_42_wasm_tests] )

Definition at line 696 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [114/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_43_wasm>" ,
"" [utf8-custom-section-id_43_wasm_tests] )

Definition at line 702 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [115/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_44_wasm>" ,
"" [utf8-custom-section-id_44_wasm_tests] )

Definition at line 708 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [116/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_45_wasm>" ,
"" [utf8-custom-section-id_45_wasm_tests] )

Definition at line 714 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [117/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_46_wasm>" ,
"" [utf8-custom-section-id_46_wasm_tests] )

Definition at line 720 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [118/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_47_wasm>" ,
"" [utf8-custom-section-id_47_wasm_tests] )

Definition at line 726 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [119/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_48_wasm>" ,
"" [utf8-custom-section-id_48_wasm_tests] )

Definition at line 732 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [120/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_49_wasm>" ,
"" [utf8-custom-section-id_49_wasm_tests] )

Definition at line 738 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [121/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_4_wasm>" ,
"" [utf8-custom-section-id_4_wasm_tests] )

Definition at line 678 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [122/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_50_wasm>" ,
"" [utf8-custom-section-id_50_wasm_tests] )

Definition at line 750 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [123/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_51_wasm>" ,
"" [utf8-custom-section-id_51_wasm_tests] )

Definition at line 756 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [124/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_52_wasm>" ,
"" [utf8-custom-section-id_52_wasm_tests] )

Definition at line 762 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [125/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_53_wasm>" ,
"" [utf8-custom-section-id_53_wasm_tests] )

Definition at line 768 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [126/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_54_wasm>" ,
"" [utf8-custom-section-id_54_wasm_tests] )

Definition at line 774 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [127/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_55_wasm>" ,
"" [utf8-custom-section-id_55_wasm_tests] )

Definition at line 780 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [128/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_56_wasm>" ,
"" [utf8-custom-section-id_56_wasm_tests] )

Definition at line 786 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [129/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_57_wasm>" ,
"" [utf8-custom-section-id_57_wasm_tests] )

Definition at line 792 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [130/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_58_wasm>" ,
"" [utf8-custom-section-id_58_wasm_tests] )

Definition at line 798 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [131/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_59_wasm>" ,
"" [utf8-custom-section-id_59_wasm_tests] )

Definition at line 804 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [132/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_5_wasm>" ,
"" [utf8-custom-section-id_5_wasm_tests] )

Definition at line 744 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [133/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_60_wasm>" ,
"" [utf8-custom-section-id_60_wasm_tests] )

Definition at line 816 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [134/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_61_wasm>" ,
"" [utf8-custom-section-id_61_wasm_tests] )

Definition at line 822 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [135/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_62_wasm>" ,
"" [utf8-custom-section-id_62_wasm_tests] )

Definition at line 828 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [136/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_63_wasm>" ,
"" [utf8-custom-section-id_63_wasm_tests] )

Definition at line 834 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [137/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_64_wasm>" ,
"" [utf8-custom-section-id_64_wasm_tests] )

Definition at line 840 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [138/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_65_wasm>" ,
"" [utf8-custom-section-id_65_wasm_tests] )

Definition at line 846 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [139/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_66_wasm>" ,
"" [utf8-custom-section-id_66_wasm_tests] )

Definition at line 852 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [140/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_67_wasm>" ,
"" [utf8-custom-section-id_67_wasm_tests] )

Definition at line 858 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [141/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_68_wasm>" ,
"" [utf8-custom-section-id_68_wasm_tests] )

Definition at line 864 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [142/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_69_wasm>" ,
"" [utf8-custom-section-id_69_wasm_tests] )

Definition at line 870 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [143/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_6_wasm>" ,
"" [utf8-custom-section-id_6_wasm_tests] )

Definition at line 810 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [144/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_70_wasm>" ,
"" [utf8-custom-section-id_70_wasm_tests] )

Definition at line 882 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [145/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_71_wasm>" ,
"" [utf8-custom-section-id_71_wasm_tests] )

Definition at line 888 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [146/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_72_wasm>" ,
"" [utf8-custom-section-id_72_wasm_tests] )

Definition at line 894 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [147/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_73_wasm>" ,
"" [utf8-custom-section-id_73_wasm_tests] )

Definition at line 900 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [148/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_74_wasm>" ,
"" [utf8-custom-section-id_74_wasm_tests] )

Definition at line 906 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [149/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_75_wasm>" ,
"" [utf8-custom-section-id_75_wasm_tests] )

Definition at line 912 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [150/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_76_wasm>" ,
"" [utf8-custom-section-id_76_wasm_tests] )

Definition at line 918 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [151/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_77_wasm>" ,
"" [utf8-custom-section-id_77_wasm_tests] )

Definition at line 924 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [152/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_78_wasm>" ,
"" [utf8-custom-section-id_78_wasm_tests] )

Definition at line 930 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [153/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_79_wasm>" ,
"" [utf8-custom-section-id_79_wasm_tests] )

Definition at line 936 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [154/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_7_wasm>" ,
"" [utf8-custom-section-id_7_wasm_tests] )

Definition at line 876 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [155/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_80_wasm>" ,
"" [utf8-custom-section-id_80_wasm_tests] )

Definition at line 948 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [156/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_81_wasm>" ,
"" [utf8-custom-section-id_81_wasm_tests] )

Definition at line 954 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [157/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_82_wasm>" ,
"" [utf8-custom-section-id_82_wasm_tests] )

Definition at line 960 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [158/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_83_wasm>" ,
"" [utf8-custom-section-id_83_wasm_tests] )

Definition at line 966 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [159/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_84_wasm>" ,
"" [utf8-custom-section-id_84_wasm_tests] )

Definition at line 972 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [160/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_85_wasm>" ,
"" [utf8-custom-section-id_85_wasm_tests] )

Definition at line 978 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [161/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_86_wasm>" ,
"" [utf8-custom-section-id_86_wasm_tests] )

Definition at line 984 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [162/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_87_wasm>" ,
"" [utf8-custom-section-id_87_wasm_tests] )

Definition at line 990 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [163/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_88_wasm>" ,
"" [utf8-custom-section-id_88_wasm_tests] )

Definition at line 996 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [164/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_89_wasm>" ,
"" [utf8-custom-section-id_89_wasm_tests] )

Definition at line 1002 of file utf8-custom-section-id_tests.cpp.

1002 {
1003 using backend_t = backend<standalone_function_t, TestType>;
1004 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.89.wasm");
1005 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
1006}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [165/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_8_wasm>" ,
"" [utf8-custom-section-id_8_wasm_tests] )

Definition at line 942 of file utf8-custom-section-id_tests.cpp.

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

◆ BACKEND_TEST_CASE() [166/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_90_wasm>" ,
"" [utf8-custom-section-id_90_wasm_tests] )

Definition at line 1014 of file utf8-custom-section-id_tests.cpp.

1014 {
1015 using backend_t = backend<standalone_function_t, TestType>;
1016 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.90.wasm");
1017 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
1018}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [167/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_91_wasm>" ,
"" [utf8-custom-section-id_91_wasm_tests] )

Definition at line 1020 of file utf8-custom-section-id_tests.cpp.

1020 {
1021 using backend_t = backend<standalone_function_t, TestType>;
1022 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.91.wasm");
1023 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
1024}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [168/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_92_wasm>" ,
"" [utf8-custom-section-id_92_wasm_tests] )

Definition at line 1026 of file utf8-custom-section-id_tests.cpp.

1026 {
1027 using backend_t = backend<standalone_function_t, TestType>;
1028 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.92.wasm");
1029 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
1030}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [169/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_93_wasm>" ,
"" [utf8-custom-section-id_93_wasm_tests] )

Definition at line 1032 of file utf8-custom-section-id_tests.cpp.

1032 {
1033 using backend_t = backend<standalone_function_t, TestType>;
1034 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.93.wasm");
1035 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
1036}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [170/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_94_wasm>" ,
"" [utf8-custom-section-id_94_wasm_tests] )

Definition at line 1038 of file utf8-custom-section-id_tests.cpp.

1038 {
1039 using backend_t = backend<standalone_function_t, TestType>;
1040 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.94.wasm");
1041 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
1042}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [171/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_95_wasm>" ,
"" [utf8-custom-section-id_95_wasm_tests] )

Definition at line 1044 of file utf8-custom-section-id_tests.cpp.

1044 {
1045 using backend_t = backend<standalone_function_t, TestType>;
1046 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.95.wasm");
1047 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
1048}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [172/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_96_wasm>" ,
"" [utf8-custom-section-id_96_wasm_tests] )

Definition at line 1050 of file utf8-custom-section-id_tests.cpp.

1050 {
1051 using backend_t = backend<standalone_function_t, TestType>;
1052 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.96.wasm");
1053 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
1054}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [173/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_97_wasm>" ,
"" [utf8-custom-section-id_97_wasm_tests] )

Definition at line 1056 of file utf8-custom-section-id_tests.cpp.

1056 {
1057 using backend_t = backend<standalone_function_t, TestType>;
1058 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.97.wasm");
1059 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
1060}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [174/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_98_wasm>" ,
"" [utf8-custom-section-id_98_wasm_tests] )

Definition at line 1062 of file utf8-custom-section-id_tests.cpp.

1062 {
1063 using backend_t = backend<standalone_function_t, TestType>;
1064 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.98.wasm");
1065 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
1066}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [175/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_99_wasm>" ,
"" [utf8-custom-section-id_99_wasm_tests] )

Definition at line 1068 of file utf8-custom-section-id_tests.cpp.

1068 {
1069 using backend_t = backend<standalone_function_t, TestType>;
1070 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.99.wasm");
1071 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
1072}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [176/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-custom-section-id_9_wasm>" ,
"" [utf8-custom-section-id_9_wasm_tests] )

Definition at line 1008 of file utf8-custom-section-id_tests.cpp.

1008 {
1009 using backend_t = backend<standalone_function_t, TestType>;
1010 auto code = read_wasm( std::string(wasm_directory) + "utf8-custom-section-id.9.wasm");
1011 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
1012}
Here is the call graph for this function:

Variable Documentation

◆ wa

wasm_allocator wa
extern

Definition at line 10 of file main.cpp.