Wire Sysio Wire Sysion 1.0.0
Loading...
Searching...
No Matches
Functions | Variables
const_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 const_tests.cpp:

Go to the source code of this file.

Functions

 BACKEND_TEST_CASE ("Testing wasm <const_0_wasm>", "[const_0_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_1_wasm>", "[const_1_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_100_wasm>", "[const_100_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_101_wasm>", "[const_101_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_102_wasm>", "[const_102_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_103_wasm>", "[const_103_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_104_wasm>", "[const_104_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_105_wasm>", "[const_105_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_106_wasm>", "[const_106_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_107_wasm>", "[const_107_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_108_wasm>", "[const_108_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_109_wasm>", "[const_109_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_110_wasm>", "[const_110_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_111_wasm>", "[const_111_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_112_wasm>", "[const_112_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_113_wasm>", "[const_113_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_114_wasm>", "[const_114_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_115_wasm>", "[const_115_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_116_wasm>", "[const_116_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_117_wasm>", "[const_117_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_118_wasm>", "[const_118_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_119_wasm>", "[const_119_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_12_wasm>", "[const_12_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_120_wasm>", "[const_120_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_121_wasm>", "[const_121_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_122_wasm>", "[const_122_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_123_wasm>", "[const_123_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_124_wasm>", "[const_124_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_125_wasm>", "[const_125_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_126_wasm>", "[const_126_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_127_wasm>", "[const_127_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_128_wasm>", "[const_128_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_129_wasm>", "[const_129_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_13_wasm>", "[const_13_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_130_wasm>", "[const_130_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_131_wasm>", "[const_131_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_132_wasm>", "[const_132_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_133_wasm>", "[const_133_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_134_wasm>", "[const_134_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_135_wasm>", "[const_135_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_136_wasm>", "[const_136_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_137_wasm>", "[const_137_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_138_wasm>", "[const_138_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_139_wasm>", "[const_139_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_140_wasm>", "[const_140_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_141_wasm>", "[const_141_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_142_wasm>", "[const_142_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_143_wasm>", "[const_143_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_144_wasm>", "[const_144_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_145_wasm>", "[const_145_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_146_wasm>", "[const_146_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_147_wasm>", "[const_147_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_148_wasm>", "[const_148_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_149_wasm>", "[const_149_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_150_wasm>", "[const_150_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_151_wasm>", "[const_151_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_152_wasm>", "[const_152_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_153_wasm>", "[const_153_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_154_wasm>", "[const_154_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_155_wasm>", "[const_155_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_156_wasm>", "[const_156_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_157_wasm>", "[const_157_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_158_wasm>", "[const_158_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_159_wasm>", "[const_159_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_16_wasm>", "[const_16_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_160_wasm>", "[const_160_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_161_wasm>", "[const_161_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_162_wasm>", "[const_162_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_163_wasm>", "[const_163_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_164_wasm>", "[const_164_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_165_wasm>", "[const_165_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_166_wasm>", "[const_166_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_167_wasm>", "[const_167_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_168_wasm>", "[const_168_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_169_wasm>", "[const_169_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_17_wasm>", "[const_17_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_170_wasm>", "[const_170_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_171_wasm>", "[const_171_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_172_wasm>", "[const_172_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_173_wasm>", "[const_173_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_174_wasm>", "[const_174_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_175_wasm>", "[const_175_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_176_wasm>", "[const_176_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_177_wasm>", "[const_177_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_178_wasm>", "[const_178_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_179_wasm>", "[const_179_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_18_wasm>", "[const_18_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_180_wasm>", "[const_180_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_181_wasm>", "[const_181_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_182_wasm>", "[const_182_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_183_wasm>", "[const_183_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_184_wasm>", "[const_184_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_185_wasm>", "[const_185_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_186_wasm>", "[const_186_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_187_wasm>", "[const_187_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_188_wasm>", "[const_188_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_189_wasm>", "[const_189_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_19_wasm>", "[const_19_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_190_wasm>", "[const_190_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_191_wasm>", "[const_191_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_192_wasm>", "[const_192_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_193_wasm>", "[const_193_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_194_wasm>", "[const_194_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_195_wasm>", "[const_195_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_196_wasm>", "[const_196_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_197_wasm>", "[const_197_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_198_wasm>", "[const_198_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_199_wasm>", "[const_199_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_20_wasm>", "[const_20_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_200_wasm>", "[const_200_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_201_wasm>", "[const_201_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_202_wasm>", "[const_202_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_203_wasm>", "[const_203_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_204_wasm>", "[const_204_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_205_wasm>", "[const_205_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_206_wasm>", "[const_206_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_207_wasm>", "[const_207_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_208_wasm>", "[const_208_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_209_wasm>", "[const_209_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_21_wasm>", "[const_21_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_210_wasm>", "[const_210_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_211_wasm>", "[const_211_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_212_wasm>", "[const_212_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_213_wasm>", "[const_213_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_214_wasm>", "[const_214_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_215_wasm>", "[const_215_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_216_wasm>", "[const_216_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_217_wasm>", "[const_217_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_218_wasm>", "[const_218_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_219_wasm>", "[const_219_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_22_wasm>", "[const_22_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_220_wasm>", "[const_220_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_221_wasm>", "[const_221_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_222_wasm>", "[const_222_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_223_wasm>", "[const_223_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_224_wasm>", "[const_224_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_225_wasm>", "[const_225_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_226_wasm>", "[const_226_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_227_wasm>", "[const_227_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_228_wasm>", "[const_228_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_229_wasm>", "[const_229_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_23_wasm>", "[const_23_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_230_wasm>", "[const_230_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_231_wasm>", "[const_231_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_232_wasm>", "[const_232_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_233_wasm>", "[const_233_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_234_wasm>", "[const_234_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_235_wasm>", "[const_235_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_236_wasm>", "[const_236_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_237_wasm>", "[const_237_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_238_wasm>", "[const_238_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_239_wasm>", "[const_239_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_24_wasm>", "[const_24_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_240_wasm>", "[const_240_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_241_wasm>", "[const_241_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_242_wasm>", "[const_242_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_243_wasm>", "[const_243_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_244_wasm>", "[const_244_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_245_wasm>", "[const_245_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_246_wasm>", "[const_246_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_247_wasm>", "[const_247_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_248_wasm>", "[const_248_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_249_wasm>", "[const_249_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_25_wasm>", "[const_25_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_250_wasm>", "[const_250_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_251_wasm>", "[const_251_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_252_wasm>", "[const_252_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_253_wasm>", "[const_253_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_254_wasm>", "[const_254_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_255_wasm>", "[const_255_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_256_wasm>", "[const_256_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_257_wasm>", "[const_257_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_258_wasm>", "[const_258_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_259_wasm>", "[const_259_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_260_wasm>", "[const_260_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_261_wasm>", "[const_261_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_262_wasm>", "[const_262_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_263_wasm>", "[const_263_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_264_wasm>", "[const_264_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_265_wasm>", "[const_265_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_266_wasm>", "[const_266_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_267_wasm>", "[const_267_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_268_wasm>", "[const_268_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_269_wasm>", "[const_269_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_270_wasm>", "[const_270_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_271_wasm>", "[const_271_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_272_wasm>", "[const_272_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_273_wasm>", "[const_273_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_274_wasm>", "[const_274_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_275_wasm>", "[const_275_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_276_wasm>", "[const_276_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_277_wasm>", "[const_277_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_278_wasm>", "[const_278_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_279_wasm>", "[const_279_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_280_wasm>", "[const_280_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_281_wasm>", "[const_281_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_282_wasm>", "[const_282_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_283_wasm>", "[const_283_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_284_wasm>", "[const_284_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_285_wasm>", "[const_285_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_286_wasm>", "[const_286_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_287_wasm>", "[const_287_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_288_wasm>", "[const_288_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_289_wasm>", "[const_289_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_290_wasm>", "[const_290_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_291_wasm>", "[const_291_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_292_wasm>", "[const_292_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_293_wasm>", "[const_293_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_294_wasm>", "[const_294_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_295_wasm>", "[const_295_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_296_wasm>", "[const_296_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_297_wasm>", "[const_297_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_298_wasm>", "[const_298_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_299_wasm>", "[const_299_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_30_wasm>", "[const_30_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_300_wasm>", "[const_300_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_301_wasm>", "[const_301_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_302_wasm>", "[const_302_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_303_wasm>", "[const_303_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_304_wasm>", "[const_304_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_305_wasm>", "[const_305_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_306_wasm>", "[const_306_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_307_wasm>", "[const_307_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_308_wasm>", "[const_308_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_309_wasm>", "[const_309_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_31_wasm>", "[const_31_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_310_wasm>", "[const_310_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_311_wasm>", "[const_311_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_312_wasm>", "[const_312_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_313_wasm>", "[const_313_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_314_wasm>", "[const_314_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_315_wasm>", "[const_315_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_316_wasm>", "[const_316_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_317_wasm>", "[const_317_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_318_wasm>", "[const_318_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_319_wasm>", "[const_319_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_320_wasm>", "[const_320_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_321_wasm>", "[const_321_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_322_wasm>", "[const_322_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_323_wasm>", "[const_323_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_324_wasm>", "[const_324_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_325_wasm>", "[const_325_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_326_wasm>", "[const_326_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_327_wasm>", "[const_327_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_328_wasm>", "[const_328_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_329_wasm>", "[const_329_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_330_wasm>", "[const_330_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_331_wasm>", "[const_331_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_332_wasm>", "[const_332_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_333_wasm>", "[const_333_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_334_wasm>", "[const_334_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_335_wasm>", "[const_335_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_336_wasm>", "[const_336_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_337_wasm>", "[const_337_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_338_wasm>", "[const_338_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_339_wasm>", "[const_339_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_34_wasm>", "[const_34_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_340_wasm>", "[const_340_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_341_wasm>", "[const_341_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_342_wasm>", "[const_342_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_343_wasm>", "[const_343_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_344_wasm>", "[const_344_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_345_wasm>", "[const_345_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_346_wasm>", "[const_346_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_347_wasm>", "[const_347_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_348_wasm>", "[const_348_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_349_wasm>", "[const_349_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_35_wasm>", "[const_35_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_350_wasm>", "[const_350_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_351_wasm>", "[const_351_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_352_wasm>", "[const_352_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_353_wasm>", "[const_353_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_354_wasm>", "[const_354_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_355_wasm>", "[const_355_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_356_wasm>", "[const_356_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_357_wasm>", "[const_357_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_358_wasm>", "[const_358_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_359_wasm>", "[const_359_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_360_wasm>", "[const_360_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_361_wasm>", "[const_361_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_362_wasm>", "[const_362_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_363_wasm>", "[const_363_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_364_wasm>", "[const_364_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_365_wasm>", "[const_365_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_366_wasm>", "[const_366_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_367_wasm>", "[const_367_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_38_wasm>", "[const_38_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_39_wasm>", "[const_39_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_4_wasm>", "[const_4_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_40_wasm>", "[const_40_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_41_wasm>", "[const_41_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_42_wasm>", "[const_42_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_43_wasm>", "[const_43_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_44_wasm>", "[const_44_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_45_wasm>", "[const_45_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_5_wasm>", "[const_5_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_50_wasm>", "[const_50_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_51_wasm>", "[const_51_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_54_wasm>", "[const_54_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_55_wasm>", "[const_55_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_58_wasm>", "[const_58_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_59_wasm>", "[const_59_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_60_wasm>", "[const_60_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_61_wasm>", "[const_61_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_68_wasm>", "[const_68_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_69_wasm>", "[const_69_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_70_wasm>", "[const_70_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_71_wasm>", "[const_71_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_72_wasm>", "[const_72_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_73_wasm>", "[const_73_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_74_wasm>", "[const_74_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_75_wasm>", "[const_75_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_76_wasm>", "[const_76_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_77_wasm>", "[const_77_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_78_wasm>", "[const_78_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_79_wasm>", "[const_79_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_8_wasm>", "[const_8_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_80_wasm>", "[const_80_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_81_wasm>", "[const_81_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_82_wasm>", "[const_82_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_83_wasm>", "[const_83_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_84_wasm>", "[const_84_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_85_wasm>", "[const_85_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_86_wasm>", "[const_86_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_87_wasm>", "[const_87_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_88_wasm>", "[const_88_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_89_wasm>", "[const_89_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_9_wasm>", "[const_9_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_90_wasm>", "[const_90_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_91_wasm>", "[const_91_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_92_wasm>", "[const_92_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_93_wasm>", "[const_93_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_94_wasm>", "[const_94_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_95_wasm>", "[const_95_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_96_wasm>", "[const_96_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_97_wasm>", "[const_97_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_98_wasm>", "[const_98_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <const_99_wasm>", "[const_99_wasm_tests]")
 

Variables

wasm_allocator wa
 

Function Documentation

◆ BACKEND_TEST_CASE() [1/338]

BACKEND_TEST_CASE ( "Testing wasm <const_0_wasm>" ,
"" [const_0_wasm_tests] )

Definition at line 18 of file const_tests.cpp.

18 {
19 using backend_t = backend<standalone_function_t, TestType>;
20 auto code = read_wasm( std::string(wasm_directory) + "const.0.wasm");
21 backend_t bkend( code, &wa );
22
23}
wa
wasm_allocator wa
Definition main.cpp:10
bkend
backend_t bkend(hello_wasm, ehm, &wa)
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/338]

BACKEND_TEST_CASE ( "Testing wasm <const_100_wasm>" ,
"" [const_100_wasm_tests] )

Definition at line 32 of file const_tests.cpp.

32 {
33 using backend_t = backend<standalone_function_t, TestType>;
34 auto code = read_wasm( std::string(wasm_directory) + "const.100.wasm");
35 backend_t bkend( code, &wa );
36
37 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
38}
sysio::vm::backend::call_with_return
auto call_with_return(host_t &host, const std::string_view &mod, const std::string_view &func, Args... args)
Definition backend.hpp:178
CHECK
#define CHECK(cond)
Definition util.h:80
UINT32_C
#define UINT32_C(val)
Definition stdint.h:283
bit_cast
T bit_cast(const U &u)
Definition utils.hpp:35
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [3/338]

BACKEND_TEST_CASE ( "Testing wasm <const_101_wasm>" ,
"" [const_101_wasm_tests] )

Definition at line 40 of file const_tests.cpp.

40 {
41 using backend_t = backend<standalone_function_t, TestType>;
42 auto code = read_wasm( std::string(wasm_directory) + "const.101.wasm");
43 backend_t bkend( code, &wa );
44
45 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
46}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [4/338]

BACKEND_TEST_CASE ( "Testing wasm <const_102_wasm>" ,
"" [const_102_wasm_tests] )

Definition at line 48 of file const_tests.cpp.

48 {
49 using backend_t = backend<standalone_function_t, TestType>;
50 auto code = read_wasm( std::string(wasm_directory) + "const.102.wasm");
51 backend_t bkend( code, &wa );
52
53 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
54}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [5/338]

BACKEND_TEST_CASE ( "Testing wasm <const_103_wasm>" ,
"" [const_103_wasm_tests] )

Definition at line 56 of file const_tests.cpp.

56 {
57 using backend_t = backend<standalone_function_t, TestType>;
58 auto code = read_wasm( std::string(wasm_directory) + "const.103.wasm");
59 backend_t bkend( code, &wa );
60
61 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
62}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [6/338]

BACKEND_TEST_CASE ( "Testing wasm <const_104_wasm>" ,
"" [const_104_wasm_tests] )

Definition at line 64 of file const_tests.cpp.

64 {
65 using backend_t = backend<standalone_function_t, TestType>;
66 auto code = read_wasm( std::string(wasm_directory) + "const.104.wasm");
67 backend_t bkend( code, &wa );
68
69 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
70}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [7/338]

BACKEND_TEST_CASE ( "Testing wasm <const_105_wasm>" ,
"" [const_105_wasm_tests] )

Definition at line 72 of file const_tests.cpp.

72 {
73 using backend_t = backend<standalone_function_t, TestType>;
74 auto code = read_wasm( std::string(wasm_directory) + "const.105.wasm");
75 backend_t bkend( code, &wa );
76
77 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
78}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [8/338]

BACKEND_TEST_CASE ( "Testing wasm <const_106_wasm>" ,
"" [const_106_wasm_tests] )

Definition at line 80 of file const_tests.cpp.

80 {
81 using backend_t = backend<standalone_function_t, TestType>;
82 auto code = read_wasm( std::string(wasm_directory) + "const.106.wasm");
83 backend_t bkend( code, &wa );
84
85 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
86}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [9/338]

BACKEND_TEST_CASE ( "Testing wasm <const_107_wasm>" ,
"" [const_107_wasm_tests] )

Definition at line 88 of file const_tests.cpp.

88 {
89 using backend_t = backend<standalone_function_t, TestType>;
90 auto code = read_wasm( std::string(wasm_directory) + "const.107.wasm");
91 backend_t bkend( code, &wa );
92
93 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
94}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [10/338]

BACKEND_TEST_CASE ( "Testing wasm <const_108_wasm>" ,
"" [const_108_wasm_tests] )

Definition at line 96 of file const_tests.cpp.

96 {
97 using backend_t = backend<standalone_function_t, TestType>;
98 auto code = read_wasm( std::string(wasm_directory) + "const.108.wasm");
99 backend_t bkend( code, &wa );
100
101 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
102}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [11/338]

BACKEND_TEST_CASE ( "Testing wasm <const_109_wasm>" ,
"" [const_109_wasm_tests] )

Definition at line 104 of file const_tests.cpp.

104 {
105 using backend_t = backend<standalone_function_t, TestType>;
106 auto code = read_wasm( std::string(wasm_directory) + "const.109.wasm");
107 backend_t bkend( code, &wa );
108
109 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
110}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [12/338]

BACKEND_TEST_CASE ( "Testing wasm <const_110_wasm>" ,
"" [const_110_wasm_tests] )

Definition at line 112 of file const_tests.cpp.

112 {
113 using backend_t = backend<standalone_function_t, TestType>;
114 auto code = read_wasm( std::string(wasm_directory) + "const.110.wasm");
115 backend_t bkend( code, &wa );
116
117 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
118}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [13/338]

BACKEND_TEST_CASE ( "Testing wasm <const_111_wasm>" ,
"" [const_111_wasm_tests] )

Definition at line 120 of file const_tests.cpp.

120 {
121 using backend_t = backend<standalone_function_t, TestType>;
122 auto code = read_wasm( std::string(wasm_directory) + "const.111.wasm");
123 backend_t bkend( code, &wa );
124
125 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
126}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [14/338]

BACKEND_TEST_CASE ( "Testing wasm <const_112_wasm>" ,
"" [const_112_wasm_tests] )

Definition at line 128 of file const_tests.cpp.

128 {
129 using backend_t = backend<standalone_function_t, TestType>;
130 auto code = read_wasm( std::string(wasm_directory) + "const.112.wasm");
131 backend_t bkend( code, &wa );
132
133 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
134}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [15/338]

BACKEND_TEST_CASE ( "Testing wasm <const_113_wasm>" ,
"" [const_113_wasm_tests] )

Definition at line 136 of file const_tests.cpp.

136 {
137 using backend_t = backend<standalone_function_t, TestType>;
138 auto code = read_wasm( std::string(wasm_directory) + "const.113.wasm");
139 backend_t bkend( code, &wa );
140
141 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
142}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [16/338]

BACKEND_TEST_CASE ( "Testing wasm <const_114_wasm>" ,
"" [const_114_wasm_tests] )

