Wire Sysio Wire Sysion 1.0.0
Loading...
Searching...
No Matches
Functions | Variables
utf8-import-field_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-import-field_tests.cpp:

Go to the source code of this file.

Functions

 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_0_wasm>", "[utf8-import-field_0_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_1_wasm>", "[utf8-import-field_1_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_10_wasm>", "[utf8-import-field_10_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_100_wasm>", "[utf8-import-field_100_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_101_wasm>", "[utf8-import-field_101_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_102_wasm>", "[utf8-import-field_102_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_103_wasm>", "[utf8-import-field_103_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_104_wasm>", "[utf8-import-field_104_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_105_wasm>", "[utf8-import-field_105_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_106_wasm>", "[utf8-import-field_106_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_107_wasm>", "[utf8-import-field_107_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_108_wasm>", "[utf8-import-field_108_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_109_wasm>", "[utf8-import-field_109_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_11_wasm>", "[utf8-import-field_11_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_110_wasm>", "[utf8-import-field_110_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_111_wasm>", "[utf8-import-field_111_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_112_wasm>", "[utf8-import-field_112_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_113_wasm>", "[utf8-import-field_113_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_114_wasm>", "[utf8-import-field_114_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_115_wasm>", "[utf8-import-field_115_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_116_wasm>", "[utf8-import-field_116_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_117_wasm>", "[utf8-import-field_117_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_118_wasm>", "[utf8-import-field_118_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_119_wasm>", "[utf8-import-field_119_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_12_wasm>", "[utf8-import-field_12_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_120_wasm>", "[utf8-import-field_120_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_121_wasm>", "[utf8-import-field_121_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_122_wasm>", "[utf8-import-field_122_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_123_wasm>", "[utf8-import-field_123_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_124_wasm>", "[utf8-import-field_124_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_125_wasm>", "[utf8-import-field_125_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_126_wasm>", "[utf8-import-field_126_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_127_wasm>", "[utf8-import-field_127_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_128_wasm>", "[utf8-import-field_128_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_129_wasm>", "[utf8-import-field_129_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_13_wasm>", "[utf8-import-field_13_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_130_wasm>", "[utf8-import-field_130_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_131_wasm>", "[utf8-import-field_131_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_132_wasm>", "[utf8-import-field_132_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_133_wasm>", "[utf8-import-field_133_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_134_wasm>", "[utf8-import-field_134_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_135_wasm>", "[utf8-import-field_135_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_136_wasm>", "[utf8-import-field_136_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_137_wasm>", "[utf8-import-field_137_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_138_wasm>", "[utf8-import-field_138_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_139_wasm>", "[utf8-import-field_139_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_14_wasm>", "[utf8-import-field_14_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_140_wasm>", "[utf8-import-field_140_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_141_wasm>", "[utf8-import-field_141_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_142_wasm>", "[utf8-import-field_142_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_143_wasm>", "[utf8-import-field_143_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_144_wasm>", "[utf8-import-field_144_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_145_wasm>", "[utf8-import-field_145_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_146_wasm>", "[utf8-import-field_146_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_147_wasm>", "[utf8-import-field_147_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_148_wasm>", "[utf8-import-field_148_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_149_wasm>", "[utf8-import-field_149_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_15_wasm>", "[utf8-import-field_15_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_150_wasm>", "[utf8-import-field_150_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_151_wasm>", "[utf8-import-field_151_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_152_wasm>", "[utf8-import-field_152_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_153_wasm>", "[utf8-import-field_153_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_154_wasm>", "[utf8-import-field_154_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_155_wasm>", "[utf8-import-field_155_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_156_wasm>", "[utf8-import-field_156_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_157_wasm>", "[utf8-import-field_157_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_158_wasm>", "[utf8-import-field_158_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_159_wasm>", "[utf8-import-field_159_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_16_wasm>", "[utf8-import-field_16_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_160_wasm>", "[utf8-import-field_160_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_161_wasm>", "[utf8-import-field_161_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_162_wasm>", "[utf8-import-field_162_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_163_wasm>", "[utf8-import-field_163_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_164_wasm>", "[utf8-import-field_164_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_165_wasm>", "[utf8-import-field_165_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_166_wasm>", "[utf8-import-field_166_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_167_wasm>", "[utf8-import-field_167_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_168_wasm>", "[utf8-import-field_168_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_169_wasm>", "[utf8-import-field_169_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_17_wasm>", "[utf8-import-field_17_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_170_wasm>", "[utf8-import-field_170_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_171_wasm>", "[utf8-import-field_171_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_172_wasm>", "[utf8-import-field_172_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_173_wasm>", "[utf8-import-field_173_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_174_wasm>", "[utf8-import-field_174_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_175_wasm>", "[utf8-import-field_175_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_18_wasm>", "[utf8-import-field_18_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_19_wasm>", "[utf8-import-field_19_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_2_wasm>", "[utf8-import-field_2_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_20_wasm>", "[utf8-import-field_20_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_21_wasm>", "[utf8-import-field_21_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_22_wasm>", "[utf8-import-field_22_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_23_wasm>", "[utf8-import-field_23_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_24_wasm>", "[utf8-import-field_24_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_25_wasm>", "[utf8-import-field_25_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_26_wasm>", "[utf8-import-field_26_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_27_wasm>", "[utf8-import-field_27_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_28_wasm>", "[utf8-import-field_28_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_29_wasm>", "[utf8-import-field_29_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_3_wasm>", "[utf8-import-field_3_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_30_wasm>", "[utf8-import-field_30_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_31_wasm>", "[utf8-import-field_31_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_32_wasm>", "[utf8-import-field_32_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_33_wasm>", "[utf8-import-field_33_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_34_wasm>", "[utf8-import-field_34_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_35_wasm>", "[utf8-import-field_35_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_36_wasm>", "[utf8-import-field_36_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_37_wasm>", "[utf8-import-field_37_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_38_wasm>", "[utf8-import-field_38_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_39_wasm>", "[utf8-import-field_39_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_4_wasm>", "[utf8-import-field_4_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_40_wasm>", "[utf8-import-field_40_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_41_wasm>", "[utf8-import-field_41_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_42_wasm>", "[utf8-import-field_42_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_43_wasm>", "[utf8-import-field_43_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_44_wasm>", "[utf8-import-field_44_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_45_wasm>", "[utf8-import-field_45_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_46_wasm>", "[utf8-import-field_46_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_47_wasm>", "[utf8-import-field_47_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_48_wasm>", "[utf8-import-field_48_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_49_wasm>", "[utf8-import-field_49_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_5_wasm>", "[utf8-import-field_5_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_50_wasm>", "[utf8-import-field_50_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_51_wasm>", "[utf8-import-field_51_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_52_wasm>", "[utf8-import-field_52_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_53_wasm>", "[utf8-import-field_53_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_54_wasm>", "[utf8-import-field_54_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_55_wasm>", "[utf8-import-field_55_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_56_wasm>", "[utf8-import-field_56_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_57_wasm>", "[utf8-import-field_57_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_58_wasm>", "[utf8-import-field_58_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_59_wasm>", "[utf8-import-field_59_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_6_wasm>", "[utf8-import-field_6_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_60_wasm>", "[utf8-import-field_60_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_61_wasm>", "[utf8-import-field_61_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_62_wasm>", "[utf8-import-field_62_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_63_wasm>", "[utf8-import-field_63_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_64_wasm>", "[utf8-import-field_64_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_65_wasm>", "[utf8-import-field_65_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_66_wasm>", "[utf8-import-field_66_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_67_wasm>", "[utf8-import-field_67_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_68_wasm>", "[utf8-import-field_68_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_69_wasm>", "[utf8-import-field_69_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_7_wasm>", "[utf8-import-field_7_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_70_wasm>", "[utf8-import-field_70_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_71_wasm>", "[utf8-import-field_71_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_72_wasm>", "[utf8-import-field_72_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_73_wasm>", "[utf8-import-field_73_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_74_wasm>", "[utf8-import-field_74_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_75_wasm>", "[utf8-import-field_75_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_76_wasm>", "[utf8-import-field_76_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_77_wasm>", "[utf8-import-field_77_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_78_wasm>", "[utf8-import-field_78_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_79_wasm>", "[utf8-import-field_79_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_8_wasm>", "[utf8-import-field_8_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_80_wasm>", "[utf8-import-field_80_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_81_wasm>", "[utf8-import-field_81_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_82_wasm>", "[utf8-import-field_82_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_83_wasm>", "[utf8-import-field_83_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_84_wasm>", "[utf8-import-field_84_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_85_wasm>", "[utf8-import-field_85_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_86_wasm>", "[utf8-import-field_86_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_87_wasm>", "[utf8-import-field_87_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_88_wasm>", "[utf8-import-field_88_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_89_wasm>", "[utf8-import-field_89_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_9_wasm>", "[utf8-import-field_9_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_90_wasm>", "[utf8-import-field_90_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_91_wasm>", "[utf8-import-field_91_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_92_wasm>", "[utf8-import-field_92_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_93_wasm>", "[utf8-import-field_93_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_94_wasm>", "[utf8-import-field_94_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_95_wasm>", "[utf8-import-field_95_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_96_wasm>", "[utf8-import-field_96_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_97_wasm>", "[utf8-import-field_97_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_98_wasm>", "[utf8-import-field_98_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <utf8-import-field_99_wasm>", "[utf8-import-field_99_wasm_tests]")
 

Variables

wasm_allocator wa
 

Function Documentation

◆ BACKEND_TEST_CASE() [1/176]

BACKEND_TEST_CASE ( "Testing wasm <utf8-import-field_0_wasm>" ,
"" [utf8-import-field_0_wasm_tests] )

Definition at line 18 of file utf8-import-field_tests.cpp.

18 {
19 using backend_t = backend<standalone_function_t, TestType>;
20 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_100_wasm>" ,
"" [utf8-import-field_100_wasm_tests] )

Definition at line 36 of file utf8-import-field_tests.cpp.

36 {
37 using backend_t = backend<standalone_function_t, TestType>;
38 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_101_wasm>" ,
"" [utf8-import-field_101_wasm_tests] )

Definition at line 42 of file utf8-import-field_tests.cpp.

42 {
43 using backend_t = backend<standalone_function_t, TestType>;
44 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_102_wasm>" ,
"" [utf8-import-field_102_wasm_tests] )

Definition at line 48 of file utf8-import-field_tests.cpp.

48 {
49 using backend_t = backend<standalone_function_t, TestType>;
50 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_103_wasm>" ,
"" [utf8-import-field_103_wasm_tests] )

Definition at line 54 of file utf8-import-field_tests.cpp.

54 {
55 using backend_t = backend<standalone_function_t, TestType>;
56 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_104_wasm>" ,
"" [utf8-import-field_104_wasm_tests] )

Definition at line 60 of file utf8-import-field_tests.cpp.

60 {
61 using backend_t = backend<standalone_function_t, TestType>;
62 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_105_wasm>" ,
"" [utf8-import-field_105_wasm_tests] )

Definition at line 66 of file utf8-import-field_tests.cpp.

66 {
67 using backend_t = backend<standalone_function_t, TestType>;
68 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_106_wasm>" ,
"" [utf8-import-field_106_wasm_tests] )

Definition at line 72 of file utf8-import-field_tests.cpp.

72 {
73 using backend_t = backend<standalone_function_t, TestType>;
74 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_107_wasm>" ,
"" [utf8-import-field_107_wasm_tests] )

Definition at line 78 of file utf8-import-field_tests.cpp.

78 {
79 using backend_t = backend<standalone_function_t, TestType>;
80 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_108_wasm>" ,
"" [utf8-import-field_108_wasm_tests] )

Definition at line 84 of file utf8-import-field_tests.cpp.

84 {
85 using backend_t = backend<standalone_function_t, TestType>;
86 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_109_wasm>" ,
"" [utf8-import-field_109_wasm_tests] )

Definition at line 90 of file utf8-import-field_tests.cpp.

90 {
91 using backend_t = backend<standalone_function_t, TestType>;
92 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_10_wasm>" ,
"" [utf8-import-field_10_wasm_tests] )

Definition at line 30 of file utf8-import-field_tests.cpp.

30 {
31 using backend_t = backend<standalone_function_t, TestType>;
32 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_110_wasm>" ,
"" [utf8-import-field_110_wasm_tests] )

Definition at line 102 of file utf8-import-field_tests.cpp.

102 {
103 using backend_t = backend<standalone_function_t, TestType>;
104 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_111_wasm>" ,
"" [utf8-import-field_111_wasm_tests] )

Definition at line 108 of file utf8-import-field_tests.cpp.

108 {
109 using backend_t = backend<standalone_function_t, TestType>;
110 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_112_wasm>" ,
"" [utf8-import-field_112_wasm_tests] )

Definition at line 114 of file utf8-import-field_tests.cpp.

114 {
115 using backend_t = backend<standalone_function_t, TestType>;
116 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_113_wasm>" ,
"" [utf8-import-field_113_wasm_tests] )

Definition at line 120 of file utf8-import-field_tests.cpp.

120 {
121 using backend_t = backend<standalone_function_t, TestType>;
122 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_114_wasm>" ,
"" [utf8-import-field_114_wasm_tests] )

Definition at line 126 of file utf8-import-field_tests.cpp.

126 {
127 using backend_t = backend<standalone_function_t, TestType>;
128 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_115_wasm>" ,
"" [utf8-import-field_115_wasm_tests] )

Definition at line 132 of file utf8-import-field_tests.cpp.

132 {
133 using backend_t = backend<standalone_function_t, TestType>;
134 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_116_wasm>" ,
"" [utf8-import-field_116_wasm_tests] )

Definition at line 138 of file utf8-import-field_tests.cpp.

138 {
139 using backend_t = backend<standalone_function_t, TestType>;
140 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_117_wasm>" ,
"" [utf8-import-field_117_wasm_tests] )

Definition at line 144 of file utf8-import-field_tests.cpp.

144 {
145 using backend_t = backend<standalone_function_t, TestType>;
146 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_118_wasm>" ,
"" [utf8-import-field_118_wasm_tests] )

Definition at line 150 of file utf8-import-field_tests.cpp.

150 {
151 using backend_t = backend<standalone_function_t, TestType>;
152 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_119_wasm>" ,
"" [utf8-import-field_119_wasm_tests] )

Definition at line 156 of file utf8-import-field_tests.cpp.

156 {
157 using backend_t = backend<standalone_function_t, TestType>;
158 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_11_wasm>" ,
"" [utf8-import-field_11_wasm_tests] )

Definition at line 96 of file utf8-import-field_tests.cpp.

96 {
97 using backend_t = backend<standalone_function_t, TestType>;
98 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_120_wasm>" ,
"" [utf8-import-field_120_wasm_tests] )

Definition at line 168 of file utf8-import-field_tests.cpp.

168 {
169 using backend_t = backend<standalone_function_t, TestType>;
170 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_121_wasm>" ,
"" [utf8-import-field_121_wasm_tests] )

Definition at line 174 of file utf8-import-field_tests.cpp.

174 {
175 using backend_t = backend<standalone_function_t, TestType>;
176 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_122_wasm>" ,
"" [utf8-import-field_122_wasm_tests] )

Definition at line 180 of file utf8-import-field_tests.cpp.

180 {
181 using backend_t = backend<standalone_function_t, TestType>;
182 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_123_wasm>" ,
"" [utf8-import-field_123_wasm_tests] )

Definition at line 186 of file utf8-import-field_tests.cpp.

186 {
187 using backend_t = backend<standalone_function_t, TestType>;
188 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_124_wasm>" ,
"" [utf8-import-field_124_wasm_tests] )

Definition at line 192 of file utf8-import-field_tests.cpp.

192 {
193 using backend_t = backend<standalone_function_t, TestType>;
194 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_125_wasm>" ,
"" [utf8-import-field_125_wasm_tests] )

Definition at line 198 of file utf8-import-field_tests.cpp.

198 {
199 using backend_t = backend<standalone_function_t, TestType>;
200 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_126_wasm>" ,
"" [utf8-import-field_126_wasm_tests] )

Definition at line 204 of file utf8-import-field_tests.cpp.

204 {
205 using backend_t = backend<standalone_function_t, TestType>;
206 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_127_wasm>" ,
"" [utf8-import-field_127_wasm_tests] )

Definition at line 210 of file utf8-import-field_tests.cpp.

210 {
211 using backend_t = backend<standalone_function_t, TestType>;
212 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_128_wasm>" ,
"" [utf8-import-field_128_wasm_tests] )

Definition at line 216 of file utf8-import-field_tests.cpp.

216 {
217 using backend_t = backend<standalone_function_t, TestType>;
218 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_129_wasm>" ,
"" [utf8-import-field_129_wasm_tests] )

Definition at line 222 of file utf8-import-field_tests.cpp.

222 {
223 using backend_t = backend<standalone_function_t, TestType>;
224 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_12_wasm>" ,
"" [utf8-import-field_12_wasm_tests] )

Definition at line 162 of file utf8-import-field_tests.cpp.

162 {
163 using backend_t = backend<standalone_function_t, TestType>;
164 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_130_wasm>" ,
"" [utf8-import-field_130_wasm_tests] )

Definition at line 234 of file utf8-import-field_tests.cpp.

234 {
235 using backend_t = backend<standalone_function_t, TestType>;
236 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_131_wasm>" ,
"" [utf8-import-field_131_wasm_tests] )

Definition at line 240 of file utf8-import-field_tests.cpp.

240 {
241 using backend_t = backend<standalone_function_t, TestType>;
242 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_132_wasm>" ,
"" [utf8-import-field_132_wasm_tests] )

Definition at line 246 of file utf8-import-field_tests.cpp.

246 {
247 using backend_t = backend<standalone_function_t, TestType>;
248 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_133_wasm>" ,
"" [utf8-import-field_133_wasm_tests] )

Definition at line 252 of file utf8-import-field_tests.cpp.

252 {
253 using backend_t = backend<standalone_function_t, TestType>;
254 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_134_wasm>" ,
"" [utf8-import-field_134_wasm_tests] )

Definition at line 258 of file utf8-import-field_tests.cpp.

258 {
259 using backend_t = backend<standalone_function_t, TestType>;
260 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_135_wasm>" ,
"" [utf8-import-field_135_wasm_tests] )

Definition at line 264 of file utf8-import-field_tests.cpp.

264 {
265 using backend_t = backend<standalone_function_t, TestType>;
266 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_136_wasm>" ,
"" [utf8-import-field_136_wasm_tests] )

Definition at line 270 of file utf8-import-field_tests.cpp.

270 {
271 using backend_t = backend<standalone_function_t, TestType>;
272 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_137_wasm>" ,
"" [utf8-import-field_137_wasm_tests] )

Definition at line 276 of file utf8-import-field_tests.cpp.

276 {
277 using backend_t = backend<standalone_function_t, TestType>;
278 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_138_wasm>" ,
"" [utf8-import-field_138_wasm_tests] )

Definition at line 282 of file utf8-import-field_tests.cpp.

282 {
283 using backend_t = backend<standalone_function_t, TestType>;
284 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_139_wasm>" ,
"" [utf8-import-field_139_wasm_tests] )

Definition at line 288 of file utf8-import-field_tests.cpp.

288 {
289 using backend_t = backend<standalone_function_t, TestType>;
290 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_13_wasm>" ,
"" [utf8-import-field_13_wasm_tests] )

Definition at line 228 of file utf8-import-field_tests.cpp.

228 {
229 using backend_t = backend<standalone_function_t, TestType>;
230 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_140_wasm>" ,
"" [utf8-import-field_140_wasm_tests] )

Definition at line 300 of file utf8-import-field_tests.cpp.

300 {
301 using backend_t = backend<standalone_function_t, TestType>;
302 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_141_wasm>" ,
"" [utf8-import-field_141_wasm_tests] )

Definition at line 306 of file utf8-import-field_tests.cpp.

306 {
307 using backend_t = backend<standalone_function_t, TestType>;
308 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_142_wasm>" ,
"" [utf8-import-field_142_wasm_tests] )

Definition at line 312 of file utf8-import-field_tests.cpp.

312 {
313 using backend_t = backend<standalone_function_t, TestType>;
314 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_143_wasm>" ,
"" [utf8-import-field_143_wasm_tests] )

Definition at line 318 of file utf8-import-field_tests.cpp.

318 {
319 using backend_t = backend<standalone_function_t, TestType>;
320 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_144_wasm>" ,
"" [utf8-import-field_144_wasm_tests] )

Definition at line 324 of file utf8-import-field_tests.cpp.

324 {
325 using backend_t = backend<standalone_function_t, TestType>;
326 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_145_wasm>" ,
"" [utf8-import-field_145_wasm_tests] )

Definition at line 330 of file utf8-import-field_tests.cpp.

330 {
331 using backend_t = backend<standalone_function_t, TestType>;
332 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_146_wasm>" ,
"" [utf8-import-field_146_wasm_tests] )

Definition at line 336 of file utf8-import-field_tests.cpp.

336 {
337 using backend_t = backend<standalone_function_t, TestType>;
338 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_147_wasm>" ,
"" [utf8-import-field_147_wasm_tests] )

Definition at line 342 of file utf8-import-field_tests.cpp.

342 {
343 using backend_t = backend<standalone_function_t, TestType>;
344 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_148_wasm>" ,
"" [utf8-import-field_148_wasm_tests] )

Definition at line 348 of file utf8-import-field_tests.cpp.

348 {
349 using backend_t = backend<standalone_function_t, TestType>;
350 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_149_wasm>" ,
"" [utf8-import-field_149_wasm_tests] )

Definition at line 354 of file utf8-import-field_tests.cpp.

354 {
355 using backend_t = backend<standalone_function_t, TestType>;
356 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_14_wasm>" ,
"" [utf8-import-field_14_wasm_tests] )

Definition at line 294 of file utf8-import-field_tests.cpp.

294 {
295 using backend_t = backend<standalone_function_t, TestType>;
296 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_150_wasm>" ,
"" [utf8-import-field_150_wasm_tests] )

Definition at line 366 of file utf8-import-field_tests.cpp.

366 {
367 using backend_t = backend<standalone_function_t, TestType>;
368 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_151_wasm>" ,
"" [utf8-import-field_151_wasm_tests] )

Definition at line 372 of file utf8-import-field_tests.cpp.

372 {
373 using backend_t = backend<standalone_function_t, TestType>;
374 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_152_wasm>" ,
"" [utf8-import-field_152_wasm_tests] )

Definition at line 378 of file utf8-import-field_tests.cpp.

378 {
379 using backend_t = backend<standalone_function_t, TestType>;
380 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_153_wasm>" ,
"" [utf8-import-field_153_wasm_tests] )

Definition at line 384 of file utf8-import-field_tests.cpp.

384 {
385 using backend_t = backend<standalone_function_t, TestType>;
386 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_154_wasm>" ,
"" [utf8-import-field_154_wasm_tests] )

Definition at line 390 of file utf8-import-field_tests.cpp.

390 {
391 using backend_t = backend<standalone_function_t, TestType>;
392 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_155_wasm>" ,
"" [utf8-import-field_155_wasm_tests] )

Definition at line 396 of file utf8-import-field_tests.cpp.

396 {
397 using backend_t = backend<standalone_function_t, TestType>;
398 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_156_wasm>" ,
"" [utf8-import-field_156_wasm_tests] )

Definition at line 402 of file utf8-import-field_tests.cpp.

402 {
403 using backend_t = backend<standalone_function_t, TestType>;
404 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_157_wasm>" ,
"" [utf8-import-field_157_wasm_tests] )

Definition at line 408 of file utf8-import-field_tests.cpp.

408 {
409 using backend_t = backend<standalone_function_t, TestType>;
410 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_158_wasm>" ,
"" [utf8-import-field_158_wasm_tests] )

Definition at line 414 of file utf8-import-field_tests.cpp.

414 {
415 using backend_t = backend<standalone_function_t, TestType>;
416 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_159_wasm>" ,
"" [utf8-import-field_159_wasm_tests] )

Definition at line 420 of file utf8-import-field_tests.cpp.

420 {
421 using backend_t = backend<standalone_function_t, TestType>;
422 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_15_wasm>" ,
"" [utf8-import-field_15_wasm_tests] )

Definition at line 360 of file utf8-import-field_tests.cpp.

360 {
361 using backend_t = backend<standalone_function_t, TestType>;
362 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_160_wasm>" ,
"" [utf8-import-field_160_wasm_tests] )

Definition at line 432 of file utf8-import-field_tests.cpp.

432 {
433 using backend_t = backend<standalone_function_t, TestType>;
434 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_161_wasm>" ,
"" [utf8-import-field_161_wasm_tests] )

Definition at line 438 of file utf8-import-field_tests.cpp.

438 {
439 using backend_t = backend<standalone_function_t, TestType>;
440 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_162_wasm>" ,
"" [utf8-import-field_162_wasm_tests] )

Definition at line 444 of file utf8-import-field_tests.cpp.

444 {
445 using backend_t = backend<standalone_function_t, TestType>;
446 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_163_wasm>" ,
"" [utf8-import-field_163_wasm_tests] )

Definition at line 450 of file utf8-import-field_tests.cpp.

450 {
451 using backend_t = backend<standalone_function_t, TestType>;
452 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_164_wasm>" ,
"" [utf8-import-field_164_wasm_tests] )

Definition at line 456 of file utf8-import-field_tests.cpp.

456 {
457 using backend_t = backend<standalone_function_t, TestType>;
458 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_165_wasm>" ,
"" [utf8-import-field_165_wasm_tests] )

Definition at line 462 of file utf8-import-field_tests.cpp.

462 {
463 using backend_t = backend<standalone_function_t, TestType>;
464 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_166_wasm>" ,
"" [utf8-import-field_166_wasm_tests] )

Definition at line 468 of file utf8-import-field_tests.cpp.

468 {
469 using backend_t = backend<standalone_function_t, TestType>;
470 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_167_wasm>" ,
"" [utf8-import-field_167_wasm_tests] )

Definition at line 474 of file utf8-import-field_tests.cpp.

474 {
475 using backend_t = backend<standalone_function_t, TestType>;
476 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_168_wasm>" ,
"" [utf8-import-field_168_wasm_tests] )

Definition at line 480 of file utf8-import-field_tests.cpp.

480 {
481 using backend_t = backend<standalone_function_t, TestType>;
482 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_169_wasm>" ,
"" [utf8-import-field_169_wasm_tests] )

Definition at line 486 of file utf8-import-field_tests.cpp.

486 {
487 using backend_t = backend<standalone_function_t, TestType>;
488 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_16_wasm>" ,
"" [utf8-import-field_16_wasm_tests] )

Definition at line 426 of file utf8-import-field_tests.cpp.

426 {
427 using backend_t = backend<standalone_function_t, TestType>;
428 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_170_wasm>" ,
"" [utf8-import-field_170_wasm_tests] )

Definition at line 498 of file utf8-import-field_tests.cpp.

498 {
499 using backend_t = backend<standalone_function_t, TestType>;
500 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_171_wasm>" ,
"" [utf8-import-field_171_wasm_tests] )

Definition at line 504 of file utf8-import-field_tests.cpp.

504 {
505 using backend_t = backend<standalone_function_t, TestType>;
506 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_172_wasm>" ,
"" [utf8-import-field_172_wasm_tests] )

Definition at line 510 of file utf8-import-field_tests.cpp.

510 {
511 using backend_t = backend<standalone_function_t, TestType>;
512 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_173_wasm>" ,
"" [utf8-import-field_173_wasm_tests] )

Definition at line 516 of file utf8-import-field_tests.cpp.

516 {
517 using backend_t = backend<standalone_function_t, TestType>;
518 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_174_wasm>" ,
"" [utf8-import-field_174_wasm_tests] )

Definition at line 522 of file utf8-import-field_tests.cpp.

522 {
523 using backend_t = backend<standalone_function_t, TestType>;
524 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_175_wasm>" ,
"" [utf8-import-field_175_wasm_tests] )

Definition at line 528 of file utf8-import-field_tests.cpp.

528 {
529 using backend_t = backend<standalone_function_t, TestType>;
530 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_17_wasm>" ,
"" [utf8-import-field_17_wasm_tests] )

Definition at line 492 of file utf8-import-field_tests.cpp.

492 {
493 using backend_t = backend<standalone_function_t, TestType>;
494 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_18_wasm>" ,
"" [utf8-import-field_18_wasm_tests] )

Definition at line 534 of file utf8-import-field_tests.cpp.

534 {
535 using backend_t = backend<standalone_function_t, TestType>;
536 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_19_wasm>" ,
"" [utf8-import-field_19_wasm_tests] )

Definition at line 540 of file utf8-import-field_tests.cpp.

540 {
541 using backend_t = backend<standalone_function_t, TestType>;
542 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_1_wasm>" ,
"" [utf8-import-field_1_wasm_tests] )

Definition at line 24 of file utf8-import-field_tests.cpp.

24 {
25 using backend_t = backend<standalone_function_t, TestType>;
26 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_20_wasm>" ,
"" [utf8-import-field_20_wasm_tests] )

Definition at line 552 of file utf8-import-field_tests.cpp.

552 {
553 using backend_t = backend<standalone_function_t, TestType>;
554 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_21_wasm>" ,
"" [utf8-import-field_21_wasm_tests] )

Definition at line 558 of file utf8-import-field_tests.cpp.

558 {
559 using backend_t = backend<standalone_function_t, TestType>;
560 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_22_wasm>" ,
"" [utf8-import-field_22_wasm_tests] )

Definition at line 564 of file utf8-import-field_tests.cpp.

564 {
565 using backend_t = backend<standalone_function_t, TestType>;
566 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_23_wasm>" ,
"" [utf8-import-field_23_wasm_tests] )

Definition at line 570 of file utf8-import-field_tests.cpp.

570 {
571 using backend_t = backend<standalone_function_t, TestType>;
572 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_24_wasm>" ,
"" [utf8-import-field_24_wasm_tests] )

Definition at line 576 of file utf8-import-field_tests.cpp.

576 {
577 using backend_t = backend<standalone_function_t, TestType>;
578 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_25_wasm>" ,
"" [utf8-import-field_25_wasm_tests] )

Definition at line 582 of file utf8-import-field_tests.cpp.

582 {
583 using backend_t = backend<standalone_function_t, TestType>;
584 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_26_wasm>" ,
"" [utf8-import-field_26_wasm_tests] )

Definition at line 588 of file utf8-import-field_tests.cpp.

588 {
589 using backend_t = backend<standalone_function_t, TestType>;
590 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_27_wasm>" ,
"" [utf8-import-field_27_wasm_tests] )

Definition at line 594 of file utf8-import-field_tests.cpp.

594 {
595 using backend_t = backend<standalone_function_t, TestType>;
596 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_28_wasm>" ,
"" [utf8-import-field_28_wasm_tests] )

Definition at line 600 of file utf8-import-field_tests.cpp.

600 {
601 using backend_t = backend<standalone_function_t, TestType>;
602 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_29_wasm>" ,
"" [utf8-import-field_29_wasm_tests] )

Definition at line 606 of file utf8-import-field_tests.cpp.

606 {
607 using backend_t = backend<standalone_function_t, TestType>;
608 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_2_wasm>" ,
"" [utf8-import-field_2_wasm_tests] )

Definition at line 546 of file utf8-import-field_tests.cpp.

546 {
547 using backend_t = backend<standalone_function_t, TestType>;
548 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_30_wasm>" ,
"" [utf8-import-field_30_wasm_tests] )

Definition at line 618 of file utf8-import-field_tests.cpp.

618 {
619 using backend_t = backend<standalone_function_t, TestType>;
620 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_31_wasm>" ,
"" [utf8-import-field_31_wasm_tests] )

Definition at line 624 of file utf8-import-field_tests.cpp.

624 {
625 using backend_t = backend<standalone_function_t, TestType>;
626 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_32_wasm>" ,
"" [utf8-import-field_32_wasm_tests] )

Definition at line 630 of file utf8-import-field_tests.cpp.

630 {
631 using backend_t = backend<standalone_function_t, TestType>;
632 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_33_wasm>" ,
"" [utf8-import-field_33_wasm_tests] )

Definition at line 636 of file utf8-import-field_tests.cpp.

636 {
637 using backend_t = backend<standalone_function_t, TestType>;
638 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_34_wasm>" ,
"" [utf8-import-field_34_wasm_tests] )

Definition at line 642 of file utf8-import-field_tests.cpp.

642 {
643 using backend_t = backend<standalone_function_t, TestType>;
644 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_35_wasm>" ,
"" [utf8-import-field_35_wasm_tests] )

Definition at line 648 of file utf8-import-field_tests.cpp.

648 {
649 using backend_t = backend<standalone_function_t, TestType>;
650 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_36_wasm>" ,
"" [utf8-import-field_36_wasm_tests] )

Definition at line 654 of file utf8-import-field_tests.cpp.

654 {
655 using backend_t = backend<standalone_function_t, TestType>;
656 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_37_wasm>" ,
"" [utf8-import-field_37_wasm_tests] )

Definition at line 660 of file utf8-import-field_tests.cpp.

660 {
661 using backend_t = backend<standalone_function_t, TestType>;
662 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_38_wasm>" ,
"" [utf8-import-field_38_wasm_tests] )

Definition at line 666 of file utf8-import-field_tests.cpp.

666 {
667 using backend_t = backend<standalone_function_t, TestType>;
668 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_39_wasm>" ,
"" [utf8-import-field_39_wasm_tests] )

Definition at line 672 of file utf8-import-field_tests.cpp.

672 {
673 using backend_t = backend<standalone_function_t, TestType>;
674 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_3_wasm>" ,
"" [utf8-import-field_3_wasm_tests] )

Definition at line 612 of file utf8-import-field_tests.cpp.

612 {
613 using backend_t = backend<standalone_function_t, TestType>;
614 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_40_wasm>" ,
"" [utf8-import-field_40_wasm_tests] )

Definition at line 684 of file utf8-import-field_tests.cpp.

684 {
685 using backend_t = backend<standalone_function_t, TestType>;
686 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_41_wasm>" ,
"" [utf8-import-field_41_wasm_tests] )

Definition at line 690 of file utf8-import-field_tests.cpp.

690 {
691 using backend_t = backend<standalone_function_t, TestType>;
692 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_42_wasm>" ,
"" [utf8-import-field_42_wasm_tests] )

Definition at line 696 of file utf8-import-field_tests.cpp.

696 {
697 using backend_t = backend<standalone_function_t, TestType>;
698 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_43_wasm>" ,
"" [utf8-import-field_43_wasm_tests] )

Definition at line 702 of file utf8-import-field_tests.cpp.

702 {
703 using backend_t = backend<standalone_function_t, TestType>;
704 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_44_wasm>" ,
"" [utf8-import-field_44_wasm_tests] )

Definition at line 708 of file utf8-import-field_tests.cpp.

708 {
709 using backend_t = backend<standalone_function_t, TestType>;
710 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_45_wasm>" ,
"" [utf8-import-field_45_wasm_tests] )

Definition at line 714 of file utf8-import-field_tests.cpp.

714 {
715 using backend_t = backend<standalone_function_t, TestType>;
716 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_46_wasm>" ,
"" [utf8-import-field_46_wasm_tests] )

Definition at line 720 of file utf8-import-field_tests.cpp.

720 {
721 using backend_t = backend<standalone_function_t, TestType>;
722 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_47_wasm>" ,
"" [utf8-import-field_47_wasm_tests] )

Definition at line 726 of file utf8-import-field_tests.cpp.

726 {
727 using backend_t = backend<standalone_function_t, TestType>;
728 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_48_wasm>" ,
"" [utf8-import-field_48_wasm_tests] )

Definition at line 732 of file utf8-import-field_tests.cpp.

732 {
733 using backend_t = backend<standalone_function_t, TestType>;
734 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_49_wasm>" ,
"" [utf8-import-field_49_wasm_tests] )

Definition at line 738 of file utf8-import-field_tests.cpp.

738 {
739 using backend_t = backend<standalone_function_t, TestType>;
740 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_4_wasm>" ,
"" [utf8-import-field_4_wasm_tests] )

Definition at line 678 of file utf8-import-field_tests.cpp.

678 {
679 using backend_t = backend<standalone_function_t, TestType>;
680 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_50_wasm>" ,
"" [utf8-import-field_50_wasm_tests] )

Definition at line 750 of file utf8-import-field_tests.cpp.

750 {
751 using backend_t = backend<standalone_function_t, TestType>;
752 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_51_wasm>" ,
"" [utf8-import-field_51_wasm_tests] )

Definition at line 756 of file utf8-import-field_tests.cpp.

756 {
757 using backend_t = backend<standalone_function_t, TestType>;
758 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_52_wasm>" ,
"" [utf8-import-field_52_wasm_tests] )

Definition at line 762 of file utf8-import-field_tests.cpp.

762 {
763 using backend_t = backend<standalone_function_t, TestType>;
764 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_53_wasm>" ,
"" [utf8-import-field_53_wasm_tests] )

Definition at line 768 of file utf8-import-field_tests.cpp.

768 {
769 using backend_t = backend<standalone_function_t, TestType>;
770 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_54_wasm>" ,
"" [utf8-import-field_54_wasm_tests] )

Definition at line 774 of file utf8-import-field_tests.cpp.

774 {
775 using backend_t = backend<standalone_function_t, TestType>;
776 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_55_wasm>" ,
"" [utf8-import-field_55_wasm_tests] )

Definition at line 780 of file utf8-import-field_tests.cpp.

780 {
781 using backend_t = backend<standalone_function_t, TestType>;
782 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_56_wasm>" ,
"" [utf8-import-field_56_wasm_tests] )

Definition at line 786 of file utf8-import-field_tests.cpp.

786 {
787 using backend_t = backend<standalone_function_t, TestType>;
788 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_57_wasm>" ,
"" [utf8-import-field_57_wasm_tests] )

Definition at line 792 of file utf8-import-field_tests.cpp.

792 {
793 using backend_t = backend<standalone_function_t, TestType>;
794 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_58_wasm>" ,
"" [utf8-import-field_58_wasm_tests] )

Definition at line 798 of file utf8-import-field_tests.cpp.

798 {
799 using backend_t = backend<standalone_function_t, TestType>;
800 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_59_wasm>" ,
"" [utf8-import-field_59_wasm_tests] )

Definition at line 804 of file utf8-import-field_tests.cpp.

804 {
805 using backend_t = backend<standalone_function_t, TestType>;
806 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_5_wasm>" ,
"" [utf8-import-field_5_wasm_tests] )

Definition at line 744 of file utf8-import-field_tests.cpp.

744 {
745 using backend_t = backend<standalone_function_t, TestType>;
746 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_60_wasm>" ,
"" [utf8-import-field_60_wasm_tests] )

Definition at line 816 of file utf8-import-field_tests.cpp.

816 {
817 using backend_t = backend<standalone_function_t, TestType>;
818 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_61_wasm>" ,
"" [utf8-import-field_61_wasm_tests] )

Definition at line 822 of file utf8-import-field_tests.cpp.

822 {
823 using backend_t = backend<standalone_function_t, TestType>;
824 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_62_wasm>" ,
"" [utf8-import-field_62_wasm_tests] )

Definition at line 828 of file utf8-import-field_tests.cpp.

828 {
829 using backend_t = backend<standalone_function_t, TestType>;
830 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_63_wasm>" ,
"" [utf8-import-field_63_wasm_tests] )

Definition at line 834 of file utf8-import-field_tests.cpp.

834 {
835 using backend_t = backend<standalone_function_t, TestType>;
836 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_64_wasm>" ,
"" [utf8-import-field_64_wasm_tests] )

Definition at line 840 of file utf8-import-field_tests.cpp.

840 {
841 using backend_t = backend<standalone_function_t, TestType>;
842 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_65_wasm>" ,
"" [utf8-import-field_65_wasm_tests] )

Definition at line 846 of file utf8-import-field_tests.cpp.

846 {
847 using backend_t = backend<standalone_function_t, TestType>;
848 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_66_wasm>" ,
"" [utf8-import-field_66_wasm_tests] )

Definition at line 852 of file utf8-import-field_tests.cpp.

852 {
853 using backend_t = backend<standalone_function_t, TestType>;
854 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_67_wasm>" ,
"" [utf8-import-field_67_wasm_tests] )

Definition at line 858 of file utf8-import-field_tests.cpp.

858 {
859 using backend_t = backend<standalone_function_t, TestType>;
860 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_68_wasm>" ,
"" [utf8-import-field_68_wasm_tests] )

Definition at line 864 of file utf8-import-field_tests.cpp.

864 {
865 using backend_t = backend<standalone_function_t, TestType>;
866 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_69_wasm>" ,
"" [utf8-import-field_69_wasm_tests] )

Definition at line 870 of file utf8-import-field_tests.cpp.

870 {
871 using backend_t = backend<standalone_function_t, TestType>;
872 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_6_wasm>" ,
"" [utf8-import-field_6_wasm_tests] )

Definition at line 810 of file utf8-import-field_tests.cpp.

810 {
811 using backend_t = backend<standalone_function_t, TestType>;
812 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_70_wasm>" ,
"" [utf8-import-field_70_wasm_tests] )

Definition at line 882 of file utf8-import-field_tests.cpp.

882 {
883 using backend_t = backend<standalone_function_t, TestType>;
884 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_71_wasm>" ,
"" [utf8-import-field_71_wasm_tests] )

Definition at line 888 of file utf8-import-field_tests.cpp.

888 {
889 using backend_t = backend<standalone_function_t, TestType>;
890 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_72_wasm>" ,
"" [utf8-import-field_72_wasm_tests] )

Definition at line 894 of file utf8-import-field_tests.cpp.

894 {
895 using backend_t = backend<standalone_function_t, TestType>;
896 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_73_wasm>" ,
"" [utf8-import-field_73_wasm_tests] )

Definition at line 900 of file utf8-import-field_tests.cpp.

900 {
901 using backend_t = backend<standalone_function_t, TestType>;
902 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_74_wasm>" ,
"" [utf8-import-field_74_wasm_tests] )

Definition at line 906 of file utf8-import-field_tests.cpp.

906 {
907 using backend_t = backend<standalone_function_t, TestType>;
908 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_75_wasm>" ,
"" [utf8-import-field_75_wasm_tests] )

Definition at line 912 of file utf8-import-field_tests.cpp.

912 {
913 using backend_t = backend<standalone_function_t, TestType>;
914 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_76_wasm>" ,
"" [utf8-import-field_76_wasm_tests] )

Definition at line 918 of file utf8-import-field_tests.cpp.

918 {
919 using backend_t = backend<standalone_function_t, TestType>;
920 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_77_wasm>" ,
"" [utf8-import-field_77_wasm_tests] )

Definition at line 924 of file utf8-import-field_tests.cpp.

924 {
925 using backend_t = backend<standalone_function_t, TestType>;
926 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_78_wasm>" ,
"" [utf8-import-field_78_wasm_tests] )

Definition at line 930 of file utf8-import-field_tests.cpp.

930 {
931 using backend_t = backend<standalone_function_t, TestType>;
932 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_79_wasm>" ,
"" [utf8-import-field_79_wasm_tests] )

Definition at line 936 of file utf8-import-field_tests.cpp.

936 {
937 using backend_t = backend<standalone_function_t, TestType>;
938 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_7_wasm>" ,
"" [utf8-import-field_7_wasm_tests] )

Definition at line 876 of file utf8-import-field_tests.cpp.

876 {
877 using backend_t = backend<standalone_function_t, TestType>;
878 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_80_wasm>" ,
"" [utf8-import-field_80_wasm_tests] )

Definition at line 948 of file utf8-import-field_tests.cpp.

948 {
949 using backend_t = backend<standalone_function_t, TestType>;
950 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_81_wasm>" ,
"" [utf8-import-field_81_wasm_tests] )

Definition at line 954 of file utf8-import-field_tests.cpp.

954 {
955 using backend_t = backend<standalone_function_t, TestType>;
956 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_82_wasm>" ,
"" [utf8-import-field_82_wasm_tests] )

Definition at line 960 of file utf8-import-field_tests.cpp.

960 {
961 using backend_t = backend<standalone_function_t, TestType>;
962 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_83_wasm>" ,
"" [utf8-import-field_83_wasm_tests] )

Definition at line 966 of file utf8-import-field_tests.cpp.

966 {
967 using backend_t = backend<standalone_function_t, TestType>;
968 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_84_wasm>" ,
"" [utf8-import-field_84_wasm_tests] )

Definition at line 972 of file utf8-import-field_tests.cpp.

972 {
973 using backend_t = backend<standalone_function_t, TestType>;
974 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_85_wasm>" ,
"" [utf8-import-field_85_wasm_tests] )

Definition at line 978 of file utf8-import-field_tests.cpp.

978 {
979 using backend_t = backend<standalone_function_t, TestType>;
980 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_86_wasm>" ,
"" [utf8-import-field_86_wasm_tests] )

Definition at line 984 of file utf8-import-field_tests.cpp.

984 {
985 using backend_t = backend<standalone_function_t, TestType>;
986 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_87_wasm>" ,
"" [utf8-import-field_87_wasm_tests] )

Definition at line 990 of file utf8-import-field_tests.cpp.

990 {
991 using backend_t = backend<standalone_function_t, TestType>;
992 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_88_wasm>" ,
"" [utf8-import-field_88_wasm_tests] )

Definition at line 996 of file utf8-import-field_tests.cpp.

996 {
997 using backend_t = backend<standalone_function_t, TestType>;
998 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_89_wasm>" ,
"" [utf8-import-field_89_wasm_tests] )

Definition at line 1002 of file utf8-import-field_tests.cpp.

1002 {
1003 using backend_t = backend<standalone_function_t, TestType>;
1004 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_8_wasm>" ,
"" [utf8-import-field_8_wasm_tests] )

Definition at line 942 of file utf8-import-field_tests.cpp.

942 {
943 using backend_t = backend<standalone_function_t, TestType>;
944 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_90_wasm>" ,
"" [utf8-import-field_90_wasm_tests] )

Definition at line 1014 of file utf8-import-field_tests.cpp.

1014 {
1015 using backend_t = backend<standalone_function_t, TestType>;
1016 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_91_wasm>" ,
"" [utf8-import-field_91_wasm_tests] )

Definition at line 1020 of file utf8-import-field_tests.cpp.

1020 {
1021 using backend_t = backend<standalone_function_t, TestType>;
1022 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_92_wasm>" ,
"" [utf8-import-field_92_wasm_tests] )

Definition at line 1026 of file utf8-import-field_tests.cpp.

1026 {
1027 using backend_t = backend<standalone_function_t, TestType>;
1028 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_93_wasm>" ,
"" [utf8-import-field_93_wasm_tests] )

Definition at line 1032 of file utf8-import-field_tests.cpp.

1032 {
1033 using backend_t = backend<standalone_function_t, TestType>;
1034 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_94_wasm>" ,
"" [utf8-import-field_94_wasm_tests] )

Definition at line 1038 of file utf8-import-field_tests.cpp.

1038 {
1039 using backend_t = backend<standalone_function_t, TestType>;
1040 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_95_wasm>" ,
"" [utf8-import-field_95_wasm_tests] )

Definition at line 1044 of file utf8-import-field_tests.cpp.

1044 {
1045 using backend_t = backend<standalone_function_t, TestType>;
1046 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_96_wasm>" ,
"" [utf8-import-field_96_wasm_tests] )

Definition at line 1050 of file utf8-import-field_tests.cpp.

1050 {
1051 using backend_t = backend<standalone_function_t, TestType>;
1052 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_97_wasm>" ,
"" [utf8-import-field_97_wasm_tests] )

Definition at line 1056 of file utf8-import-field_tests.cpp.

1056 {
1057 using backend_t = backend<standalone_function_t, TestType>;
1058 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_98_wasm>" ,
"" [utf8-import-field_98_wasm_tests] )

Definition at line 1062 of file utf8-import-field_tests.cpp.

1062 {
1063 using backend_t = backend<standalone_function_t, TestType>;
1064 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_99_wasm>" ,
"" [utf8-import-field_99_wasm_tests] )

Definition at line 1068 of file utf8-import-field_tests.cpp.

1068 {
1069 using backend_t = backend<standalone_function_t, TestType>;
1070 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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-import-field_9_wasm>" ,
"" [utf8-import-field_9_wasm_tests] )

Definition at line 1008 of file utf8-import-field_tests.cpp.

1008 {
1009 using backend_t = backend<standalone_function_t, TestType>;
1010 auto code = read_wasm( std::string(wasm_directory) + "utf8-import-field.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.