Definition at line 144 of file const_tests.cpp.

144 {
145 using backend_t = backend<standalone_function_t, TestType>;
146 auto code = read_wasm( std::string(wasm_directory) + "const.114.wasm");
147 backend_t bkend( code, &wa );
148
149 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
150}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [17/338]

BACKEND_TEST_CASE ( "Testing wasm <const_115_wasm>" ,
"" [const_115_wasm_tests] )

Definition at line 152 of file const_tests.cpp.

152 {
153 using backend_t = backend<standalone_function_t, TestType>;
154 auto code = read_wasm( std::string(wasm_directory) + "const.115.wasm");
155 backend_t bkend( code, &wa );
156
157 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
158}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [18/338]

BACKEND_TEST_CASE ( "Testing wasm <const_116_wasm>" ,
"" [const_116_wasm_tests] )

Definition at line 160 of file const_tests.cpp.

160 {
161 using backend_t = backend<standalone_function_t, TestType>;
162 auto code = read_wasm( std::string(wasm_directory) + "const.116.wasm");
163 backend_t bkend( code, &wa );
164
165 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
166}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [19/338]

BACKEND_TEST_CASE ( "Testing wasm <const_117_wasm>" ,
"" [const_117_wasm_tests] )

Definition at line 168 of file const_tests.cpp.

168 {
169 using backend_t = backend<standalone_function_t, TestType>;
170 auto code = read_wasm( std::string(wasm_directory) + "const.117.wasm");
171 backend_t bkend( code, &wa );
172
173 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
174}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [20/338]

BACKEND_TEST_CASE ( "Testing wasm <const_118_wasm>" ,
"" [const_118_wasm_tests] )

Definition at line 176 of file const_tests.cpp.

176 {
177 using backend_t = backend<standalone_function_t, TestType>;
178 auto code = read_wasm( std::string(wasm_directory) + "const.118.wasm");
179 backend_t bkend( code, &wa );
180
181 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922819));
182}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [21/338]

BACKEND_TEST_CASE ( "Testing wasm <const_119_wasm>" ,
"" [const_119_wasm_tests] )

Definition at line 184 of file const_tests.cpp.

184 {
185 using backend_t = backend<standalone_function_t, TestType>;
186 auto code = read_wasm( std::string(wasm_directory) + "const.119.wasm");
187 backend_t bkend( code, &wa );
188
189 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406467));
190}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [22/338]

BACKEND_TEST_CASE ( "Testing wasm <const_120_wasm>" ,
"" [const_120_wasm_tests] )

Definition at line 199 of file const_tests.cpp.

199 {
200 using backend_t = backend<standalone_function_t, TestType>;
201 auto code = read_wasm( std::string(wasm_directory) + "const.120.wasm");
202 backend_t bkend( code, &wa );
203
204 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922816));
205}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [23/338]

BACKEND_TEST_CASE ( "Testing wasm <const_121_wasm>" ,
"" [const_121_wasm_tests] )

Definition at line 207 of file const_tests.cpp.

207 {
208 using backend_t = backend<standalone_function_t, TestType>;
209 auto code = read_wasm( std::string(wasm_directory) + "const.121.wasm");
210 backend_t bkend( code, &wa );
211
212 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406464));
213}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [24/338]

BACKEND_TEST_CASE ( "Testing wasm <const_122_wasm>" ,
"" [const_122_wasm_tests] )

Definition at line 215 of file const_tests.cpp.

215 {
216 using backend_t = backend<standalone_function_t, TestType>;
217 auto code = read_wasm( std::string(wasm_directory) + "const.122.wasm");
218 backend_t bkend( code, &wa );
219
220 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
221}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [25/338]

BACKEND_TEST_CASE ( "Testing wasm <const_123_wasm>" ,
"" [const_123_wasm_tests] )

Definition at line 223 of file const_tests.cpp.

223 {
224 using backend_t = backend<standalone_function_t, TestType>;
225 auto code = read_wasm( std::string(wasm_directory) + "const.123.wasm");
226 backend_t bkend( code, &wa );
227
228 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
229}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [26/338]

BACKEND_TEST_CASE ( "Testing wasm <const_124_wasm>" ,
"" [const_124_wasm_tests] )

Definition at line 231 of file const_tests.cpp.

231 {
232 using backend_t = backend<standalone_function_t, TestType>;
233 auto code = read_wasm( std::string(wasm_directory) + "const.124.wasm");
234 backend_t bkend( code, &wa );
235
236 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
237}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [27/338]

BACKEND_TEST_CASE ( "Testing wasm <const_125_wasm>" ,
"" [const_125_wasm_tests] )

Definition at line 239 of file const_tests.cpp.

239 {
240 using backend_t = backend<standalone_function_t, TestType>;
241 auto code = read_wasm( std::string(wasm_directory) + "const.125.wasm");
242 backend_t bkend( code, &wa );
243
244 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
245}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [28/338]

BACKEND_TEST_CASE ( "Testing wasm <const_126_wasm>" ,
"" [const_126_wasm_tests] )

Definition at line 247 of file const_tests.cpp.

247 {
248 using backend_t = backend<standalone_function_t, TestType>;
249 auto code = read_wasm( std::string(wasm_directory) + "const.126.wasm");
250 backend_t bkend( code, &wa );
251
252 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
253}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [29/338]

BACKEND_TEST_CASE ( "Testing wasm <const_127_wasm>" ,
"" [const_127_wasm_tests] )

Definition at line 255 of file const_tests.cpp.

255 {
256 using backend_t = backend<standalone_function_t, TestType>;
257 auto code = read_wasm( std::string(wasm_directory) + "const.127.wasm");
258 backend_t bkend( code, &wa );
259
260 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
261}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [30/338]

BACKEND_TEST_CASE ( "Testing wasm <const_128_wasm>" ,
"" [const_128_wasm_tests] )

Definition at line 263 of file const_tests.cpp.

263 {
264 using backend_t = backend<standalone_function_t, TestType>;
265 auto code = read_wasm( std::string(wasm_directory) + "const.128.wasm");
266 backend_t bkend( code, &wa );
267
268 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783616));
269}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [31/338]

BACKEND_TEST_CASE ( "Testing wasm <const_129_wasm>" ,
"" [const_129_wasm_tests] )

Definition at line 271 of file const_tests.cpp.

271 {
272 using backend_t = backend<standalone_function_t, TestType>;
273 auto code = read_wasm( std::string(wasm_directory) + "const.129.wasm");
274 backend_t bkend( code, &wa );
275
276 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267264));
277}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [32/338]

BACKEND_TEST_CASE ( "Testing wasm <const_12_wasm>" ,
"" [const_12_wasm_tests] )

Definition at line 192 of file const_tests.cpp.

192 {
193 using backend_t = backend<standalone_function_t, TestType>;
194 auto code = read_wasm( std::string(wasm_directory) + "const.12.wasm");
195 backend_t bkend( code, &wa );
196
197}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [33/338]

BACKEND_TEST_CASE ( "Testing wasm <const_130_wasm>" ,
"" [const_130_wasm_tests] )

Definition at line 286 of file const_tests.cpp.

286 {
287 using backend_t = backend<standalone_function_t, TestType>;
288 auto code = read_wasm( std::string(wasm_directory) + "const.130.wasm");
289 backend_t bkend( code, &wa );
290
291 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
292}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [34/338]

BACKEND_TEST_CASE ( "Testing wasm <const_131_wasm>" ,
"" [const_131_wasm_tests] )

Definition at line 294 of file const_tests.cpp.

294 {
295 using backend_t = backend<standalone_function_t, TestType>;
296 auto code = read_wasm( std::string(wasm_directory) + "const.131.wasm");
297 backend_t bkend( code, &wa );
298
299 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
300}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [35/338]

BACKEND_TEST_CASE ( "Testing wasm <const_132_wasm>" ,
"" [const_132_wasm_tests] )

Definition at line 302 of file const_tests.cpp.

302 {
303 using backend_t = backend<standalone_function_t, TestType>;
304 auto code = read_wasm( std::string(wasm_directory) + "const.132.wasm");
305 backend_t bkend( code, &wa );
306
307 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
308}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [36/338]

BACKEND_TEST_CASE ( "Testing wasm <const_133_wasm>" ,
"" [const_133_wasm_tests] )

Definition at line 310 of file const_tests.cpp.

310 {
311 using backend_t = backend<standalone_function_t, TestType>;
312 auto code = read_wasm( std::string(wasm_directory) + "const.133.wasm");
313 backend_t bkend( code, &wa );
314
315 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
316}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [37/338]

BACKEND_TEST_CASE ( "Testing wasm <const_134_wasm>" ,
"" [const_134_wasm_tests] )

Definition at line 318 of file const_tests.cpp.

318 {
319 using backend_t = backend<standalone_function_t, TestType>;
320 auto code = read_wasm( std::string(wasm_directory) + "const.134.wasm");
321 backend_t bkend( code, &wa );
322
323 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
324}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [38/338]

BACKEND_TEST_CASE ( "Testing wasm <const_135_wasm>" ,
"" [const_135_wasm_tests] )

Definition at line 326 of file const_tests.cpp.

326 {
327 using backend_t = backend<standalone_function_t, TestType>;
328 auto code = read_wasm( std::string(wasm_directory) + "const.135.wasm");
329 backend_t bkend( code, &wa );
330
331 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
332}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [39/338]

BACKEND_TEST_CASE ( "Testing wasm <const_136_wasm>" ,
"" [const_136_wasm_tests] )

Definition at line 334 of file const_tests.cpp.

334 {
335 using backend_t = backend<standalone_function_t, TestType>;
336 auto code = read_wasm( std::string(wasm_directory) + "const.136.wasm");
337 backend_t bkend( code, &wa );
338
339 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
340}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [40/338]

BACKEND_TEST_CASE ( "Testing wasm <const_137_wasm>" ,
"" [const_137_wasm_tests] )

Definition at line 342 of file const_tests.cpp.

342 {
343 using backend_t = backend<standalone_function_t, TestType>;
344 auto code = read_wasm( std::string(wasm_directory) + "const.137.wasm");
345 backend_t bkend( code, &wa );
346
347 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
348}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [41/338]

BACKEND_TEST_CASE ( "Testing wasm <const_138_wasm>" ,
"" [const_138_wasm_tests] )

Definition at line 350 of file const_tests.cpp.

350 {
351 using backend_t = backend<standalone_function_t, TestType>;
352 auto code = read_wasm( std::string(wasm_directory) + "const.138.wasm");
353 backend_t bkend( code, &wa );
354
355 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
356}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [42/338]

BACKEND_TEST_CASE ( "Testing wasm <const_139_wasm>" ,
"" [const_139_wasm_tests] )

Definition at line 358 of file const_tests.cpp.

358 {
359 using backend_t = backend<standalone_function_t, TestType>;
360 auto code = read_wasm( std::string(wasm_directory) + "const.139.wasm");
361 backend_t bkend( code, &wa );
362
363 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
364}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [43/338]

BACKEND_TEST_CASE ( "Testing wasm <const_13_wasm>" ,
"" [const_13_wasm_tests] )

Definition at line 279 of file const_tests.cpp.

279 {
280 using backend_t = backend<standalone_function_t, TestType>;
281 auto code = read_wasm( std::string(wasm_directory) + "const.13.wasm");
282 backend_t bkend( code, &wa );
283
284}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [44/338]

BACKEND_TEST_CASE ( "Testing wasm <const_140_wasm>" ,
"" [const_140_wasm_tests] )

Definition at line 366 of file const_tests.cpp.

366 {
367 using backend_t = backend<standalone_function_t, TestType>;
368 auto code = read_wasm( std::string(wasm_directory) + "const.140.wasm");
369 backend_t bkend( code, &wa );
370
371 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
372}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [45/338]

BACKEND_TEST_CASE ( "Testing wasm <const_141_wasm>" ,
"" [const_141_wasm_tests] )

Definition at line 374 of file const_tests.cpp.

374 {
375 using backend_t = backend<standalone_function_t, TestType>;
376 auto code = read_wasm( std::string(wasm_directory) + "const.141.wasm");
377 backend_t bkend( code, &wa );
378
379 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
380}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [46/338]

BACKEND_TEST_CASE ( "Testing wasm <const_142_wasm>" ,
"" [const_142_wasm_tests] )

Definition at line 382 of file const_tests.cpp.

382 {
383 using backend_t = backend<standalone_function_t, TestType>;
384 auto code = read_wasm( std::string(wasm_directory) + "const.142.wasm");
385 backend_t bkend( code, &wa );
386
387 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
388}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [47/338]

BACKEND_TEST_CASE ( "Testing wasm <const_143_wasm>" ,
"" [const_143_wasm_tests] )

Definition at line 390 of file const_tests.cpp.

390 {
391 using backend_t = backend<standalone_function_t, TestType>;
392 auto code = read_wasm( std::string(wasm_directory) + "const.143.wasm");
393 backend_t bkend( code, &wa );
394
395 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
396}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [48/338]

BACKEND_TEST_CASE ( "Testing wasm <const_144_wasm>" ,
"" [const_144_wasm_tests] )

Definition at line 398 of file const_tests.cpp.

398 {
399 using backend_t = backend<standalone_function_t, TestType>;
400 auto code = read_wasm( std::string(wasm_directory) + "const.144.wasm");
401 backend_t bkend( code, &wa );
402
403 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
404}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [49/338]

BACKEND_TEST_CASE ( "Testing wasm <const_145_wasm>" ,
"" [const_145_wasm_tests] )

Definition at line 406 of file const_tests.cpp.

406 {
407 using backend_t = backend<standalone_function_t, TestType>;
408 auto code = read_wasm( std::string(wasm_directory) + "const.145.wasm");
409 backend_t bkend( code, &wa );
410
411 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
412}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [50/338]

BACKEND_TEST_CASE ( "Testing wasm <const_146_wasm>" ,
"" [const_146_wasm_tests] )

Definition at line 414 of file const_tests.cpp.

414 {
415 using backend_t = backend<standalone_function_t, TestType>;
416 auto code = read_wasm( std::string(wasm_directory) + "const.146.wasm");
417 backend_t bkend( code, &wa );
418
419 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
420}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [51/338]

BACKEND_TEST_CASE ( "Testing wasm <const_147_wasm>" ,
"" [const_147_wasm_tests] )

Definition at line 422 of file const_tests.cpp.

422 {
423 using backend_t = backend<standalone_function_t, TestType>;
424 auto code = read_wasm( std::string(wasm_directory) + "const.147.wasm");
425 backend_t bkend( code, &wa );
426
427 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
428}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [52/338]

BACKEND_TEST_CASE ( "Testing wasm <const_148_wasm>" ,
"" [const_148_wasm_tests] )

Definition at line 430 of file const_tests.cpp.

430 {
431 using backend_t = backend<standalone_function_t, TestType>;
432 auto code = read_wasm( std::string(wasm_directory) + "const.148.wasm");
433 backend_t bkend( code, &wa );
434
435 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
436}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [53/338]

BACKEND_TEST_CASE ( "Testing wasm <const_149_wasm>" ,
"" [const_149_wasm_tests] )

Definition at line 438 of file const_tests.cpp.

438 {
439 using backend_t = backend<standalone_function_t, TestType>;
440 auto code = read_wasm( std::string(wasm_directory) + "const.149.wasm");
441 backend_t bkend( code, &wa );
442
443 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
444}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [54/338]

BACKEND_TEST_CASE ( "Testing wasm <const_150_wasm>" ,
"" [const_150_wasm_tests] )

Definition at line 446 of file const_tests.cpp.

446 {
447 using backend_t = backend<standalone_function_t, TestType>;
448 auto code = read_wasm( std::string(wasm_directory) + "const.150.wasm");
449 backend_t bkend( code, &wa );
450
451 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
452}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [55/338]

BACKEND_TEST_CASE ( "Testing wasm <const_151_wasm>" ,
"" [const_151_wasm_tests] )

Definition at line 454 of file const_tests.cpp.

454 {
455 using backend_t = backend<standalone_function_t, TestType>;
456 auto code = read_wasm( std::string(wasm_directory) + "const.151.wasm");
457 backend_t bkend( code, &wa );
458
459 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
460}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [56/338]

BACKEND_TEST_CASE ( "Testing wasm <const_152_wasm>" ,
"" [const_152_wasm_tests] )

Definition at line 462 of file const_tests.cpp.

462 {
463 using backend_t = backend<standalone_function_t, TestType>;
464 auto code = read_wasm( std::string(wasm_directory) + "const.152.wasm");
465 backend_t bkend( code, &wa );
466
467 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
468}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [57/338]

BACKEND_TEST_CASE ( "Testing wasm <const_153_wasm>" ,
"" [const_153_wasm_tests] )

Definition at line 470 of file const_tests.cpp.

470 {
471 using backend_t = backend<standalone_function_t, TestType>;
472 auto code = read_wasm( std::string(wasm_directory) + "const.153.wasm");
473 backend_t bkend( code, &wa );
474
475 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
476}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [58/338]

BACKEND_TEST_CASE ( "Testing wasm <const_154_wasm>" ,
"" [const_154_wasm_tests] )

Definition at line 478 of file const_tests.cpp.

478 {
479 using backend_t = backend<standalone_function_t, TestType>;
480 auto code = read_wasm( std::string(wasm_directory) + "const.154.wasm");
481 backend_t bkend( code, &wa );
482
483 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783619));
484}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [59/338]

BACKEND_TEST_CASE ( "Testing wasm <const_155_wasm>" ,
"" [const_155_wasm_tests] )

Definition at line 486 of file const_tests.cpp.

486 {
487 using backend_t = backend<standalone_function_t, TestType>;
488 auto code = read_wasm( std::string(wasm_directory) + "const.155.wasm");
489 backend_t bkend( code, &wa );
490
491 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267267));
492}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [60/338]

BACKEND_TEST_CASE ( "Testing wasm <const_156_wasm>" ,
"" [const_156_wasm_tests] )

Definition at line 494 of file const_tests.cpp.

494 {
495 using backend_t = backend<standalone_function_t, TestType>;
496 auto code = read_wasm( std::string(wasm_directory) + "const.156.wasm");
497 backend_t bkend( code, &wa );
498
499 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783616));
500}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [61/338]

BACKEND_TEST_CASE ( "Testing wasm <const_157_wasm>" ,
"" [const_157_wasm_tests] )

Definition at line 502 of file const_tests.cpp.

502 {
503 using backend_t = backend<standalone_function_t, TestType>;
504 auto code = read_wasm( std::string(wasm_directory) + "const.157.wasm");
505 backend_t bkend( code, &wa );
506
507 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267264));
508}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [62/338]

BACKEND_TEST_CASE ( "Testing wasm <const_158_wasm>" ,
"" [const_158_wasm_tests] )

Definition at line 510 of file const_tests.cpp.

510 {
511 using backend_t = backend<standalone_function_t, TestType>;
512 auto code = read_wasm( std::string(wasm_directory) + "const.158.wasm");
513 backend_t bkend( code, &wa );
514
515 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
516}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [63/338]

BACKEND_TEST_CASE ( "Testing wasm <const_159_wasm>" ,
"" [const_159_wasm_tests] )

Definition at line 518 of file const_tests.cpp.

518 {
519 using backend_t = backend<standalone_function_t, TestType>;
520 auto code = read_wasm( std::string(wasm_directory) + "const.159.wasm");
521 backend_t bkend( code, &wa );
522
523 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
524}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [64/338]

BACKEND_TEST_CASE ( "Testing wasm <const_160_wasm>" ,
"" [const_160_wasm_tests] )

Definition at line 533 of file const_tests.cpp.

533 {
534 using backend_t = backend<standalone_function_t, TestType>;
535 auto code = read_wasm( std::string(wasm_directory) + "const.160.wasm");
536 backend_t bkend( code, &wa );
537
538 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
539}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [65/338]

BACKEND_TEST_CASE ( "Testing wasm <const_161_wasm>" ,
"" [const_161_wasm_tests] )

Definition at line 541 of file const_tests.cpp.

541 {
542 using backend_t = backend<standalone_function_t, TestType>;
543 auto code = read_wasm( std::string(wasm_directory) + "const.161.wasm");
544 backend_t bkend( code, &wa );
545
546 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
547}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [66/338]

BACKEND_TEST_CASE ( "Testing wasm <const_162_wasm>" ,
"" [const_162_wasm_tests] )

Definition at line 549 of file const_tests.cpp.

549 {
550 using backend_t = backend<standalone_function_t, TestType>;
551 auto code = read_wasm( std::string(wasm_directory) + "const.162.wasm");
552 backend_t bkend( code, &wa );
553
554 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
555}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [67/338]

BACKEND_TEST_CASE ( "Testing wasm <const_163_wasm>" ,
"" [const_163_wasm_tests] )

Definition at line 557 of file const_tests.cpp.

557 {
558 using backend_t = backend<standalone_function_t, TestType>;
559 auto code = read_wasm( std::string(wasm_directory) + "const.163.wasm");
560 backend_t bkend( code, &wa );
561
562 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
563}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [68/338]

BACKEND_TEST_CASE ( "Testing wasm <const_164_wasm>" ,
"" [const_164_wasm_tests] )

Definition at line 565 of file const_tests.cpp.

565 {
566 using backend_t = backend<standalone_function_t, TestType>;
567 auto code = read_wasm( std::string(wasm_directory) + "const.164.wasm");
568 backend_t bkend( code, &wa );
569
570 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
571}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [69/338]

BACKEND_TEST_CASE ( "Testing wasm <const_165_wasm>" ,
"" [const_165_wasm_tests] )

Definition at line 573 of file const_tests.cpp.

573 {
574 using backend_t = backend<standalone_function_t, TestType>;
575 auto code = read_wasm( std::string(wasm_directory) + "const.165.wasm");
576 backend_t bkend( code, &wa );
577
578 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
579}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [70/338]

BACKEND_TEST_CASE ( "Testing wasm <const_166_wasm>" ,
"" [const_166_wasm_tests] )

Definition at line 581 of file const_tests.cpp.

581 {
582 using backend_t = backend<standalone_function_t, TestType>;
583 auto code = read_wasm( std::string(wasm_directory) + "const.166.wasm");
584 backend_t bkend( code, &wa );
585
586 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
587}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [71/338]

BACKEND_TEST_CASE ( "Testing wasm <const_167_wasm>" ,
"" [const_167_wasm_tests] )

Definition at line 589 of file const_tests.cpp.

589 {
590 using backend_t = backend<standalone_function_t, TestType>;
591 auto code = read_wasm( std::string(wasm_directory) + "const.167.wasm");
592 backend_t bkend( code, &wa );
593
594 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
595}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [72/338]

BACKEND_TEST_CASE ( "Testing wasm <const_168_wasm>" ,
"" [const_168_wasm_tests] )

Definition at line 597 of file const_tests.cpp.

597 {
598 using backend_t = backend<standalone_function_t, TestType>;
599 auto code = read_wasm( std::string(wasm_directory) + "const.168.wasm");
600 backend_t bkend( code, &wa );
601
602 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
603}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [73/338]

BACKEND_TEST_CASE ( "Testing wasm <const_169_wasm>" ,
"" [const_169_wasm_tests] )

Definition at line 605 of file const_tests.cpp.

605 {
606 using backend_t = backend<standalone_function_t, TestType>;
607 auto code = read_wasm( std::string(wasm_directory) + "const.169.wasm");
608 backend_t bkend( code, &wa );
609
610 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
611}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [74/338]

BACKEND_TEST_CASE ( "Testing wasm <const_16_wasm>" ,
"" [const_16_wasm_tests] )

Definition at line 526 of file const_tests.cpp.

526 {
527 using backend_t = backend<standalone_function_t, TestType>;
528 auto code = read_wasm( std::string(wasm_directory) + "const.16.wasm");
529 backend_t bkend( code, &wa );
530
531}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [75/338]

BACKEND_TEST_CASE ( "Testing wasm <const_170_wasm>" ,
"" [const_170_wasm_tests] )

Definition at line 620 of file const_tests.cpp.

620 {
621 using backend_t = backend<standalone_function_t, TestType>;
622 auto code = read_wasm( std::string(wasm_directory) + "const.170.wasm");
623 backend_t bkend( code, &wa );
624
625 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783616));
626}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [76/338]

BACKEND_TEST_CASE ( "Testing wasm <const_171_wasm>" ,
"" [const_171_wasm_tests] )

Definition at line 628 of file const_tests.cpp.

628 {
629 using backend_t = backend<standalone_function_t, TestType>;
630 auto code = read_wasm( std::string(wasm_directory) + "const.171.wasm");
631 backend_t bkend( code, &wa );
632
633 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267264));
634}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [77/338]

BACKEND_TEST_CASE ( "Testing wasm <const_172_wasm>" ,
"" [const_172_wasm_tests] )

Definition at line 636 of file const_tests.cpp.

636 {
637 using backend_t = backend<standalone_function_t, TestType>;
638 auto code = read_wasm( std::string(wasm_directory) + "const.172.wasm");
639 backend_t bkend( code, &wa );
640
641 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
642}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [78/338]

BACKEND_TEST_CASE ( "Testing wasm <const_173_wasm>" ,
"" [const_173_wasm_tests] )

Definition at line 644 of file const_tests.cpp.

644 {
645 using backend_t = backend<standalone_function_t, TestType>;
646 auto code = read_wasm( std::string(wasm_directory) + "const.173.wasm");
647 backend_t bkend( code, &wa );
648
649 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
650}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [79/338]

BACKEND_TEST_CASE ( "Testing wasm <const_174_wasm>" ,
"" [const_174_wasm_tests] )

Definition at line 652 of file const_tests.cpp.

652 {
653 using backend_t = backend<standalone_function_t, TestType>;
654 auto code = read_wasm( std::string(wasm_directory) + "const.174.wasm");
655 backend_t bkend( code, &wa );
656
657 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783617));
658}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [80/338]

BACKEND_TEST_CASE ( "Testing wasm <const_175_wasm>" ,
"" [const_175_wasm_tests] )

Definition at line 660 of file const_tests.cpp.

660 {
661 using backend_t = backend<standalone_function_t, TestType>;
662 auto code = read_wasm( std::string(wasm_directory) + "const.175.wasm");
663 backend_t bkend( code, &wa );
664
665 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267265));
666}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [81/338]

BACKEND_TEST_CASE ( "Testing wasm <const_176_wasm>" ,
"" [const_176_wasm_tests] )

Definition at line 668 of file const_tests.cpp.

668 {
669 using backend_t = backend<standalone_function_t, TestType>;
670 auto code = read_wasm( std::string(wasm_directory) + "const.176.wasm");
671 backend_t bkend( code, &wa );
672
673 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1484783618));
674}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [82/338]

BACKEND_TEST_CASE ( "Testing wasm <const_177_wasm>" ,
"" [const_177_wasm_tests] )

Definition at line 676 of file const_tests.cpp.

676 {
677 using backend_t = backend<standalone_function_t, TestType>;
678 auto code = read_wasm( std::string(wasm_directory) + "const.177.wasm");
679 backend_t bkend( code, &wa );
680
681 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3632267266));
682}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [83/338]

BACKEND_TEST_CASE ( "Testing wasm <const_178_wasm>" ,
"" [const_178_wasm_tests] )

Definition at line 684 of file const_tests.cpp.

684 {
685 using backend_t = backend<standalone_function_t, TestType>;
686 auto code = read_wasm( std::string(wasm_directory) + "const.178.wasm");
687 backend_t bkend( code, &wa );
688
689 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(0));
690}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [84/338]

BACKEND_TEST_CASE ( "Testing wasm <const_179_wasm>" ,
"" [const_179_wasm_tests] )

Definition at line 692 of file const_tests.cpp.

692 {
693 using backend_t = backend<standalone_function_t, TestType>;
694 auto code = read_wasm( std::string(wasm_directory) + "const.179.wasm");
695 backend_t bkend( code, &wa );
696
697 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483648));
698}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [85/338]

BACKEND_TEST_CASE ( "Testing wasm <const_17_wasm>" ,
"" [const_17_wasm_tests] )

Definition at line 613 of file const_tests.cpp.

613 {
614 using backend_t = backend<standalone_function_t, TestType>;
615 auto code = read_wasm( std::string(wasm_directory) + "const.17.wasm");
616 backend_t bkend( code, &wa );
617
618}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [86/338]

BACKEND_TEST_CASE ( "Testing wasm <const_180_wasm>" ,
"" [const_180_wasm_tests] )

Definition at line 707 of file const_tests.cpp.

707 {
708 using backend_t = backend<standalone_function_t, TestType>;
709 auto code = read_wasm( std::string(wasm_directory) + "const.180.wasm");
710 backend_t bkend( code, &wa );
711
712 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1));
713}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [87/338]

BACKEND_TEST_CASE ( "Testing wasm <const_181_wasm>" ,
"" [const_181_wasm_tests] )

Definition at line 715 of file const_tests.cpp.

715 {
716 using backend_t = backend<standalone_function_t, TestType>;
717 auto code = read_wasm( std::string(wasm_directory) + "const.181.wasm");
718 backend_t bkend( code, &wa );
719
720 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483649));
721}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [88/338]

BACKEND_TEST_CASE ( "Testing wasm <const_182_wasm>" ,
"" [const_182_wasm_tests] )

Definition at line 723 of file const_tests.cpp.

723 {
724 using backend_t = backend<standalone_function_t, TestType>;
725 auto code = read_wasm( std::string(wasm_directory) + "const.182.wasm");
726 backend_t bkend( code, &wa );
727
728 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1));
729}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [89/338]

BACKEND_TEST_CASE ( "Testing wasm <const_183_wasm>" ,
"" [const_183_wasm_tests] )

Definition at line 731 of file const_tests.cpp.

731 {
732 using backend_t = backend<standalone_function_t, TestType>;
733 auto code = read_wasm( std::string(wasm_directory) + "const.183.wasm");
734 backend_t bkend( code, &wa );
735
736 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483649));
737}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [90/338]

BACKEND_TEST_CASE ( "Testing wasm <const_184_wasm>" ,
"" [const_184_wasm_tests] )

Definition at line 739 of file const_tests.cpp.

739 {
740 using backend_t = backend<standalone_function_t, TestType>;
741 auto code = read_wasm( std::string(wasm_directory) + "const.184.wasm");
742 backend_t bkend( code, &wa );
743
744 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1));
745}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [91/338]

BACKEND_TEST_CASE ( "Testing wasm <const_185_wasm>" ,
"" [const_185_wasm_tests] )

Definition at line 747 of file const_tests.cpp.

747 {
748 using backend_t = backend<standalone_function_t, TestType>;
749 auto code = read_wasm( std::string(wasm_directory) + "const.185.wasm");
750 backend_t bkend( code, &wa );
751
752 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483649));
753}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [92/338]

BACKEND_TEST_CASE ( "Testing wasm <const_186_wasm>" ,
"" [const_186_wasm_tests] )

Definition at line 755 of file const_tests.cpp.

755 {
756 using backend_t = backend<standalone_function_t, TestType>;
757 auto code = read_wasm( std::string(wasm_directory) + "const.186.wasm");
758 backend_t bkend( code, &wa );
759
760 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1));
761}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [93/338]

BACKEND_TEST_CASE ( "Testing wasm <const_187_wasm>" ,
"" [const_187_wasm_tests] )

Definition at line 763 of file const_tests.cpp.

763 {
764 using backend_t = backend<standalone_function_t, TestType>;
765 auto code = read_wasm( std::string(wasm_directory) + "const.187.wasm");
766 backend_t bkend( code, &wa );
767
768 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483649));
769}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [94/338]

BACKEND_TEST_CASE ( "Testing wasm <const_188_wasm>" ,
"" [const_188_wasm_tests] )

Definition at line 771 of file const_tests.cpp.

771 {
772 using backend_t = backend<standalone_function_t, TestType>;
773 auto code = read_wasm( std::string(wasm_directory) + "const.188.wasm");
774 backend_t bkend( code, &wa );
775
776 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(1));
777}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [95/338]

BACKEND_TEST_CASE ( "Testing wasm <const_189_wasm>" ,
"" [const_189_wasm_tests] )

Definition at line 779 of file const_tests.cpp.

779 {
780 using backend_t = backend<standalone_function_t, TestType>;
781 auto code = read_wasm( std::string(wasm_directory) + "const.189.wasm");
782 backend_t bkend( code, &wa );
783
784 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483649));
785}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [96/338]

BACKEND_TEST_CASE ( "Testing wasm <const_18_wasm>" ,
"" [const_18_wasm_tests] )

Definition at line 700 of file const_tests.cpp.

700 {
701 using backend_t = backend<standalone_function_t, TestType>;
702 auto code = read_wasm( std::string(wasm_directory) + "const.18.wasm");
703 backend_t bkend( code, &wa );
704
705}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [97/338]

BACKEND_TEST_CASE ( "Testing wasm <const_190_wasm>" ,
"" [const_190_wasm_tests] )

Definition at line 794 of file const_tests.cpp.

794 {
795 using backend_t = backend<standalone_function_t, TestType>;
796 auto code = read_wasm( std::string(wasm_directory) + "const.190.wasm");
797 backend_t bkend( code, &wa );
798
799 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
800}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [98/338]

BACKEND_TEST_CASE ( "Testing wasm <const_191_wasm>" ,
"" [const_191_wasm_tests] )

Definition at line 802 of file const_tests.cpp.

802 {
803 using backend_t = backend<standalone_function_t, TestType>;
804 auto code = read_wasm( std::string(wasm_directory) + "const.191.wasm");
805 backend_t bkend( code, &wa );
806
807 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
808}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [99/338]

BACKEND_TEST_CASE ( "Testing wasm <const_192_wasm>" ,
"" [const_192_wasm_tests] )

Definition at line 810 of file const_tests.cpp.

810 {
811 using backend_t = backend<standalone_function_t, TestType>;
812 auto code = read_wasm( std::string(wasm_directory) + "const.192.wasm");
813 backend_t bkend( code, &wa );
814
815 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
816}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [100/338]

BACKEND_TEST_CASE ( "Testing wasm <const_193_wasm>" ,
"" [const_193_wasm_tests] )

Definition at line 818 of file const_tests.cpp.

818 {
819 using backend_t = backend<standalone_function_t, TestType>;
820 auto code = read_wasm( std::string(wasm_directory) + "const.193.wasm");
821 backend_t bkend( code, &wa );
822
823 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
824}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [101/338]

BACKEND_TEST_CASE ( "Testing wasm <const_194_wasm>" ,
"" [const_194_wasm_tests] )

Definition at line 826 of file const_tests.cpp.

826 {
827 using backend_t = backend<standalone_function_t, TestType>;
828 auto code = read_wasm( std::string(wasm_directory) + "const.194.wasm");
829 backend_t bkend( code, &wa );
830
831 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
832}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [102/338]

BACKEND_TEST_CASE ( "Testing wasm <const_195_wasm>" ,
"" [const_195_wasm_tests] )

Definition at line 834 of file const_tests.cpp.

834 {
835 using backend_t = backend<standalone_function_t, TestType>;
836 auto code = read_wasm( std::string(wasm_directory) + "const.195.wasm");
837 backend_t bkend( code, &wa );
838
839 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
840}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [103/338]

BACKEND_TEST_CASE ( "Testing wasm <const_196_wasm>" ,
"" [const_196_wasm_tests] )

Definition at line 842 of file const_tests.cpp.

842 {
843 using backend_t = backend<standalone_function_t, TestType>;
844 auto code = read_wasm( std::string(wasm_directory) + "const.196.wasm");
845 backend_t bkend( code, &wa );
846
847 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
848}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [104/338]

BACKEND_TEST_CASE ( "Testing wasm <const_197_wasm>" ,
"" [const_197_wasm_tests] )

Definition at line 850 of file const_tests.cpp.

850 {
851 using backend_t = backend<standalone_function_t, TestType>;
852 auto code = read_wasm( std::string(wasm_directory) + "const.197.wasm");
853 backend_t bkend( code, &wa );
854
855 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
856}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [105/338]

BACKEND_TEST_CASE ( "Testing wasm <const_198_wasm>" ,
"" [const_198_wasm_tests] )

Definition at line 858 of file const_tests.cpp.

858 {
859 using backend_t = backend<standalone_function_t, TestType>;
860 auto code = read_wasm( std::string(wasm_directory) + "const.198.wasm");
861 backend_t bkend( code, &wa );
862
863 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
864}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [106/338]

BACKEND_TEST_CASE ( "Testing wasm <const_199_wasm>" ,
"" [const_199_wasm_tests] )

Definition at line 866 of file const_tests.cpp.

866 {
867 using backend_t = backend<standalone_function_t, TestType>;
868 auto code = read_wasm( std::string(wasm_directory) + "const.199.wasm");
869 backend_t bkend( code, &wa );
870
871 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
872}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [107/338]

BACKEND_TEST_CASE ( "Testing wasm <const_19_wasm>" ,
"" [const_19_wasm_tests] )

Definition at line 787 of file const_tests.cpp.

787 {
788 using backend_t = backend<standalone_function_t, TestType>;
789 auto code = read_wasm( std::string(wasm_directory) + "const.19.wasm");
790 backend_t bkend( code, &wa );
791
792}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [108/338]

BACKEND_TEST_CASE ( "Testing wasm <const_1_wasm>" ,
"" [const_1_wasm_tests] )

Definition at line 25 of file const_tests.cpp.

25 {
26 using backend_t = backend<standalone_function_t, TestType>;
27 auto code = read_wasm( std::string(wasm_directory) + "const.1.wasm");
28 backend_t bkend( code, &wa );
29
30}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [109/338]

BACKEND_TEST_CASE ( "Testing wasm <const_200_wasm>" ,
"" [const_200_wasm_tests] )

Definition at line 881 of file const_tests.cpp.

881 {
882 using backend_t = backend<standalone_function_t, TestType>;
883 auto code = read_wasm( std::string(wasm_directory) + "const.200.wasm");
884 backend_t bkend( code, &wa );
885
886 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
887}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [110/338]

BACKEND_TEST_CASE ( "Testing wasm <const_201_wasm>" ,
"" [const_201_wasm_tests] )

Definition at line 889 of file const_tests.cpp.

889 {
890 using backend_t = backend<standalone_function_t, TestType>;
891 auto code = read_wasm( std::string(wasm_directory) + "const.201.wasm");
892 backend_t bkend( code, &wa );
893
894 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
895}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [111/338]

BACKEND_TEST_CASE ( "Testing wasm <const_202_wasm>" ,
"" [const_202_wasm_tests] )

Definition at line 897 of file const_tests.cpp.

897 {
898 using backend_t = backend<standalone_function_t, TestType>;
899 auto code = read_wasm( std::string(wasm_directory) + "const.202.wasm");
900 backend_t bkend( code, &wa );
901
902 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2));
903}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [112/338]

BACKEND_TEST_CASE ( "Testing wasm <const_203_wasm>" ,
"" [const_203_wasm_tests] )

Definition at line 905 of file const_tests.cpp.

905 {
906 using backend_t = backend<standalone_function_t, TestType>;
907 auto code = read_wasm( std::string(wasm_directory) + "const.203.wasm");
908 backend_t bkend( code, &wa );
909
910 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483650));
911}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [113/338]

BACKEND_TEST_CASE ( "Testing wasm <const_204_wasm>" ,
"" [const_204_wasm_tests] )

Definition at line 913 of file const_tests.cpp.

913 {
914 using backend_t = backend<standalone_function_t, TestType>;
915 auto code = read_wasm( std::string(wasm_directory) + "const.204.wasm");
916 backend_t bkend( code, &wa );
917
918 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(3));
919}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [114/338]

BACKEND_TEST_CASE ( "Testing wasm <const_205_wasm>" ,
"" [const_205_wasm_tests] )

Definition at line 921 of file const_tests.cpp.

921 {
922 using backend_t = backend<standalone_function_t, TestType>;
923 auto code = read_wasm( std::string(wasm_directory) + "const.205.wasm");
924 backend_t bkend( code, &wa );
925
926 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2147483651));
927}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [115/338]

BACKEND_TEST_CASE ( "Testing wasm <const_206_wasm>" ,
"" [const_206_wasm_tests] )

Definition at line 929 of file const_tests.cpp.

929 {
930 using backend_t = backend<standalone_function_t, TestType>;
931 auto code = read_wasm( std::string(wasm_directory) + "const.206.wasm");
932 backend_t bkend( code, &wa );
933
934 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2139095039));
935}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [116/338]

BACKEND_TEST_CASE ( "Testing wasm <const_207_wasm>" ,
"" [const_207_wasm_tests] )

Definition at line 937 of file const_tests.cpp.

937 {
938 using backend_t = backend<standalone_function_t, TestType>;
939 auto code = read_wasm( std::string(wasm_directory) + "const.207.wasm");
940 backend_t bkend( code, &wa );
941
942 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(4286578687));
943}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [117/338]

BACKEND_TEST_CASE ( "Testing wasm <const_208_wasm>" ,
"" [const_208_wasm_tests] )

Definition at line 945 of file const_tests.cpp.

945 {
946 using backend_t = backend<standalone_function_t, TestType>;
947 auto code = read_wasm( std::string(wasm_directory) + "const.208.wasm");
948 backend_t bkend( code, &wa );
949
950 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2139095039));
951}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [118/338]

BACKEND_TEST_CASE ( "Testing wasm <const_209_wasm>" ,
"" [const_209_wasm_tests] )

Definition at line 953 of file const_tests.cpp.

953 {
954 using backend_t = backend<standalone_function_t, TestType>;
955 auto code = read_wasm( std::string(wasm_directory) + "const.209.wasm");
956 backend_t bkend( code, &wa );
957
958 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(4286578687));
959}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [119/338]

BACKEND_TEST_CASE ( "Testing wasm <const_20_wasm>" ,
"" [const_20_wasm_tests] )

Definition at line 874 of file const_tests.cpp.

874 {
875 using backend_t = backend<standalone_function_t, TestType>;
876 auto code = read_wasm( std::string(wasm_directory) + "const.20.wasm");
877 backend_t bkend( code, &wa );
878
879}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [120/338]

BACKEND_TEST_CASE ( "Testing wasm <const_210_wasm>" ,
"" [const_210_wasm_tests] )

Definition at line 968 of file const_tests.cpp.

968 {
969 using backend_t = backend<standalone_function_t, TestType>;
970 auto code = read_wasm( std::string(wasm_directory) + "const.210.wasm");
971 backend_t bkend( code, &wa );
972
973 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2139095039));
974}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [121/338]

BACKEND_TEST_CASE ( "Testing wasm <const_211_wasm>" ,
"" [const_211_wasm_tests] )

Definition at line 976 of file const_tests.cpp.

976 {
977 using backend_t = backend<standalone_function_t, TestType>;
978 auto code = read_wasm( std::string(wasm_directory) + "const.211.wasm");
979 backend_t bkend( code, &wa );
980
981 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(4286578687));
982}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [122/338]

BACKEND_TEST_CASE ( "Testing wasm <const_212_wasm>" ,
"" [const_212_wasm_tests] )

Definition at line 984 of file const_tests.cpp.

984 {
985 using backend_t = backend<standalone_function_t, TestType>;
986 auto code = read_wasm( std::string(wasm_directory) + "const.212.wasm");
987 backend_t bkend( code, &wa );
988
989 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719808));
990}
UINT64_C
#define UINT64_C(val)
Definition stdint.h:284
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [123/338]

BACKEND_TEST_CASE ( "Testing wasm <const_213_wasm>" ,
"" [const_213_wasm_tests] )

Definition at line 992 of file const_tests.cpp.

992 {
993 using backend_t = backend<standalone_function_t, TestType>;
994 auto code = read_wasm( std::string(wasm_directory) + "const.213.wasm");
995 backend_t bkend( code, &wa );
996
997 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495616));
998}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [124/338]

BACKEND_TEST_CASE ( "Testing wasm <const_214_wasm>" ,
"" [const_214_wasm_tests] )

Definition at line 1000 of file const_tests.cpp.

1000 {
1001 using backend_t = backend<standalone_function_t, TestType>;
1002 auto code = read_wasm( std::string(wasm_directory) + "const.214.wasm");
1003 backend_t bkend( code, &wa );
1004
1005 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1006}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [125/338]

BACKEND_TEST_CASE ( "Testing wasm <const_215_wasm>" ,
"" [const_215_wasm_tests] )

Definition at line 1008 of file const_tests.cpp.

1008 {
1009 using backend_t = backend<standalone_function_t, TestType>;
1010 auto code = read_wasm( std::string(wasm_directory) + "const.215.wasm");
1011 backend_t bkend( code, &wa );
1012
1013 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1014}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [126/338]

BACKEND_TEST_CASE ( "Testing wasm <const_216_wasm>" ,
"" [const_216_wasm_tests] )

Definition at line 1016 of file const_tests.cpp.

1016 {
1017 using backend_t = backend<standalone_function_t, TestType>;
1018 auto code = read_wasm( std::string(wasm_directory) + "const.216.wasm");
1019 backend_t bkend( code, &wa );
1020
1021 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1022}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [127/338]

BACKEND_TEST_CASE ( "Testing wasm <const_217_wasm>" ,
"" [const_217_wasm_tests] )

Definition at line 1024 of file const_tests.cpp.

1024 {
1025 using backend_t = backend<standalone_function_t, TestType>;
1026 auto code = read_wasm( std::string(wasm_directory) + "const.217.wasm");
1027 backend_t bkend( code, &wa );
1028
1029 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1030}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [128/338]

BACKEND_TEST_CASE ( "Testing wasm <const_218_wasm>" ,
"" [const_218_wasm_tests] )

Definition at line 1032 of file const_tests.cpp.

1032 {
1033 using backend_t = backend<standalone_function_t, TestType>;
1034 auto code = read_wasm( std::string(wasm_directory) + "const.218.wasm");
1035 backend_t bkend( code, &wa );
1036
1037 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1038}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [129/338]

BACKEND_TEST_CASE ( "Testing wasm <const_219_wasm>" ,
"" [const_219_wasm_tests] )

Definition at line 1040 of file const_tests.cpp.

1040 {
1041 using backend_t = backend<standalone_function_t, TestType>;
1042 auto code = read_wasm( std::string(wasm_directory) + "const.219.wasm");
1043 backend_t bkend( code, &wa );
1044
1045 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1046}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [130/338]

BACKEND_TEST_CASE ( "Testing wasm <const_21_wasm>" ,
"" [const_21_wasm_tests] )

Definition at line 961 of file const_tests.cpp.

961 {
962 using backend_t = backend<standalone_function_t, TestType>;
963 auto code = read_wasm( std::string(wasm_directory) + "const.21.wasm");
964 backend_t bkend( code, &wa );
965
966}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [131/338]

BACKEND_TEST_CASE ( "Testing wasm <const_220_wasm>" ,
"" [const_220_wasm_tests] )

Definition at line 1055 of file const_tests.cpp.

1055 {
1056 using backend_t = backend<standalone_function_t, TestType>;
1057 auto code = read_wasm( std::string(wasm_directory) + "const.220.wasm");
1058 backend_t bkend( code, &wa );
1059
1060 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1061}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [132/338]

BACKEND_TEST_CASE ( "Testing wasm <const_221_wasm>" ,
"" [const_221_wasm_tests] )

Definition at line 1063 of file const_tests.cpp.

1063 {
1064 using backend_t = backend<standalone_function_t, TestType>;
1065 auto code = read_wasm( std::string(wasm_directory) + "const.221.wasm");
1066 backend_t bkend( code, &wa );
1067
1068 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1069}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [133/338]

BACKEND_TEST_CASE ( "Testing wasm <const_222_wasm>" ,
"" [const_222_wasm_tests] )

Definition at line 1071 of file const_tests.cpp.

1071 {
1072 using backend_t = backend<standalone_function_t, TestType>;
1073 auto code = read_wasm( std::string(wasm_directory) + "const.222.wasm");
1074 backend_t bkend( code, &wa );
1075
1076 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1077}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [134/338]

BACKEND_TEST_CASE ( "Testing wasm <const_223_wasm>" ,
"" [const_223_wasm_tests] )

Definition at line 1079 of file const_tests.cpp.

1079 {
1080 using backend_t = backend<standalone_function_t, TestType>;
1081 auto code = read_wasm( std::string(wasm_directory) + "const.223.wasm");
1082 backend_t bkend( code, &wa );
1083
1084 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1085}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [135/338]

BACKEND_TEST_CASE ( "Testing wasm <const_224_wasm>" ,
"" [const_224_wasm_tests] )

Definition at line 1087 of file const_tests.cpp.

1087 {
1088 using backend_t = backend<standalone_function_t, TestType>;
1089 auto code = read_wasm( std::string(wasm_directory) + "const.224.wasm");
1090 backend_t bkend( code, &wa );
1091
1092 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1093}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [136/338]

BACKEND_TEST_CASE ( "Testing wasm <const_225_wasm>" ,
"" [const_225_wasm_tests] )

Definition at line 1095 of file const_tests.cpp.

1095 {
1096 using backend_t = backend<standalone_function_t, TestType>;
1097 auto code = read_wasm( std::string(wasm_directory) + "const.225.wasm");
1098 backend_t bkend( code, &wa );
1099
1100 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1101}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [137/338]

BACKEND_TEST_CASE ( "Testing wasm <const_226_wasm>" ,
"" [const_226_wasm_tests] )

Definition at line 1103 of file const_tests.cpp.

1103 {
1104 using backend_t = backend<standalone_function_t, TestType>;
1105 auto code = read_wasm( std::string(wasm_directory) + "const.226.wasm");
1106 backend_t bkend( code, &wa );
1107
1108 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1109}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [138/338]

BACKEND_TEST_CASE ( "Testing wasm <const_227_wasm>" ,
"" [const_227_wasm_tests] )

Definition at line 1111 of file const_tests.cpp.

1111 {
1112 using backend_t = backend<standalone_function_t, TestType>;
1113 auto code = read_wasm( std::string(wasm_directory) + "const.227.wasm");
1114 backend_t bkend( code, &wa );
1115
1116 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1117}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [139/338]

BACKEND_TEST_CASE ( "Testing wasm <const_228_wasm>" ,
"" [const_228_wasm_tests] )

Definition at line 1119 of file const_tests.cpp.

1119 {
1120 using backend_t = backend<standalone_function_t, TestType>;
1121 auto code = read_wasm( std::string(wasm_directory) + "const.228.wasm");
1122 backend_t bkend( code, &wa );
1123
1124 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1125}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [140/338]

BACKEND_TEST_CASE ( "Testing wasm <const_229_wasm>" ,
"" [const_229_wasm_tests] )

Definition at line 1127 of file const_tests.cpp.

1127 {
1128 using backend_t = backend<standalone_function_t, TestType>;
1129 auto code = read_wasm( std::string(wasm_directory) + "const.229.wasm");
1130 backend_t bkend( code, &wa );
1131
1132 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1133}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [141/338]

BACKEND_TEST_CASE ( "Testing wasm <const_22_wasm>" ,
"" [const_22_wasm_tests] )

Definition at line 1048 of file const_tests.cpp.

1048 {
1049 using backend_t = backend<standalone_function_t, TestType>;
1050 auto code = read_wasm( std::string(wasm_directory) + "const.22.wasm");
1051 backend_t bkend( code, &wa );
1052
1053}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [142/338]

BACKEND_TEST_CASE ( "Testing wasm <const_230_wasm>" ,
"" [const_230_wasm_tests] )

Definition at line 1142 of file const_tests.cpp.

1142 {
1143 using backend_t = backend<standalone_function_t, TestType>;
1144 auto code = read_wasm( std::string(wasm_directory) + "const.230.wasm");
1145 backend_t bkend( code, &wa );
1146
1147 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1148}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [143/338]

BACKEND_TEST_CASE ( "Testing wasm <const_231_wasm>" ,
"" [const_231_wasm_tests] )

Definition at line 1150 of file const_tests.cpp.

1150 {
1151 using backend_t = backend<standalone_function_t, TestType>;
1152 auto code = read_wasm( std::string(wasm_directory) + "const.231.wasm");
1153 backend_t bkend( code, &wa );
1154
1155 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1156}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [144/338]

BACKEND_TEST_CASE ( "Testing wasm <const_232_wasm>" ,
"" [const_232_wasm_tests] )

Definition at line 1158 of file const_tests.cpp.

1158 {
1159 using backend_t = backend<standalone_function_t, TestType>;
1160 auto code = read_wasm( std::string(wasm_directory) + "const.232.wasm");
1161 backend_t bkend( code, &wa );
1162
1163 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1164}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [145/338]

BACKEND_TEST_CASE ( "Testing wasm <const_233_wasm>" ,
"" [const_233_wasm_tests] )

Definition at line 1166 of file const_tests.cpp.

1166 {
1167 using backend_t = backend<standalone_function_t, TestType>;
1168 auto code = read_wasm( std::string(wasm_directory) + "const.233.wasm");
1169 backend_t bkend( code, &wa );
1170
1171 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1172}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [146/338]

BACKEND_TEST_CASE ( "Testing wasm <const_234_wasm>" ,
"" [const_234_wasm_tests] )

Definition at line 1174 of file const_tests.cpp.

1174 {
1175 using backend_t = backend<standalone_function_t, TestType>;
1176 auto code = read_wasm( std::string(wasm_directory) + "const.234.wasm");
1177 backend_t bkend( code, &wa );
1178
1179 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1180}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [147/338]

BACKEND_TEST_CASE ( "Testing wasm <const_235_wasm>" ,
"" [const_235_wasm_tests] )

Definition at line 1182 of file const_tests.cpp.

1182 {
1183 using backend_t = backend<standalone_function_t, TestType>;
1184 auto code = read_wasm( std::string(wasm_directory) + "const.235.wasm");
1185 backend_t bkend( code, &wa );
1186
1187 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1188}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [148/338]

BACKEND_TEST_CASE ( "Testing wasm <const_236_wasm>" ,
"" [const_236_wasm_tests] )

Definition at line 1190 of file const_tests.cpp.

1190 {
1191 using backend_t = backend<standalone_function_t, TestType>;
1192 auto code = read_wasm( std::string(wasm_directory) + "const.236.wasm");
1193 backend_t bkend( code, &wa );
1194
1195 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719811));
1196}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [149/338]

BACKEND_TEST_CASE ( "Testing wasm <const_237_wasm>" ,
"" [const_237_wasm_tests] )

Definition at line 1198 of file const_tests.cpp.

1198 {
1199 using backend_t = backend<standalone_function_t, TestType>;
1200 auto code = read_wasm( std::string(wasm_directory) + "const.237.wasm");
1201 backend_t bkend( code, &wa );
1202
1203 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495619));
1204}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [150/338]

BACKEND_TEST_CASE ( "Testing wasm <const_238_wasm>" ,
"" [const_238_wasm_tests] )

Definition at line 1206 of file const_tests.cpp.

1206 {
1207 using backend_t = backend<standalone_function_t, TestType>;
1208 auto code = read_wasm( std::string(wasm_directory) + "const.238.wasm");
1209 backend_t bkend( code, &wa );
1210
1211 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719808));
1212}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [151/338]

BACKEND_TEST_CASE ( "Testing wasm <const_239_wasm>" ,
"" [const_239_wasm_tests] )

Definition at line 1214 of file const_tests.cpp.

1214 {
1215 using backend_t = backend<standalone_function_t, TestType>;
1216 auto code = read_wasm( std::string(wasm_directory) + "const.239.wasm");
1217 backend_t bkend( code, &wa );
1218
1219 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495616));
1220}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [152/338]

BACKEND_TEST_CASE ( "Testing wasm <const_23_wasm>" ,
"" [const_23_wasm_tests] )

Definition at line 1135 of file const_tests.cpp.

1135 {
1136 using backend_t = backend<standalone_function_t, TestType>;
1137 auto code = read_wasm( std::string(wasm_directory) + "const.23.wasm");
1138 backend_t bkend( code, &wa );
1139
1140}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [153/338]

BACKEND_TEST_CASE ( "Testing wasm <const_240_wasm>" ,
"" [const_240_wasm_tests] )

Definition at line 1229 of file const_tests.cpp.

1229 {
1230 using backend_t = backend<standalone_function_t, TestType>;
1231 auto code = read_wasm( std::string(wasm_directory) + "const.240.wasm");
1232 backend_t bkend( code, &wa );
1233
1234 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1235}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [154/338]

BACKEND_TEST_CASE ( "Testing wasm <const_241_wasm>" ,
"" [const_241_wasm_tests] )

Definition at line 1237 of file const_tests.cpp.

1237 {
1238 using backend_t = backend<standalone_function_t, TestType>;
1239 auto code = read_wasm( std::string(wasm_directory) + "const.241.wasm");
1240 backend_t bkend( code, &wa );
1241
1242 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1243}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [155/338]

BACKEND_TEST_CASE ( "Testing wasm <const_242_wasm>" ,
"" [const_242_wasm_tests] )

Definition at line 1245 of file const_tests.cpp.

1245 {
1246 using backend_t = backend<standalone_function_t, TestType>;
1247 auto code = read_wasm( std::string(wasm_directory) + "const.242.wasm");
1248 backend_t bkend( code, &wa );
1249
1250 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1251}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [156/338]

BACKEND_TEST_CASE ( "Testing wasm <const_243_wasm>" ,
"" [const_243_wasm_tests] )

Definition at line 1253 of file const_tests.cpp.

1253 {
1254 using backend_t = backend<standalone_function_t, TestType>;
1255 auto code = read_wasm( std::string(wasm_directory) + "const.243.wasm");
1256 backend_t bkend( code, &wa );
1257
1258 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1259}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [157/338]

BACKEND_TEST_CASE ( "Testing wasm <const_244_wasm>" ,
"" [const_244_wasm_tests] )

Definition at line 1261 of file const_tests.cpp.

1261 {
1262 using backend_t = backend<standalone_function_t, TestType>;
1263 auto code = read_wasm( std::string(wasm_directory) + "const.244.wasm");
1264 backend_t bkend( code, &wa );
1265
1266 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1267}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [158/338]

BACKEND_TEST_CASE ( "Testing wasm <const_245_wasm>" ,
"" [const_245_wasm_tests] )

Definition at line 1269 of file const_tests.cpp.

1269 {
1270 using backend_t = backend<standalone_function_t, TestType>;
1271 auto code = read_wasm( std::string(wasm_directory) + "const.245.wasm");
1272 backend_t bkend( code, &wa );
1273
1274 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1275}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [159/338]

BACKEND_TEST_CASE ( "Testing wasm <const_246_wasm>" ,
"" [const_246_wasm_tests] )

Definition at line 1277 of file const_tests.cpp.

1277 {
1278 using backend_t = backend<standalone_function_t, TestType>;
1279 auto code = read_wasm( std::string(wasm_directory) + "const.246.wasm");
1280 backend_t bkend( code, &wa );
1281
1282 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1283}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [160/338]

BACKEND_TEST_CASE ( "Testing wasm <const_247_wasm>" ,
"" [const_247_wasm_tests] )

Definition at line 1285 of file const_tests.cpp.

1285 {
1286 using backend_t = backend<standalone_function_t, TestType>;
1287 auto code = read_wasm( std::string(wasm_directory) + "const.247.wasm");
1288 backend_t bkend( code, &wa );
1289
1290 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1291}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [161/338]

BACKEND_TEST_CASE ( "Testing wasm <const_248_wasm>" ,
"" [const_248_wasm_tests] )

Definition at line 1293 of file const_tests.cpp.

1293 {
1294 using backend_t = backend<standalone_function_t, TestType>;
1295 auto code = read_wasm( std::string(wasm_directory) + "const.248.wasm");
1296 backend_t bkend( code, &wa );
1297
1298 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719809));
1299}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [162/338]

BACKEND_TEST_CASE ( "Testing wasm <const_249_wasm>" ,
"" [const_249_wasm_tests] )

Definition at line 1301 of file const_tests.cpp.

1301 {
1302 using backend_t = backend<standalone_function_t, TestType>;
1303 auto code = read_wasm( std::string(wasm_directory) + "const.249.wasm");
1304 backend_t bkend( code, &wa );
1305
1306 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495617));
1307}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [163/338]

BACKEND_TEST_CASE ( "Testing wasm <const_24_wasm>" ,
"" [const_24_wasm_tests] )

Definition at line 1222 of file const_tests.cpp.

1222 {
1223 using backend_t = backend<standalone_function_t, TestType>;
1224 auto code = read_wasm( std::string(wasm_directory) + "const.24.wasm");
1225 backend_t bkend( code, &wa );
1226
1227}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [164/338]

BACKEND_TEST_CASE ( "Testing wasm <const_250_wasm>" ,
"" [const_250_wasm_tests] )

Definition at line 1316 of file const_tests.cpp.

1316 {
1317 using backend_t = backend<standalone_function_t, TestType>;
1318 auto code = read_wasm( std::string(wasm_directory) + "const.250.wasm");
1319 backend_t bkend( code, &wa );
1320
1321 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1322}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [165/338]

BACKEND_TEST_CASE ( "Testing wasm <const_251_wasm>" ,
"" [const_251_wasm_tests] )

Definition at line 1324 of file const_tests.cpp.

1324 {
1325 using backend_t = backend<standalone_function_t, TestType>;
1326 auto code = read_wasm( std::string(wasm_directory) + "const.251.wasm");
1327 backend_t bkend( code, &wa );
1328
1329 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1330}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [166/338]

BACKEND_TEST_CASE ( "Testing wasm <const_252_wasm>" ,
"" [const_252_wasm_tests] )

Definition at line 1332 of file const_tests.cpp.

1332 {
1333 using backend_t = backend<standalone_function_t, TestType>;
1334 auto code = read_wasm( std::string(wasm_directory) + "const.252.wasm");
1335 backend_t bkend( code, &wa );
1336
1337 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1338}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [167/338]

BACKEND_TEST_CASE ( "Testing wasm <const_253_wasm>" ,
"" [const_253_wasm_tests] )

Definition at line 1340 of file const_tests.cpp.

1340 {
1341 using backend_t = backend<standalone_function_t, TestType>;
1342 auto code = read_wasm( std::string(wasm_directory) + "const.253.wasm");
1343 backend_t bkend( code, &wa );
1344
1345 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1346}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [168/338]

BACKEND_TEST_CASE ( "Testing wasm <const_254_wasm>" ,
"" [const_254_wasm_tests] )

Definition at line 1348 of file const_tests.cpp.

1348 {
1349 using backend_t = backend<standalone_function_t, TestType>;
1350 auto code = read_wasm( std::string(wasm_directory) + "const.254.wasm");
1351 backend_t bkend( code, &wa );
1352
1353 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1354}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [169/338]

BACKEND_TEST_CASE ( "Testing wasm <const_255_wasm>" ,
"" [const_255_wasm_tests] )

Definition at line 1356 of file const_tests.cpp.

1356 {
1357 using backend_t = backend<standalone_function_t, TestType>;
1358 auto code = read_wasm( std::string(wasm_directory) + "const.255.wasm");
1359 backend_t bkend( code, &wa );
1360
1361 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1362}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [170/338]

BACKEND_TEST_CASE ( "Testing wasm <const_256_wasm>" ,
"" [const_256_wasm_tests] )

Definition at line 1364 of file const_tests.cpp.

1364 {
1365 using backend_t = backend<standalone_function_t, TestType>;
1366 auto code = read_wasm( std::string(wasm_directory) + "const.256.wasm");
1367 backend_t bkend( code, &wa );
1368
1369 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1370}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [171/338]

BACKEND_TEST_CASE ( "Testing wasm <const_257_wasm>" ,
"" [const_257_wasm_tests] )

Definition at line 1372 of file const_tests.cpp.

1372 {
1373 using backend_t = backend<standalone_function_t, TestType>;
1374 auto code = read_wasm( std::string(wasm_directory) + "const.257.wasm");
1375 backend_t bkend( code, &wa );
1376
1377 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1378}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [172/338]

BACKEND_TEST_CASE ( "Testing wasm <const_258_wasm>" ,
"" [const_258_wasm_tests] )

Definition at line 1380 of file const_tests.cpp.

1380 {
1381 using backend_t = backend<standalone_function_t, TestType>;
1382 auto code = read_wasm( std::string(wasm_directory) + "const.258.wasm");
1383 backend_t bkend( code, &wa );
1384
1385 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1386}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [173/338]

BACKEND_TEST_CASE ( "Testing wasm <const_259_wasm>" ,
"" [const_259_wasm_tests] )

Definition at line 1388 of file const_tests.cpp.

1388 {
1389 using backend_t = backend<standalone_function_t, TestType>;
1390 auto code = read_wasm( std::string(wasm_directory) + "const.259.wasm");
1391 backend_t bkend( code, &wa );
1392
1393 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1394}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [174/338]

BACKEND_TEST_CASE ( "Testing wasm <const_25_wasm>" ,
"" [const_25_wasm_tests] )

Definition at line 1309 of file const_tests.cpp.

1309 {
1310 using backend_t = backend<standalone_function_t, TestType>;
1311 auto code = read_wasm( std::string(wasm_directory) + "const.25.wasm");
1312 backend_t bkend( code, &wa );
1313
1314}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [175/338]

BACKEND_TEST_CASE ( "Testing wasm <const_260_wasm>" ,
"" [const_260_wasm_tests] )

Definition at line 1396 of file const_tests.cpp.

1396 {
1397 using backend_t = backend<standalone_function_t, TestType>;
1398 auto code = read_wasm( std::string(wasm_directory) + "const.260.wasm");
1399 backend_t bkend( code, &wa );
1400
1401 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719810));
1402}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [176/338]

BACKEND_TEST_CASE ( "Testing wasm <const_261_wasm>" ,
"" [const_261_wasm_tests] )

Definition at line 1404 of file const_tests.cpp.

1404 {
1405 using backend_t = backend<standalone_function_t, TestType>;
1406 auto code = read_wasm( std::string(wasm_directory) + "const.261.wasm");
1407 backend_t bkend( code, &wa );
1408
1409 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495618));
1410}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [177/338]

BACKEND_TEST_CASE ( "Testing wasm <const_262_wasm>" ,
"" [const_262_wasm_tests] )

Definition at line 1412 of file const_tests.cpp.

1412 {
1413 using backend_t = backend<standalone_function_t, TestType>;
1414 auto code = read_wasm( std::string(wasm_directory) + "const.262.wasm");
1415 backend_t bkend( code, &wa );
1416
1417 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1905022642377719811));
1418}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [178/338]

BACKEND_TEST_CASE ( "Testing wasm <const_263_wasm>" ,
"" [const_263_wasm_tests] )

Definition at line 1420 of file const_tests.cpp.

1420 {
1421 using backend_t = backend<standalone_function_t, TestType>;
1422 auto code = read_wasm( std::string(wasm_directory) + "const.263.wasm");
1423 backend_t bkend( code, &wa );
1424
1425 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(11128394679232495619));
1426}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [179/338]

BACKEND_TEST_CASE ( "Testing wasm <const_264_wasm>" ,
"" [const_264_wasm_tests] )

Definition at line 1428 of file const_tests.cpp.

1428 {
1429 using backend_t = backend<standalone_function_t, TestType>;
1430 auto code = read_wasm( std::string(wasm_directory) + "const.264.wasm");
1431 backend_t bkend( code, &wa );
1432
1433 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9106278446543142912));
1434}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [180/338]

BACKEND_TEST_CASE ( "Testing wasm <const_265_wasm>" ,
"" [const_265_wasm_tests] )

Definition at line 1436 of file const_tests.cpp.

1436 {
1437 using backend_t = backend<standalone_function_t, TestType>;
1438 auto code = read_wasm( std::string(wasm_directory) + "const.265.wasm");
1439 backend_t bkend( code, &wa );
1440
1441 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(18329650483397918720));
1442}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [181/338]

BACKEND_TEST_CASE ( "Testing wasm <const_266_wasm>" ,
"" [const_266_wasm_tests] )

Definition at line 1444 of file const_tests.cpp.

1444 {
1445 using backend_t = backend<standalone_function_t, TestType>;
1446 auto code = read_wasm( std::string(wasm_directory) + "const.266.wasm");
1447 backend_t bkend( code, &wa );
1448
1449 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9106278446543142913));
1450}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [182/338]

BACKEND_TEST_CASE ( "Testing wasm <const_267_wasm>" ,
"" [const_267_wasm_tests] )

Definition at line 1452 of file const_tests.cpp.

1452 {
1453 using backend_t = backend<standalone_function_t, TestType>;
1454 auto code = read_wasm( std::string(wasm_directory) + "const.267.wasm");
1455 backend_t bkend( code, &wa );
1456
1457 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(18329650483397918721));
1458}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [183/338]

BACKEND_TEST_CASE ( "Testing wasm <const_268_wasm>" ,
"" [const_268_wasm_tests] )

Definition at line 1460 of file const_tests.cpp.

1460 {
1461 using backend_t = backend<standalone_function_t, TestType>;
1462 auto code = read_wasm( std::string(wasm_directory) + "const.268.wasm");
1463 backend_t bkend( code, &wa );
1464
1465 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9106278446543142913));
1466}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [184/338]

BACKEND_TEST_CASE ( "Testing wasm <const_269_wasm>" ,
"" [const_269_wasm_tests] )

Definition at line 1468 of file const_tests.cpp.

1468 {
1469 using backend_t = backend<standalone_function_t, TestType>;
1470 auto code = read_wasm( std::string(wasm_directory) + "const.269.wasm");
1471 backend_t bkend( code, &wa );
1472
1473 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(18329650483397918721));
1474}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [185/338]

BACKEND_TEST_CASE ( "Testing wasm <const_270_wasm>" ,
"" [const_270_wasm_tests] )

Definition at line 1476 of file const_tests.cpp.

1476 {
1477 using backend_t = backend<standalone_function_t, TestType>;
1478 auto code = read_wasm( std::string(wasm_directory) + "const.270.wasm");
1479 backend_t bkend( code, &wa );
1480
1481 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9106278446543142914));
1482}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [186/338]

BACKEND_TEST_CASE ( "Testing wasm <const_271_wasm>" ,
"" [const_271_wasm_tests] )

Definition at line 1484 of file const_tests.cpp.

1484 {
1485 using backend_t = backend<standalone_function_t, TestType>;
1486 auto code = read_wasm( std::string(wasm_directory) + "const.271.wasm");
1487 backend_t bkend( code, &wa );
1488
1489 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(18329650483397918722));
1490}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [187/338]

BACKEND_TEST_CASE ( "Testing wasm <const_272_wasm>" ,
"" [const_272_wasm_tests] )

Definition at line 1492 of file const_tests.cpp.

1492 {
1493 using backend_t = backend<standalone_function_t, TestType>;
1494 auto code = read_wasm( std::string(wasm_directory) + "const.272.wasm");
1495 backend_t bkend( code, &wa );
1496
1497 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315008));
1498}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [188/338]

BACKEND_TEST_CASE ( "Testing wasm <const_273_wasm>" ,
"" [const_273_wasm_tests] )

Definition at line 1500 of file const_tests.cpp.

1500 {
1501 using backend_t = backend<standalone_function_t, TestType>;
1502 auto code = read_wasm( std::string(wasm_directory) + "const.273.wasm");
1503 backend_t bkend( code, &wa );
1504
1505 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090816));
1506}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [189/338]

BACKEND_TEST_CASE ( "Testing wasm <const_274_wasm>" ,
"" [const_274_wasm_tests] )

Definition at line 1508 of file const_tests.cpp.

1508 {
1509 using backend_t = backend<standalone_function_t, TestType>;
1510 auto code = read_wasm( std::string(wasm_directory) + "const.274.wasm");
1511 backend_t bkend( code, &wa );
1512
1513 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315009));
1514}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [190/338]

BACKEND_TEST_CASE ( "Testing wasm <const_275_wasm>" ,
"" [const_275_wasm_tests] )

Definition at line 1516 of file const_tests.cpp.

1516 {
1517 using backend_t = backend<standalone_function_t, TestType>;
1518 auto code = read_wasm( std::string(wasm_directory) + "const.275.wasm");
1519 backend_t bkend( code, &wa );
1520
1521 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090817));
1522}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [191/338]

BACKEND_TEST_CASE ( "Testing wasm <const_276_wasm>" ,
"" [const_276_wasm_tests] )

Definition at line 1524 of file const_tests.cpp.

1524 {
1525 using backend_t = backend<standalone_function_t, TestType>;
1526 auto code = read_wasm( std::string(wasm_directory) + "const.276.wasm");
1527 backend_t bkend( code, &wa );
1528
1529 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315009));
1530}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [192/338]

BACKEND_TEST_CASE ( "Testing wasm <const_277_wasm>" ,
"" [const_277_wasm_tests] )

Definition at line 1532 of file const_tests.cpp.

1532 {
1533 using backend_t = backend<standalone_function_t, TestType>;
1534 auto code = read_wasm( std::string(wasm_directory) + "const.277.wasm");
1535 backend_t bkend( code, &wa );
1536
1537 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090817));
1538}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [193/338]

BACKEND_TEST_CASE ( "Testing wasm <const_278_wasm>" ,
"" [const_278_wasm_tests] )

Definition at line 1540 of file const_tests.cpp.

1540 {
1541 using backend_t = backend<standalone_function_t, TestType>;
1542 auto code = read_wasm( std::string(wasm_directory) + "const.278.wasm");
1543 backend_t bkend( code, &wa );
1544
1545 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315009));
1546}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [194/338]

BACKEND_TEST_CASE ( "Testing wasm <const_279_wasm>" ,
"" [const_279_wasm_tests] )

Definition at line 1548 of file const_tests.cpp.

1548 {
1549 using backend_t = backend<standalone_function_t, TestType>;
1550 auto code = read_wasm( std::string(wasm_directory) + "const.279.wasm");
1551 backend_t bkend( code, &wa );
1552
1553 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090817));
1554}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [195/338]

BACKEND_TEST_CASE ( "Testing wasm <const_280_wasm>" ,
"" [const_280_wasm_tests] )

Definition at line 1556 of file const_tests.cpp.

1556 {
1557 using backend_t = backend<standalone_function_t, TestType>;
1558 auto code = read_wasm( std::string(wasm_directory) + "const.280.wasm");
1559 backend_t bkend( code, &wa );
1560
1561 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315009));
1562}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [196/338]

BACKEND_TEST_CASE ( "Testing wasm <const_281_wasm>" ,
"" [const_281_wasm_tests] )

Definition at line 1564 of file const_tests.cpp.

1564 {
1565 using backend_t = backend<standalone_function_t, TestType>;
1566 auto code = read_wasm( std::string(wasm_directory) + "const.281.wasm");
1567 backend_t bkend( code, &wa );
1568
1569 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090817));
1570}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [197/338]

BACKEND_TEST_CASE ( "Testing wasm <const_282_wasm>" ,
"" [const_282_wasm_tests] )

Definition at line 1572 of file const_tests.cpp.

1572 {
1573 using backend_t = backend<standalone_function_t, TestType>;
1574 auto code = read_wasm( std::string(wasm_directory) + "const.282.wasm");
1575 backend_t bkend( code, &wa );
1576
1577 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315009));
1578}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [198/338]

BACKEND_TEST_CASE ( "Testing wasm <const_283_wasm>" ,
"" [const_283_wasm_tests] )

Definition at line 1580 of file const_tests.cpp.

1580 {
1581 using backend_t = backend<standalone_function_t, TestType>;
1582 auto code = read_wasm( std::string(wasm_directory) + "const.283.wasm");
1583 backend_t bkend( code, &wa );
1584
1585 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090817));
1586}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [199/338]

BACKEND_TEST_CASE ( "Testing wasm <const_284_wasm>" ,
"" [const_284_wasm_tests] )

Definition at line 1588 of file const_tests.cpp.

1588 {
1589 using backend_t = backend<standalone_function_t, TestType>;
1590 auto code = read_wasm( std::string(wasm_directory) + "const.284.wasm");
1591 backend_t bkend( code, &wa );
1592
1593 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1594}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [200/338]

BACKEND_TEST_CASE ( "Testing wasm <const_285_wasm>" ,
"" [const_285_wasm_tests] )

Definition at line 1596 of file const_tests.cpp.

1596 {
1597 using backend_t = backend<standalone_function_t, TestType>;
1598 auto code = read_wasm( std::string(wasm_directory) + "const.285.wasm");
1599 backend_t bkend( code, &wa );
1600
1601 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1602}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [201/338]

BACKEND_TEST_CASE ( "Testing wasm <const_286_wasm>" ,
"" [const_286_wasm_tests] )

Definition at line 1604 of file const_tests.cpp.

1604 {
1605 using backend_t = backend<standalone_function_t, TestType>;
1606 auto code = read_wasm( std::string(wasm_directory) + "const.286.wasm");
1607 backend_t bkend( code, &wa );
1608
1609 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1610}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [202/338]

BACKEND_TEST_CASE ( "Testing wasm <const_287_wasm>" ,
"" [const_287_wasm_tests] )

Definition at line 1612 of file const_tests.cpp.

1612 {
1613 using backend_t = backend<standalone_function_t, TestType>;
1614 auto code = read_wasm( std::string(wasm_directory) + "const.287.wasm");
1615 backend_t bkend( code, &wa );
1616
1617 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1618}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [203/338]

BACKEND_TEST_CASE ( "Testing wasm <const_288_wasm>" ,
"" [const_288_wasm_tests] )

Definition at line 1620 of file const_tests.cpp.

1620 {
1621 using backend_t = backend<standalone_function_t, TestType>;
1622 auto code = read_wasm( std::string(wasm_directory) + "const.288.wasm");
1623 backend_t bkend( code, &wa );
1624
1625 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1626}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [204/338]

BACKEND_TEST_CASE ( "Testing wasm <const_289_wasm>" ,
"" [const_289_wasm_tests] )

Definition at line 1628 of file const_tests.cpp.

1628 {
1629 using backend_t = backend<standalone_function_t, TestType>;
1630 auto code = read_wasm( std::string(wasm_directory) + "const.289.wasm");
1631 backend_t bkend( code, &wa );
1632
1633 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1634}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [205/338]

BACKEND_TEST_CASE ( "Testing wasm <const_290_wasm>" ,
"" [const_290_wasm_tests] )

Definition at line 1636 of file const_tests.cpp.

1636 {
1637 using backend_t = backend<standalone_function_t, TestType>;
1638 auto code = read_wasm( std::string(wasm_directory) + "const.290.wasm");
1639 backend_t bkend( code, &wa );
1640
1641 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1642}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [206/338]

BACKEND_TEST_CASE ( "Testing wasm <const_291_wasm>" ,
"" [const_291_wasm_tests] )

Definition at line 1644 of file const_tests.cpp.

1644 {
1645 using backend_t = backend<standalone_function_t, TestType>;
1646 auto code = read_wasm( std::string(wasm_directory) + "const.291.wasm");
1647 backend_t bkend( code, &wa );
1648
1649 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1650}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [207/338]

BACKEND_TEST_CASE ( "Testing wasm <const_292_wasm>" ,
"" [const_292_wasm_tests] )

Definition at line 1652 of file const_tests.cpp.

1652 {
1653 using backend_t = backend<standalone_function_t, TestType>;
1654 auto code = read_wasm( std::string(wasm_directory) + "const.292.wasm");
1655 backend_t bkend( code, &wa );
1656
1657 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1658}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [208/338]

BACKEND_TEST_CASE ( "Testing wasm <const_293_wasm>" ,
"" [const_293_wasm_tests] )

Definition at line 1660 of file const_tests.cpp.

1660 {
1661 using backend_t = backend<standalone_function_t, TestType>;
1662 auto code = read_wasm( std::string(wasm_directory) + "const.293.wasm");
1663 backend_t bkend( code, &wa );
1664
1665 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1666}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [209/338]

BACKEND_TEST_CASE ( "Testing wasm <const_294_wasm>" ,
"" [const_294_wasm_tests] )

Definition at line 1668 of file const_tests.cpp.

1668 {
1669 using backend_t = backend<standalone_function_t, TestType>;
1670 auto code = read_wasm( std::string(wasm_directory) + "const.294.wasm");
1671 backend_t bkend( code, &wa );
1672
1673 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1674}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [210/338]

BACKEND_TEST_CASE ( "Testing wasm <const_295_wasm>" ,
"" [const_295_wasm_tests] )

Definition at line 1676 of file const_tests.cpp.

1676 {
1677 using backend_t = backend<standalone_function_t, TestType>;
1678 auto code = read_wasm( std::string(wasm_directory) + "const.295.wasm");
1679 backend_t bkend( code, &wa );
1680
1681 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1682}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [211/338]

BACKEND_TEST_CASE ( "Testing wasm <const_296_wasm>" ,
"" [const_296_wasm_tests] )

Definition at line 1684 of file const_tests.cpp.

1684 {
1685 using backend_t = backend<standalone_function_t, TestType>;
1686 auto code = read_wasm( std::string(wasm_directory) + "const.296.wasm");
1687 backend_t bkend( code, &wa );
1688
1689 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315010));
1690}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [212/338]

BACKEND_TEST_CASE ( "Testing wasm <const_297_wasm>" ,
"" [const_297_wasm_tests] )

Definition at line 1692 of file const_tests.cpp.

1692 {
1693 using backend_t = backend<standalone_function_t, TestType>;
1694 auto code = read_wasm( std::string(wasm_directory) + "const.297.wasm");
1695 backend_t bkend( code, &wa );
1696
1697 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090818));
1698}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [213/338]

BACKEND_TEST_CASE ( "Testing wasm <const_298_wasm>" ,
"" [const_298_wasm_tests] )

Definition at line 1700 of file const_tests.cpp.

1700 {
1701 using backend_t = backend<standalone_function_t, TestType>;
1702 auto code = read_wasm( std::string(wasm_directory) + "const.298.wasm");
1703 backend_t bkend( code, &wa );
1704
1705 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(7309342195222315011));
1706}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [214/338]

BACKEND_TEST_CASE ( "Testing wasm <const_299_wasm>" ,
"" [const_299_wasm_tests] )

Definition at line 1708 of file const_tests.cpp.

1708 {
1709 using backend_t = backend<standalone_function_t, TestType>;
1710 auto code = read_wasm( std::string(wasm_directory) + "const.299.wasm");
1711 backend_t bkend( code, &wa );
1712
1713 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(16532714232077090819));
1714}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [215/338]

BACKEND_TEST_CASE ( "Testing wasm <const_300_wasm>" ,
"" [const_300_wasm_tests] )

Definition at line 1723 of file const_tests.cpp.

1723 {
1724 using backend_t = backend<standalone_function_t, TestType>;
1725 auto code = read_wasm( std::string(wasm_directory) + "const.300.wasm");
1726 backend_t bkend( code, &wa );
1727
1728 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955520));
1729}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [216/338]

BACKEND_TEST_CASE ( "Testing wasm <const_301_wasm>" ,
"" [const_301_wasm_tests] )

Definition at line 1731 of file const_tests.cpp.

1731 {
1732 using backend_t = backend<standalone_function_t, TestType>;
1733 auto code = read_wasm( std::string(wasm_directory) + "const.301.wasm");
1734 backend_t bkend( code, &wa );
1735
1736 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731328));
1737}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [217/338]

BACKEND_TEST_CASE ( "Testing wasm <const_302_wasm>" ,
"" [const_302_wasm_tests] )

Definition at line 1739 of file const_tests.cpp.

1739 {
1740 using backend_t = backend<standalone_function_t, TestType>;
1741 auto code = read_wasm( std::string(wasm_directory) + "const.302.wasm");
1742 backend_t bkend( code, &wa );
1743
1744 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955521));
1745}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [218/338]

BACKEND_TEST_CASE ( "Testing wasm <const_303_wasm>" ,
"" [const_303_wasm_tests] )

Definition at line 1747 of file const_tests.cpp.

1747 {
1748 using backend_t = backend<standalone_function_t, TestType>;
1749 auto code = read_wasm( std::string(wasm_directory) + "const.303.wasm");
1750 backend_t bkend( code, &wa );
1751
1752 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731329));
1753}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [219/338]

BACKEND_TEST_CASE ( "Testing wasm <const_304_wasm>" ,
"" [const_304_wasm_tests] )

Definition at line 1755 of file const_tests.cpp.

1755 {
1756 using backend_t = backend<standalone_function_t, TestType>;
1757 auto code = read_wasm( std::string(wasm_directory) + "const.304.wasm");
1758 backend_t bkend( code, &wa );
1759
1760 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955521));
1761}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [220/338]

BACKEND_TEST_CASE ( "Testing wasm <const_305_wasm>" ,
"" [const_305_wasm_tests] )

Definition at line 1763 of file const_tests.cpp.

1763 {
1764 using backend_t = backend<standalone_function_t, TestType>;
1765 auto code = read_wasm( std::string(wasm_directory) + "const.305.wasm");
1766 backend_t bkend( code, &wa );
1767
1768 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731329));
1769}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [221/338]

BACKEND_TEST_CASE ( "Testing wasm <const_306_wasm>" ,
"" [const_306_wasm_tests] )

Definition at line 1771 of file const_tests.cpp.

1771 {
1772 using backend_t = backend<standalone_function_t, TestType>;
1773 auto code = read_wasm( std::string(wasm_directory) + "const.306.wasm");
1774 backend_t bkend( code, &wa );
1775
1776 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955521));
1777}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [222/338]

BACKEND_TEST_CASE ( "Testing wasm <const_307_wasm>" ,
"" [const_307_wasm_tests] )

Definition at line 1779 of file const_tests.cpp.

1779 {
1780 using backend_t = backend<standalone_function_t, TestType>;
1781 auto code = read_wasm( std::string(wasm_directory) + "const.307.wasm");
1782 backend_t bkend( code, &wa );
1783
1784 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731329));
1785}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [223/338]

BACKEND_TEST_CASE ( "Testing wasm <const_308_wasm>" ,
"" [const_308_wasm_tests] )

Definition at line 1787 of file const_tests.cpp.

1787 {
1788 using backend_t = backend<standalone_function_t, TestType>;
1789 auto code = read_wasm( std::string(wasm_directory) + "const.308.wasm");
1790 backend_t bkend( code, &wa );
1791
1792 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955521));
1793}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [224/338]

BACKEND_TEST_CASE ( "Testing wasm <const_309_wasm>" ,
"" [const_309_wasm_tests] )

Definition at line 1795 of file const_tests.cpp.

1795 {
1796 using backend_t = backend<standalone_function_t, TestType>;
1797 auto code = read_wasm( std::string(wasm_directory) + "const.309.wasm");
1798 backend_t bkend( code, &wa );
1799
1800 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731329));
1801}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [225/338]

BACKEND_TEST_CASE ( "Testing wasm <const_30_wasm>" ,
"" [const_30_wasm_tests] )

Definition at line 1716 of file const_tests.cpp.

1716 {
1717 using backend_t = backend<standalone_function_t, TestType>;
1718 auto code = read_wasm( std::string(wasm_directory) + "const.30.wasm");
1719 backend_t bkend( code, &wa );
1720
1721}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [226/338]

BACKEND_TEST_CASE ( "Testing wasm <const_310_wasm>" ,
"" [const_310_wasm_tests] )

Definition at line 1810 of file const_tests.cpp.

1810 {
1811 using backend_t = backend<standalone_function_t, TestType>;
1812 auto code = read_wasm( std::string(wasm_directory) + "const.310.wasm");
1813 backend_t bkend( code, &wa );
1814
1815 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955521));
1816}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [227/338]

BACKEND_TEST_CASE ( "Testing wasm <const_311_wasm>" ,
"" [const_311_wasm_tests] )

Definition at line 1818 of file const_tests.cpp.

1818 {
1819 using backend_t = backend<standalone_function_t, TestType>;
1820 auto code = read_wasm( std::string(wasm_directory) + "const.311.wasm");
1821 backend_t bkend( code, &wa );
1822
1823 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731329));
1824}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [228/338]

BACKEND_TEST_CASE ( "Testing wasm <const_312_wasm>" ,
"" [const_312_wasm_tests] )

Definition at line 1826 of file const_tests.cpp.

1826 {
1827 using backend_t = backend<standalone_function_t, TestType>;
1828 auto code = read_wasm( std::string(wasm_directory) + "const.312.wasm");
1829 backend_t bkend( code, &wa );
1830
1831 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1832}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [229/338]

BACKEND_TEST_CASE ( "Testing wasm <const_313_wasm>" ,
"" [const_313_wasm_tests] )

Definition at line 1834 of file const_tests.cpp.

1834 {
1835 using backend_t = backend<standalone_function_t, TestType>;
1836 auto code = read_wasm( std::string(wasm_directory) + "const.313.wasm");
1837 backend_t bkend( code, &wa );
1838
1839 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1840}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [230/338]

BACKEND_TEST_CASE ( "Testing wasm <const_314_wasm>" ,
"" [const_314_wasm_tests] )

Definition at line 1842 of file const_tests.cpp.

1842 {
1843 using backend_t = backend<standalone_function_t, TestType>;
1844 auto code = read_wasm( std::string(wasm_directory) + "const.314.wasm");
1845 backend_t bkend( code, &wa );
1846
1847 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1848}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [231/338]

BACKEND_TEST_CASE ( "Testing wasm <const_315_wasm>" ,
"" [const_315_wasm_tests] )

Definition at line 1850 of file const_tests.cpp.

1850 {
1851 using backend_t = backend<standalone_function_t, TestType>;
1852 auto code = read_wasm( std::string(wasm_directory) + "const.315.wasm");
1853 backend_t bkend( code, &wa );
1854
1855 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1856}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [232/338]

BACKEND_TEST_CASE ( "Testing wasm <const_316_wasm>" ,
"" [const_316_wasm_tests] )

Definition at line 1858 of file const_tests.cpp.

1858 {
1859 using backend_t = backend<standalone_function_t, TestType>;
1860 auto code = read_wasm( std::string(wasm_directory) + "const.316.wasm");
1861 backend_t bkend( code, &wa );
1862
1863 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1864}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [233/338]

BACKEND_TEST_CASE ( "Testing wasm <const_317_wasm>" ,
"" [const_317_wasm_tests] )

Definition at line 1866 of file const_tests.cpp.

1866 {
1867 using backend_t = backend<standalone_function_t, TestType>;
1868 auto code = read_wasm( std::string(wasm_directory) + "const.317.wasm");
1869 backend_t bkend( code, &wa );
1870
1871 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1872}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [234/338]

BACKEND_TEST_CASE ( "Testing wasm <const_318_wasm>" ,
"" [const_318_wasm_tests] )

Definition at line 1874 of file const_tests.cpp.

1874 {
1875 using backend_t = backend<standalone_function_t, TestType>;
1876 auto code = read_wasm( std::string(wasm_directory) + "const.318.wasm");
1877 backend_t bkend( code, &wa );
1878
1879 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1880}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [235/338]

BACKEND_TEST_CASE ( "Testing wasm <const_319_wasm>" ,
"" [const_319_wasm_tests] )

Definition at line 1882 of file const_tests.cpp.

1882 {
1883 using backend_t = backend<standalone_function_t, TestType>;
1884 auto code = read_wasm( std::string(wasm_directory) + "const.319.wasm");
1885 backend_t bkend( code, &wa );
1886
1887 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1888}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [236/338]

BACKEND_TEST_CASE ( "Testing wasm <const_31_wasm>" ,
"" [const_31_wasm_tests] )

Definition at line 1803 of file const_tests.cpp.

1803 {
1804 using backend_t = backend<standalone_function_t, TestType>;
1805 auto code = read_wasm( std::string(wasm_directory) + "const.31.wasm");
1806 backend_t bkend( code, &wa );
1807
1808}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [237/338]

BACKEND_TEST_CASE ( "Testing wasm <const_320_wasm>" ,
"" [const_320_wasm_tests] )

Definition at line 1890 of file const_tests.cpp.

1890 {
1891 using backend_t = backend<standalone_function_t, TestType>;
1892 auto code = read_wasm( std::string(wasm_directory) + "const.320.wasm");
1893 backend_t bkend( code, &wa );
1894
1895 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1896}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [238/338]

BACKEND_TEST_CASE ( "Testing wasm <const_321_wasm>" ,
"" [const_321_wasm_tests] )

Definition at line 1898 of file const_tests.cpp.

1898 {
1899 using backend_t = backend<standalone_function_t, TestType>;
1900 auto code = read_wasm( std::string(wasm_directory) + "const.321.wasm");
1901 backend_t bkend( code, &wa );
1902
1903 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1904}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [239/338]

BACKEND_TEST_CASE ( "Testing wasm <const_322_wasm>" ,
"" [const_322_wasm_tests] )

Definition at line 1906 of file const_tests.cpp.

1906 {
1907 using backend_t = backend<standalone_function_t, TestType>;
1908 auto code = read_wasm( std::string(wasm_directory) + "const.322.wasm");
1909 backend_t bkend( code, &wa );
1910
1911 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1912}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [240/338]

BACKEND_TEST_CASE ( "Testing wasm <const_323_wasm>" ,
"" [const_323_wasm_tests] )

Definition at line 1914 of file const_tests.cpp.

1914 {
1915 using backend_t = backend<standalone_function_t, TestType>;
1916 auto code = read_wasm( std::string(wasm_directory) + "const.323.wasm");
1917 backend_t bkend( code, &wa );
1918
1919 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1920}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [241/338]

BACKEND_TEST_CASE ( "Testing wasm <const_324_wasm>" ,
"" [const_324_wasm_tests] )

Definition at line 1922 of file const_tests.cpp.

1922 {
1923 using backend_t = backend<standalone_function_t, TestType>;
1924 auto code = read_wasm( std::string(wasm_directory) + "const.324.wasm");
1925 backend_t bkend( code, &wa );
1926
1927 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955522));
1928}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [242/338]

BACKEND_TEST_CASE ( "Testing wasm <const_325_wasm>" ,
"" [const_325_wasm_tests] )

Definition at line 1930 of file const_tests.cpp.

1930 {
1931 using backend_t = backend<standalone_function_t, TestType>;
1932 auto code = read_wasm( std::string(wasm_directory) + "const.325.wasm");
1933 backend_t bkend( code, &wa );
1934
1935 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731330));
1936}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [243/338]

BACKEND_TEST_CASE ( "Testing wasm <const_326_wasm>" ,
"" [const_326_wasm_tests] )

Definition at line 1938 of file const_tests.cpp.

1938 {
1939 using backend_t = backend<standalone_function_t, TestType>;
1940 auto code = read_wasm( std::string(wasm_directory) + "const.326.wasm");
1941 backend_t bkend( code, &wa );
1942
1943 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(5044031582654955523));
1944}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [244/338]

BACKEND_TEST_CASE ( "Testing wasm <const_327_wasm>" ,
"" [const_327_wasm_tests] )

Definition at line 1946 of file const_tests.cpp.

1946 {
1947 using backend_t = backend<standalone_function_t, TestType>;
1948 auto code = read_wasm( std::string(wasm_directory) + "const.327.wasm");
1949 backend_t bkend( code, &wa );
1950
1951 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14267403619509731331));
1952}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [245/338]

BACKEND_TEST_CASE ( "Testing wasm <const_328_wasm>" ,
"" [const_328_wasm_tests] )

Definition at line 1954 of file const_tests.cpp.

1954 {
1955 using backend_t = backend<standalone_function_t, TestType>;
1956 auto code = read_wasm( std::string(wasm_directory) + "const.328.wasm");
1957 backend_t bkend( code, &wa );
1958
1959 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(4877398396442247168));
1960}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [246/338]

BACKEND_TEST_CASE ( "Testing wasm <const_329_wasm>" ,
"" [const_329_wasm_tests] )

Definition at line 1962 of file const_tests.cpp.

1962 {
1963 using backend_t = backend<standalone_function_t, TestType>;
1964 auto code = read_wasm( std::string(wasm_directory) + "const.329.wasm");
1965 backend_t bkend( code, &wa );
1966
1967 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14100770433297022976));
1968}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [247/338]

BACKEND_TEST_CASE ( "Testing wasm <const_330_wasm>" ,
"" [const_330_wasm_tests] )

Definition at line 1970 of file const_tests.cpp.

1970 {
1971 using backend_t = backend<standalone_function_t, TestType>;
1972 auto code = read_wasm( std::string(wasm_directory) + "const.330.wasm");
1973 backend_t bkend( code, &wa );
1974
1975 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(4877398396442247169));
1976}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [248/338]

BACKEND_TEST_CASE ( "Testing wasm <const_331_wasm>" ,
"" [const_331_wasm_tests] )

Definition at line 1978 of file const_tests.cpp.

1978 {
1979 using backend_t = backend<standalone_function_t, TestType>;
1980 auto code = read_wasm( std::string(wasm_directory) + "const.331.wasm");
1981 backend_t bkend( code, &wa );
1982
1983 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14100770433297022977));
1984}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [249/338]

BACKEND_TEST_CASE ( "Testing wasm <const_332_wasm>" ,
"" [const_332_wasm_tests] )

Definition at line 1986 of file const_tests.cpp.

1986 {
1987 using backend_t = backend<standalone_function_t, TestType>;
1988 auto code = read_wasm( std::string(wasm_directory) + "const.332.wasm");
1989 backend_t bkend( code, &wa );
1990
1991 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(4877398396442247169));
1992}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [250/338]

BACKEND_TEST_CASE ( "Testing wasm <const_333_wasm>" ,
"" [const_333_wasm_tests] )

Definition at line 1994 of file const_tests.cpp.

1994 {
1995 using backend_t = backend<standalone_function_t, TestType>;
1996 auto code = read_wasm( std::string(wasm_directory) + "const.333.wasm");
1997 backend_t bkend( code, &wa );
1998
1999 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14100770433297022977));
2000}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [251/338]

BACKEND_TEST_CASE ( "Testing wasm <const_334_wasm>" ,
"" [const_334_wasm_tests] )

Definition at line 2002 of file const_tests.cpp.

2002 {
2003 using backend_t = backend<standalone_function_t, TestType>;
2004 auto code = read_wasm( std::string(wasm_directory) + "const.334.wasm");
2005 backend_t bkend( code, &wa );
2006
2007 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(4877398396442247170));
2008}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [252/338]

BACKEND_TEST_CASE ( "Testing wasm <const_335_wasm>" ,
"" [const_335_wasm_tests] )

Definition at line 2010 of file const_tests.cpp.

2010 {
2011 using backend_t = backend<standalone_function_t, TestType>;
2012 auto code = read_wasm( std::string(wasm_directory) + "const.335.wasm");
2013 backend_t bkend( code, &wa );
2014
2015 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(14100770433297022978));
2016}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [253/338]

BACKEND_TEST_CASE ( "Testing wasm <const_336_wasm>" ,
"" [const_336_wasm_tests] )

Definition at line 2018 of file const_tests.cpp.

2018 {
2019 using backend_t = backend<standalone_function_t, TestType>;
2020 auto code = read_wasm( std::string(wasm_directory) + "const.336.wasm");
2021 backend_t bkend( code, &wa );
2022
2023 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(0));
2024}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [254/338]

BACKEND_TEST_CASE ( "Testing wasm <const_337_wasm>" ,
"" [const_337_wasm_tests] )

Definition at line 2026 of file const_tests.cpp.

2026 {
2027 using backend_t = backend<standalone_function_t, TestType>;
2028 auto code = read_wasm( std::string(wasm_directory) + "const.337.wasm");
2029 backend_t bkend( code, &wa );
2030
2031 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775808));
2032}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [255/338]

BACKEND_TEST_CASE ( "Testing wasm <const_338_wasm>" ,
"" [const_338_wasm_tests] )

Definition at line 2034 of file const_tests.cpp.

2034 {
2035 using backend_t = backend<standalone_function_t, TestType>;
2036 auto code = read_wasm( std::string(wasm_directory) + "const.338.wasm");
2037 backend_t bkend( code, &wa );
2038
2039 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1));
2040}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [256/338]

BACKEND_TEST_CASE ( "Testing wasm <const_339_wasm>" ,
"" [const_339_wasm_tests] )

Definition at line 2042 of file const_tests.cpp.

2042 {
2043 using backend_t = backend<standalone_function_t, TestType>;
2044 auto code = read_wasm( std::string(wasm_directory) + "const.339.wasm");
2045 backend_t bkend( code, &wa );
2046
2047 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775809));
2048}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [257/338]

BACKEND_TEST_CASE ( "Testing wasm <const_340_wasm>" ,
"" [const_340_wasm_tests] )

Definition at line 2057 of file const_tests.cpp.

2057 {
2058 using backend_t = backend<standalone_function_t, TestType>;
2059 auto code = read_wasm( std::string(wasm_directory) + "const.340.wasm");
2060 backend_t bkend( code, &wa );
2061
2062 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1));
2063}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [258/338]

BACKEND_TEST_CASE ( "Testing wasm <const_341_wasm>" ,
"" [const_341_wasm_tests] )

Definition at line 2065 of file const_tests.cpp.

2065 {
2066 using backend_t = backend<standalone_function_t, TestType>;
2067 auto code = read_wasm( std::string(wasm_directory) + "const.341.wasm");
2068 backend_t bkend( code, &wa );
2069
2070 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775809));
2071}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [259/338]

BACKEND_TEST_CASE ( "Testing wasm <const_342_wasm>" ,
"" [const_342_wasm_tests] )

Definition at line 2073 of file const_tests.cpp.

2073 {
2074 using backend_t = backend<standalone_function_t, TestType>;
2075 auto code = read_wasm( std::string(wasm_directory) + "const.342.wasm");
2076 backend_t bkend( code, &wa );
2077
2078 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1));
2079}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [260/338]

BACKEND_TEST_CASE ( "Testing wasm <const_343_wasm>" ,
"" [const_343_wasm_tests] )

Definition at line 2081 of file const_tests.cpp.

2081 {
2082 using backend_t = backend<standalone_function_t, TestType>;
2083 auto code = read_wasm( std::string(wasm_directory) + "const.343.wasm");
2084 backend_t bkend( code, &wa );
2085
2086 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775809));
2087}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [261/338]

BACKEND_TEST_CASE ( "Testing wasm <const_344_wasm>" ,
"" [const_344_wasm_tests] )

Definition at line 2089 of file const_tests.cpp.

2089 {
2090 using backend_t = backend<standalone_function_t, TestType>;
2091 auto code = read_wasm( std::string(wasm_directory) + "const.344.wasm");
2092 backend_t bkend( code, &wa );
2093
2094 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1));
2095}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [262/338]

BACKEND_TEST_CASE ( "Testing wasm <const_345_wasm>" ,
"" [const_345_wasm_tests] )

Definition at line 2097 of file const_tests.cpp.

2097 {
2098 using backend_t = backend<standalone_function_t, TestType>;
2099 auto code = read_wasm( std::string(wasm_directory) + "const.345.wasm");
2100 backend_t bkend( code, &wa );
2101
2102 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775809));
2103}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [263/338]

BACKEND_TEST_CASE ( "Testing wasm <const_346_wasm>" ,
"" [const_346_wasm_tests] )

Definition at line 2105 of file const_tests.cpp.

2105 {
2106 using backend_t = backend<standalone_function_t, TestType>;
2107 auto code = read_wasm( std::string(wasm_directory) + "const.346.wasm");
2108 backend_t bkend( code, &wa );
2109
2110 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(1));
2111}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [264/338]

BACKEND_TEST_CASE ( "Testing wasm <const_347_wasm>" ,
"" [const_347_wasm_tests] )

Definition at line 2113 of file const_tests.cpp.

2113 {
2114 using backend_t = backend<standalone_function_t, TestType>;
2115 auto code = read_wasm( std::string(wasm_directory) + "const.347.wasm");
2116 backend_t bkend( code, &wa );
2117
2118 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775809));
2119}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [265/338]

BACKEND_TEST_CASE ( "Testing wasm <const_348_wasm>" ,
"" [const_348_wasm_tests] )

Definition at line 2121 of file const_tests.cpp.

2121 {
2122 using backend_t = backend<standalone_function_t, TestType>;
2123 auto code = read_wasm( std::string(wasm_directory) + "const.348.wasm");
2124 backend_t bkend( code, &wa );
2125
2126 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2127}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [266/338]

BACKEND_TEST_CASE ( "Testing wasm <const_349_wasm>" ,
"" [const_349_wasm_tests] )

Definition at line 2129 of file const_tests.cpp.

2129 {
2130 using backend_t = backend<standalone_function_t, TestType>;
2131 auto code = read_wasm( std::string(wasm_directory) + "const.349.wasm");
2132 backend_t bkend( code, &wa );
2133
2134 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2135}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [267/338]

BACKEND_TEST_CASE ( "Testing wasm <const_34_wasm>" ,
"" [const_34_wasm_tests] )

Definition at line 2050 of file const_tests.cpp.

2050 {
2051 using backend_t = backend<standalone_function_t, TestType>;
2052 auto code = read_wasm( std::string(wasm_directory) + "const.34.wasm");
2053 backend_t bkend( code, &wa );
2054
2055}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [268/338]

BACKEND_TEST_CASE ( "Testing wasm <const_350_wasm>" ,
"" [const_350_wasm_tests] )

Definition at line 2144 of file const_tests.cpp.

2144 {
2145 using backend_t = backend<standalone_function_t, TestType>;
2146 auto code = read_wasm( std::string(wasm_directory) + "const.350.wasm");
2147 backend_t bkend( code, &wa );
2148
2149 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2150}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [269/338]

BACKEND_TEST_CASE ( "Testing wasm <const_351_wasm>" ,
"" [const_351_wasm_tests] )

Definition at line 2152 of file const_tests.cpp.

2152 {
2153 using backend_t = backend<standalone_function_t, TestType>;
2154 auto code = read_wasm( std::string(wasm_directory) + "const.351.wasm");
2155 backend_t bkend( code, &wa );
2156
2157 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2158}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [270/338]

BACKEND_TEST_CASE ( "Testing wasm <const_352_wasm>" ,
"" [const_352_wasm_tests] )

Definition at line 2160 of file const_tests.cpp.

2160 {
2161 using backend_t = backend<standalone_function_t, TestType>;
2162 auto code = read_wasm( std::string(wasm_directory) + "const.352.wasm");
2163 backend_t bkend( code, &wa );
2164
2165 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2166}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [271/338]

BACKEND_TEST_CASE ( "Testing wasm <const_353_wasm>" ,
"" [const_353_wasm_tests] )

Definition at line 2168 of file const_tests.cpp.

2168 {
2169 using backend_t = backend<standalone_function_t, TestType>;
2170 auto code = read_wasm( std::string(wasm_directory) + "const.353.wasm");
2171 backend_t bkend( code, &wa );
2172
2173 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2174}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [272/338]

BACKEND_TEST_CASE ( "Testing wasm <const_354_wasm>" ,
"" [const_354_wasm_tests] )

Definition at line 2176 of file const_tests.cpp.

2176 {
2177 using backend_t = backend<standalone_function_t, TestType>;
2178 auto code = read_wasm( std::string(wasm_directory) + "const.354.wasm");
2179 backend_t bkend( code, &wa );
2180
2181 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2182}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [273/338]

BACKEND_TEST_CASE ( "Testing wasm <const_355_wasm>" ,
"" [const_355_wasm_tests] )

Definition at line 2184 of file const_tests.cpp.

2184 {
2185 using backend_t = backend<standalone_function_t, TestType>;
2186 auto code = read_wasm( std::string(wasm_directory) + "const.355.wasm");
2187 backend_t bkend( code, &wa );
2188
2189 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2190}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [274/338]

BACKEND_TEST_CASE ( "Testing wasm <const_356_wasm>" ,
"" [const_356_wasm_tests] )

Definition at line 2192 of file const_tests.cpp.

2192 {
2193 using backend_t = backend<standalone_function_t, TestType>;
2194 auto code = read_wasm( std::string(wasm_directory) + "const.356.wasm");
2195 backend_t bkend( code, &wa );
2196
2197 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2198}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [275/338]

BACKEND_TEST_CASE ( "Testing wasm <const_357_wasm>" ,
"" [const_357_wasm_tests] )

Definition at line 2200 of file const_tests.cpp.

2200 {
2201 using backend_t = backend<standalone_function_t, TestType>;
2202 auto code = read_wasm( std::string(wasm_directory) + "const.357.wasm");
2203 backend_t bkend( code, &wa );
2204
2205 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2206}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [276/338]

BACKEND_TEST_CASE ( "Testing wasm <const_358_wasm>" ,
"" [const_358_wasm_tests] )

Definition at line 2208 of file const_tests.cpp.

2208 {
2209 using backend_t = backend<standalone_function_t, TestType>;
2210 auto code = read_wasm( std::string(wasm_directory) + "const.358.wasm");
2211 backend_t bkend( code, &wa );
2212
2213 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2214}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [277/338]

BACKEND_TEST_CASE ( "Testing wasm <const_359_wasm>" ,
"" [const_359_wasm_tests] )

Definition at line 2216 of file const_tests.cpp.

2216 {
2217 using backend_t = backend<standalone_function_t, TestType>;
2218 auto code = read_wasm( std::string(wasm_directory) + "const.359.wasm");
2219 backend_t bkend( code, &wa );
2220
2221 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2222}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [278/338]

BACKEND_TEST_CASE ( "Testing wasm <const_35_wasm>" ,
"" [const_35_wasm_tests] )

Definition at line 2137 of file const_tests.cpp.

2137 {
2138 using backend_t = backend<standalone_function_t, TestType>;
2139 auto code = read_wasm( std::string(wasm_directory) + "const.35.wasm");
2140 backend_t bkend( code, &wa );
2141
2142}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [279/338]

BACKEND_TEST_CASE ( "Testing wasm <const_360_wasm>" ,
"" [const_360_wasm_tests] )

Definition at line 2224 of file const_tests.cpp.

2224 {
2225 using backend_t = backend<standalone_function_t, TestType>;
2226 auto code = read_wasm( std::string(wasm_directory) + "const.360.wasm");
2227 backend_t bkend( code, &wa );
2228
2229 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(2));
2230}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [280/338]

BACKEND_TEST_CASE ( "Testing wasm <const_361_wasm>" ,
"" [const_361_wasm_tests] )

Definition at line 2232 of file const_tests.cpp.

2232 {
2233 using backend_t = backend<standalone_function_t, TestType>;
2234 auto code = read_wasm( std::string(wasm_directory) + "const.361.wasm");
2235 backend_t bkend( code, &wa );
2236
2237 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9223372036854775810));
2238}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [281/338]

BACKEND_TEST_CASE ( "Testing wasm <const_362_wasm>" ,
"" [const_362_wasm_tests] )

Definition at line 2240 of file const_tests.cpp.

2240 {
2241 using backend_t = backend<standalone_function_t, TestType>;
2242 auto code = read_wasm( std::string(wasm_directory) + "const.362.wasm");
2243 backend_t bkend( code, &wa );
2244
2245 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(4503599627370499));
2246}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [282/338]

BACKEND_TEST_CASE ( "Testing wasm <const_363_wasm>" ,
"" [const_363_wasm_tests] )

Definition at line 2248 of file const_tests.cpp.

2248 {
2249 using backend_t = backend<standalone_function_t, TestType>;
2250 auto code = read_wasm( std::string(wasm_directory) + "const.363.wasm");
2251 backend_t bkend( code, &wa );
2252
2253 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9227875636482146307));
2254}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [283/338]

BACKEND_TEST_CASE ( "Testing wasm <const_364_wasm>" ,
"" [const_364_wasm_tests] )

Definition at line 2256 of file const_tests.cpp.

2256 {
2257 using backend_t = backend<standalone_function_t, TestType>;
2258 auto code = read_wasm( std::string(wasm_directory) + "const.364.wasm");
2259 backend_t bkend( code, &wa );
2260
2261 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9218868437227405311));
2262}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [284/338]

BACKEND_TEST_CASE ( "Testing wasm <const_365_wasm>" ,
"" [const_365_wasm_tests] )

Definition at line 2264 of file const_tests.cpp.

2264 {
2265 using backend_t = backend<standalone_function_t, TestType>;
2266 auto code = read_wasm( std::string(wasm_directory) + "const.365.wasm");
2267 backend_t bkend( code, &wa );
2268
2269 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(18442240474082181119));
2270}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [285/338]

BACKEND_TEST_CASE ( "Testing wasm <const_366_wasm>" ,
"" [const_366_wasm_tests] )

Definition at line 2272 of file const_tests.cpp.

2272 {
2273 using backend_t = backend<standalone_function_t, TestType>;
2274 auto code = read_wasm( std::string(wasm_directory) + "const.366.wasm");
2275 backend_t bkend( code, &wa );
2276
2277 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(9218868437227405311));
2278}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [286/338]

BACKEND_TEST_CASE ( "Testing wasm <const_367_wasm>" ,
"" [const_367_wasm_tests] )

Definition at line 2280 of file const_tests.cpp.

2280 {
2281 using backend_t = backend<standalone_function_t, TestType>;
2282 auto code = read_wasm( std::string(wasm_directory) + "const.367.wasm");
2283 backend_t bkend( code, &wa );
2284
2285 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f")->to_f64()) == UINT64_C(18442240474082181119));
2286}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [287/338]

BACKEND_TEST_CASE ( "Testing wasm <const_38_wasm>" ,
"" [const_38_wasm_tests] )

Definition at line 2288 of file const_tests.cpp.

2288 {
2289 using backend_t = backend<standalone_function_t, TestType>;
2290 auto code = read_wasm( std::string(wasm_directory) + "const.38.wasm");
2291 backend_t bkend( code, &wa );
2292
2293}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [288/338]

BACKEND_TEST_CASE ( "Testing wasm <const_39_wasm>" ,
"" [const_39_wasm_tests] )

Definition at line 2295 of file const_tests.cpp.

2295 {
2296 using backend_t = backend<standalone_function_t, TestType>;
2297 auto code = read_wasm( std::string(wasm_directory) + "const.39.wasm");
2298 backend_t bkend( code, &wa );
2299
2300}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [289/338]

BACKEND_TEST_CASE ( "Testing wasm <const_40_wasm>" ,
"" [const_40_wasm_tests] )

Definition at line 2309 of file const_tests.cpp.

2309 {
2310 using backend_t = backend<standalone_function_t, TestType>;
2311 auto code = read_wasm( std::string(wasm_directory) + "const.40.wasm");
2312 backend_t bkend( code, &wa );
2313
2314}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [290/338]

BACKEND_TEST_CASE ( "Testing wasm <const_41_wasm>" ,
"" [const_41_wasm_tests] )

Definition at line 2316 of file const_tests.cpp.

2316 {
2317 using backend_t = backend<standalone_function_t, TestType>;
2318 auto code = read_wasm( std::string(wasm_directory) + "const.41.wasm");
2319 backend_t bkend( code, &wa );
2320
2321}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [291/338]

BACKEND_TEST_CASE ( "Testing wasm <const_42_wasm>" ,
"" [const_42_wasm_tests] )

Definition at line 2323 of file const_tests.cpp.

2323 {
2324 using backend_t = backend<standalone_function_t, TestType>;
2325 auto code = read_wasm( std::string(wasm_directory) + "const.42.wasm");
2326 backend_t bkend( code, &wa );
2327
2328}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [292/338]

BACKEND_TEST_CASE ( "Testing wasm <const_43_wasm>" ,
"" [const_43_wasm_tests] )

Definition at line 2330 of file const_tests.cpp.

2330 {
2331 using backend_t = backend<standalone_function_t, TestType>;
2332 auto code = read_wasm( std::string(wasm_directory) + "const.43.wasm");
2333 backend_t bkend( code, &wa );
2334
2335}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [293/338]

BACKEND_TEST_CASE ( "Testing wasm <const_44_wasm>" ,
"" [const_44_wasm_tests] )

Definition at line 2337 of file const_tests.cpp.

2337 {
2338 using backend_t = backend<standalone_function_t, TestType>;
2339 auto code = read_wasm( std::string(wasm_directory) + "const.44.wasm");
2340 backend_t bkend( code, &wa );
2341
2342}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [294/338]

BACKEND_TEST_CASE ( "Testing wasm <const_45_wasm>" ,
"" [const_45_wasm_tests] )

Definition at line 2344 of file const_tests.cpp.

2344 {
2345 using backend_t = backend<standalone_function_t, TestType>;
2346 auto code = read_wasm( std::string(wasm_directory) + "const.45.wasm");
2347 backend_t bkend( code, &wa );
2348
2349}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [295/338]

BACKEND_TEST_CASE ( "Testing wasm <const_4_wasm>" ,
"" [const_4_wasm_tests] )

Definition at line 2302 of file const_tests.cpp.

2302 {
2303 using backend_t = backend<standalone_function_t, TestType>;
2304 auto code = read_wasm( std::string(wasm_directory) + "const.4.wasm");
2305 backend_t bkend( code, &wa );
2306
2307}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [296/338]

BACKEND_TEST_CASE ( "Testing wasm <const_50_wasm>" ,
"" [const_50_wasm_tests] )

Definition at line 2358 of file const_tests.cpp.

2358 {
2359 using backend_t = backend<standalone_function_t, TestType>;
2360 auto code = read_wasm( std::string(wasm_directory) + "const.50.wasm");
2361 backend_t bkend( code, &wa );
2362
2363}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [297/338]

BACKEND_TEST_CASE ( "Testing wasm <const_51_wasm>" ,
"" [const_51_wasm_tests] )

Definition at line 2365 of file const_tests.cpp.

2365 {
2366 using backend_t = backend<standalone_function_t, TestType>;
2367 auto code = read_wasm( std::string(wasm_directory) + "const.51.wasm");
2368 backend_t bkend( code, &wa );
2369
2370}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [298/338]

BACKEND_TEST_CASE ( "Testing wasm <const_54_wasm>" ,
"" [const_54_wasm_tests] )

Definition at line 2372 of file const_tests.cpp.

2372 {
2373 using backend_t = backend<standalone_function_t, TestType>;
2374 auto code = read_wasm( std::string(wasm_directory) + "const.54.wasm");
2375 backend_t bkend( code, &wa );
2376
2377}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [299/338]

BACKEND_TEST_CASE ( "Testing wasm <const_55_wasm>" ,
"" [const_55_wasm_tests] )

Definition at line 2379 of file const_tests.cpp.

2379 {
2380 using backend_t = backend<standalone_function_t, TestType>;
2381 auto code = read_wasm( std::string(wasm_directory) + "const.55.wasm");
2382 backend_t bkend( code, &wa );
2383
2384}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [300/338]

BACKEND_TEST_CASE ( "Testing wasm <const_58_wasm>" ,
"" [const_58_wasm_tests] )

Definition at line 2386 of file const_tests.cpp.

2386 {
2387 using backend_t = backend<standalone_function_t, TestType>;
2388 auto code = read_wasm( std::string(wasm_directory) + "const.58.wasm");
2389 backend_t bkend( code, &wa );
2390
2391}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [301/338]

BACKEND_TEST_CASE ( "Testing wasm <const_59_wasm>" ,
"" [const_59_wasm_tests] )

Definition at line 2393 of file const_tests.cpp.

2393 {
2394 using backend_t = backend<standalone_function_t, TestType>;
2395 auto code = read_wasm( std::string(wasm_directory) + "const.59.wasm");
2396 backend_t bkend( code, &wa );
2397
2398}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [302/338]

BACKEND_TEST_CASE ( "Testing wasm <const_5_wasm>" ,
"" [const_5_wasm_tests] )

Definition at line 2351 of file const_tests.cpp.

2351 {
2352 using backend_t = backend<standalone_function_t, TestType>;
2353 auto code = read_wasm( std::string(wasm_directory) + "const.5.wasm");
2354 backend_t bkend( code, &wa );
2355
2356}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [303/338]

BACKEND_TEST_CASE ( "Testing wasm <const_60_wasm>" ,
"" [const_60_wasm_tests] )

Definition at line 2400 of file const_tests.cpp.

2400 {
2401 using backend_t = backend<standalone_function_t, TestType>;
2402 auto code = read_wasm( std::string(wasm_directory) + "const.60.wasm");
2403 backend_t bkend( code, &wa );
2404
2405}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [304/338]

BACKEND_TEST_CASE ( "Testing wasm <const_61_wasm>" ,
"" [const_61_wasm_tests] )

Definition at line 2407 of file const_tests.cpp.

2407 {
2408 using backend_t = backend<standalone_function_t, TestType>;
2409 auto code = read_wasm( std::string(wasm_directory) + "const.61.wasm");
2410 backend_t bkend( code, &wa );
2411
2412}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [305/338]

BACKEND_TEST_CASE ( "Testing wasm <const_68_wasm>" ,
"" [const_68_wasm_tests] )

Definition at line 2414 of file const_tests.cpp.

2414 {
2415 using backend_t = backend<standalone_function_t, TestType>;
2416 auto code = read_wasm( std::string(wasm_directory) + "const.68.wasm");
2417 backend_t bkend( code, &wa );
2418
2419 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922816));
2420}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [306/338]

BACKEND_TEST_CASE ( "Testing wasm <const_69_wasm>" ,
"" [const_69_wasm_tests] )

Definition at line 2422 of file const_tests.cpp.

2422 {
2423 using backend_t = backend<standalone_function_t, TestType>;
2424 auto code = read_wasm( std::string(wasm_directory) + "const.69.wasm");
2425 backend_t bkend( code, &wa );
2426
2427 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406464));
2428}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [307/338]

BACKEND_TEST_CASE ( "Testing wasm <const_70_wasm>" ,
"" [const_70_wasm_tests] )

Definition at line 2430 of file const_tests.cpp.

2430 {
2431 using backend_t = backend<standalone_function_t, TestType>;
2432 auto code = read_wasm( std::string(wasm_directory) + "const.70.wasm");
2433 backend_t bkend( code, &wa );
2434
2435 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
2436}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [308/338]

BACKEND_TEST_CASE ( "Testing wasm <const_71_wasm>" ,
"" [const_71_wasm_tests] )

Definition at line 2438 of file const_tests.cpp.

2438 {
2439 using backend_t = backend<standalone_function_t, TestType>;
2440 auto code = read_wasm( std::string(wasm_directory) + "const.71.wasm");
2441 backend_t bkend( code, &wa );
2442
2443 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
2444}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [309/338]

BACKEND_TEST_CASE ( "Testing wasm <const_72_wasm>" ,
"" [const_72_wasm_tests] )

Definition at line 2446 of file const_tests.cpp.

2446 {
2447 using backend_t = backend<standalone_function_t, TestType>;
2448 auto code = read_wasm( std::string(wasm_directory) + "const.72.wasm");
2449 backend_t bkend( code, &wa );
2450
2451 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
2452}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [310/338]

BACKEND_TEST_CASE ( "Testing wasm <const_73_wasm>" ,
"" [const_73_wasm_tests] )

Definition at line 2454 of file const_tests.cpp.

2454 {
2455 using backend_t = backend<standalone_function_t, TestType>;
2456 auto code = read_wasm( std::string(wasm_directory) + "const.73.wasm");
2457 backend_t bkend( code, &wa );
2458
2459 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
2460}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [311/338]

BACKEND_TEST_CASE ( "Testing wasm <const_74_wasm>" ,
"" [const_74_wasm_tests] )

Definition at line 2462 of file const_tests.cpp.

2462 {
2463 using backend_t = backend<standalone_function_t, TestType>;
2464 auto code = read_wasm( std::string(wasm_directory) + "const.74.wasm");
2465 backend_t bkend( code, &wa );
2466
2467 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
2468}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [312/338]

BACKEND_TEST_CASE ( "Testing wasm <const_75_wasm>" ,
"" [const_75_wasm_tests] )

Definition at line 2470 of file const_tests.cpp.

2470 {
2471 using backend_t = backend<standalone_function_t, TestType>;
2472 auto code = read_wasm( std::string(wasm_directory) + "const.75.wasm");
2473 backend_t bkend( code, &wa );
2474
2475 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
2476}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [313/338]

BACKEND_TEST_CASE ( "Testing wasm <const_76_wasm>" ,
"" [const_76_wasm_tests] )

Definition at line 2478 of file const_tests.cpp.

2478 {
2479 using backend_t = backend<standalone_function_t, TestType>;
2480 auto code = read_wasm( std::string(wasm_directory) + "const.76.wasm");
2481 backend_t bkend( code, &wa );
2482
2483 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
2484}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [314/338]

BACKEND_TEST_CASE ( "Testing wasm <const_77_wasm>" ,
"" [const_77_wasm_tests] )

Definition at line 2486 of file const_tests.cpp.

2486 {
2487 using backend_t = backend<standalone_function_t, TestType>;
2488 auto code = read_wasm( std::string(wasm_directory) + "const.77.wasm");
2489 backend_t bkend( code, &wa );
2490
2491 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
2492}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [315/338]

BACKEND_TEST_CASE ( "Testing wasm <const_78_wasm>" ,
"" [const_78_wasm_tests] )

Definition at line 2494 of file const_tests.cpp.

2494 {
2495 using backend_t = backend<standalone_function_t, TestType>;
2496 auto code = read_wasm( std::string(wasm_directory) + "const.78.wasm");
2497 backend_t bkend( code, &wa );
2498
2499 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
2500}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [316/338]

BACKEND_TEST_CASE ( "Testing wasm <const_79_wasm>" ,
"" [const_79_wasm_tests] )

Definition at line 2502 of file const_tests.cpp.

2502 {
2503 using backend_t = backend<standalone_function_t, TestType>;
2504 auto code = read_wasm( std::string(wasm_directory) + "const.79.wasm");
2505 backend_t bkend( code, &wa );
2506
2507 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
2508}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [317/338]

BACKEND_TEST_CASE ( "Testing wasm <const_80_wasm>" ,
"" [const_80_wasm_tests] )

Definition at line 2517 of file const_tests.cpp.

2517 {
2518 using backend_t = backend<standalone_function_t, TestType>;
2519 auto code = read_wasm( std::string(wasm_directory) + "const.80.wasm");
2520 backend_t bkend( code, &wa );
2521
2522 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2523}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [318/338]

BACKEND_TEST_CASE ( "Testing wasm <const_81_wasm>" ,
"" [const_81_wasm_tests] )

Definition at line 2525 of file const_tests.cpp.

2525 {
2526 using backend_t = backend<standalone_function_t, TestType>;
2527 auto code = read_wasm( std::string(wasm_directory) + "const.81.wasm");
2528 backend_t bkend( code, &wa );
2529
2530 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2531}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [319/338]

BACKEND_TEST_CASE ( "Testing wasm <const_82_wasm>" ,
"" [const_82_wasm_tests] )

Definition at line 2533 of file const_tests.cpp.

2533 {
2534 using backend_t = backend<standalone_function_t, TestType>;
2535 auto code = read_wasm( std::string(wasm_directory) + "const.82.wasm");
2536 backend_t bkend( code, &wa );
2537
2538 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2539}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [320/338]

BACKEND_TEST_CASE ( "Testing wasm <const_83_wasm>" ,
"" [const_83_wasm_tests] )

Definition at line 2541 of file const_tests.cpp.

2541 {
2542 using backend_t = backend<standalone_function_t, TestType>;
2543 auto code = read_wasm( std::string(wasm_directory) + "const.83.wasm");
2544 backend_t bkend( code, &wa );
2545
2546 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2547}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [321/338]

BACKEND_TEST_CASE ( "Testing wasm <const_84_wasm>" ,
"" [const_84_wasm_tests] )

Definition at line 2549 of file const_tests.cpp.

2549 {
2550 using backend_t = backend<standalone_function_t, TestType>;
2551 auto code = read_wasm( std::string(wasm_directory) + "const.84.wasm");
2552 backend_t bkend( code, &wa );
2553
2554 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2555}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [322/338]

BACKEND_TEST_CASE ( "Testing wasm <const_85_wasm>" ,
"" [const_85_wasm_tests] )

Definition at line 2557 of file const_tests.cpp.

2557 {
2558 using backend_t = backend<standalone_function_t, TestType>;
2559 auto code = read_wasm( std::string(wasm_directory) + "const.85.wasm");
2560 backend_t bkend( code, &wa );
2561
2562 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2563}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [323/338]

BACKEND_TEST_CASE ( "Testing wasm <const_86_wasm>" ,
"" [const_86_wasm_tests] )

Definition at line 2565 of file const_tests.cpp.

2565 {
2566 using backend_t = backend<standalone_function_t, TestType>;
2567 auto code = read_wasm( std::string(wasm_directory) + "const.86.wasm");
2568 backend_t bkend( code, &wa );
2569
2570 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2571}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [324/338]

BACKEND_TEST_CASE ( "Testing wasm <const_87_wasm>" ,
"" [const_87_wasm_tests] )

Definition at line 2573 of file const_tests.cpp.

2573 {
2574 using backend_t = backend<standalone_function_t, TestType>;
2575 auto code = read_wasm( std::string(wasm_directory) + "const.87.wasm");
2576 backend_t bkend( code, &wa );
2577
2578 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2579}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [325/338]

BACKEND_TEST_CASE ( "Testing wasm <const_88_wasm>" ,
"" [const_88_wasm_tests] )

Definition at line 2581 of file const_tests.cpp.

2581 {
2582 using backend_t = backend<standalone_function_t, TestType>;
2583 auto code = read_wasm( std::string(wasm_directory) + "const.88.wasm");
2584 backend_t bkend( code, &wa );
2585
2586 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2587}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [326/338]

BACKEND_TEST_CASE ( "Testing wasm <const_89_wasm>" ,
"" [const_89_wasm_tests] )

Definition at line 2589 of file const_tests.cpp.

2589 {
2590 using backend_t = backend<standalone_function_t, TestType>;
2591 auto code = read_wasm( std::string(wasm_directory) + "const.89.wasm");
2592 backend_t bkend( code, &wa );
2593
2594 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2595}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [327/338]

BACKEND_TEST_CASE ( "Testing wasm <const_8_wasm>" ,
"" [const_8_wasm_tests] )

Definition at line 2510 of file const_tests.cpp.

2510 {
2511 using backend_t = backend<standalone_function_t, TestType>;
2512 auto code = read_wasm( std::string(wasm_directory) + "const.8.wasm");
2513 backend_t bkend( code, &wa );
2514
2515}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [328/338]

BACKEND_TEST_CASE ( "Testing wasm <const_90_wasm>" ,
"" [const_90_wasm_tests] )

Definition at line 2604 of file const_tests.cpp.

2604 {
2605 using backend_t = backend<standalone_function_t, TestType>;
2606 auto code = read_wasm( std::string(wasm_directory) + "const.90.wasm");
2607 backend_t bkend( code, &wa );
2608
2609 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2610}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [329/338]

BACKEND_TEST_CASE ( "Testing wasm <const_91_wasm>" ,
"" [const_91_wasm_tests] )

Definition at line 2612 of file const_tests.cpp.

2612 {
2613 using backend_t = backend<standalone_function_t, TestType>;
2614 auto code = read_wasm( std::string(wasm_directory) + "const.91.wasm");
2615 backend_t bkend( code, &wa );
2616
2617 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2618}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [330/338]

BACKEND_TEST_CASE ( "Testing wasm <const_92_wasm>" ,
"" [const_92_wasm_tests] )

Definition at line 2620 of file const_tests.cpp.

2620 {
2621 using backend_t = backend<standalone_function_t, TestType>;
2622 auto code = read_wasm( std::string(wasm_directory) + "const.92.wasm");
2623 backend_t bkend( code, &wa );
2624
2625 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922818));
2626}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [331/338]

BACKEND_TEST_CASE ( "Testing wasm <const_93_wasm>" ,
"" [const_93_wasm_tests] )

Definition at line 2628 of file const_tests.cpp.

2628 {
2629 using backend_t = backend<standalone_function_t, TestType>;
2630 auto code = read_wasm( std::string(wasm_directory) + "const.93.wasm");
2631 backend_t bkend( code, &wa );
2632
2633 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406466));
2634}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [332/338]

BACKEND_TEST_CASE ( "Testing wasm <const_94_wasm>" ,
"" [const_94_wasm_tests] )

Definition at line 2636 of file const_tests.cpp.

2636 {
2637 using backend_t = backend<standalone_function_t, TestType>;
2638 auto code = read_wasm( std::string(wasm_directory) + "const.94.wasm");
2639 backend_t bkend( code, &wa );
2640
2641 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922819));
2642}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [333/338]

BACKEND_TEST_CASE ( "Testing wasm <const_95_wasm>" ,
"" [const_95_wasm_tests] )

Definition at line 2644 of file const_tests.cpp.

2644 {
2645 using backend_t = backend<standalone_function_t, TestType>;
2646 auto code = read_wasm( std::string(wasm_directory) + "const.95.wasm");
2647 backend_t bkend( code, &wa );
2648
2649 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406467));
2650}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [334/338]

BACKEND_TEST_CASE ( "Testing wasm <const_96_wasm>" ,
"" [const_96_wasm_tests] )

Definition at line 2652 of file const_tests.cpp.

2652 {
2653 using backend_t = backend<standalone_function_t, TestType>;
2654 auto code = read_wasm( std::string(wasm_directory) + "const.96.wasm");
2655 backend_t bkend( code, &wa );
2656
2657 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922816));
2658}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [335/338]

BACKEND_TEST_CASE ( "Testing wasm <const_97_wasm>" ,
"" [const_97_wasm_tests] )

Definition at line 2660 of file const_tests.cpp.

2660 {
2661 using backend_t = backend<standalone_function_t, TestType>;
2662 auto code = read_wasm( std::string(wasm_directory) + "const.97.wasm");
2663 backend_t bkend( code, &wa );
2664
2665 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406464));
2666}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [336/338]

BACKEND_TEST_CASE ( "Testing wasm <const_98_wasm>" ,
"" [const_98_wasm_tests] )

Definition at line 2668 of file const_tests.cpp.

2668 {
2669 using backend_t = backend<standalone_function_t, TestType>;
2670 auto code = read_wasm( std::string(wasm_directory) + "const.98.wasm");
2671 backend_t bkend( code, &wa );
2672
2673 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(645922817));
2674}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [337/338]

BACKEND_TEST_CASE ( "Testing wasm <const_99_wasm>" ,
"" [const_99_wasm_tests] )

Definition at line 2676 of file const_tests.cpp.

2676 {
2677 using backend_t = backend<standalone_function_t, TestType>;
2678 auto code = read_wasm( std::string(wasm_directory) + "const.99.wasm");
2679 backend_t bkend( code, &wa );
2680
2681 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f")->to_f32()) == UINT32_C(2793406465));
2682}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [338/338]

BACKEND_TEST_CASE ( "Testing wasm <const_9_wasm>" ,
"" [const_9_wasm_tests] )

Definition at line 2597 of file const_tests.cpp.

2597 {
2598 using backend_t = backend<standalone_function_t, TestType>;
2599 auto code = read_wasm( std::string(wasm_directory) + "const.9.wasm");
2600 backend_t bkend( code, &wa );
2601
2602}
Here is the call graph for this function:

Variable Documentation

◆ wa

wasm_allocator wa
extern

Definition at line 10 of file main.cpp.