test(plugins): assert host-call outputs to preserve devirtualized bin…

…dings Replacing the concrete dynamic_cast host-function lookups with getHostFunc() dropped the only check that each export was wired to the correct, same-signature host function: a call that copies bytes into memory or returns a scalar still reports ErrNo::Success when mis-bound. Read the written output back or pin a distinguishing value so every export binding stays observable. wasmedge_ffmpeg name and scalar readbacks: - avPixfmt: av_color_range_name (pc), av_color_transfer_name (smpte170m), av_color_space_name / av_color_primaries_name (bt709), av_pix_format_name (yuv420p). - avCodec: avcodec_get_name (h264) and avcodec_get_long_name. - avSampleFmt: av_get_sample_fmt_name (u8). - avInputFormat: name (mov,mp4,...) and long_name (QuickTime / MOV). - avfilter: avfilter_name (abuffer), description, pad_get_name. - avDictionary: av_dict_get_key_value copies KEY/VALUE; read both back. - avError: av_strerror ran with no arguments; pass the real buffer and assert. - av_log_get_flags ran with a stray argument; call the setter with an empty result span and the getter with none, then assert the flag. - utils: initEmptyFrame asserts the av_frame_alloc run() result. wasmedge_ffmpeg version, configuration/license, and codec-kind sweep: - version exports (avutil, avcodec, avformat, avfilter, swresample, swscale): assert the major-version byte (>> 16) is nonzero, so a swap with a configuration/license length getter no longer passes. - configuration/license copiers (all six modules): read back the buffer and require the configure-flag marker "--" to be present for configuration and absent for license, distinguishing the pair on both sides. - avformatContext duration: replace the tautological check with the sample asset's exact duration. - avcodec find_decoder_by_name / find_encoder_by_name: confirm the returned codec kind via av_codec_is_decoder / av_codec_is_encoder. wasmedge_process: - GetStdErr compares the StdErr buffer instead of the empty StdOut. - GetExitCode seeds a nonzero Env.ExitCode and asserts it. Assisted-by: Claude (Anthropic) Signed-off-by: hydai <z54981220@gmail.com>
0yi0 · Jun 26, 2026 · Jun 11, 2026 · Jun 12, 2026 · Jun 12, 2026 · Jun 12, 2026
commit cf526fa01383ec51f09b9ca3b92b2131638cee87
diff --git a/test/plugins/wasmedge_ffmpeg/avcodec/avCodec.cpp b/test/plugins/wasmedge_ffmpeg/avcodec/avCodec.cpp
@@ -121,6 +121,9 @@ TEST_F(FFmpegTest, AVCodec) {
                                        AVCodecId, StringPtr, Length},
                                    Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+    EXPECT_EQ(std::string_view(MemInst->getPointer<char *>(StringPtr),
+                               static_cast<size_t>(Length)),
+              "h264"sv);
   }
 
   FuncInst = AVCodecMod->findFuncExports(
@@ -154,6 +157,9 @@ TEST_F(FFmpegTest, AVCodec) {
                                                     Length},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+    EXPECT_EQ(std::string_view(MemInst->getPointer<char *>(StringPtr),
+                               static_cast<size_t>(Length)),
+              "H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"sv);
   }
 
   FuncInst =

diff --git a/test/plugins/wasmedge_ffmpeg/avcodec/avCodecCtx.cpp b/test/plugins/wasmedge_ffmpeg/avcodec/avCodecCtx.cpp
@@ -1293,7 +1293,7 @@ TEST_F(FFmpegTest, AVCodecCtx) {
     EXPECT_TRUE(HostFuncAVCodecCtxColorTrc.run(
         CallFrame, std::initializer_list<WasmEdge::ValVariant>{AVCodecCtxId},
         Result));
-    ASSERT_TRUE(Result[0].get<int32_t>() > 0);
+    EXPECT_EQ(Result[0].get<int32_t>(), 2);
   }
 
   FuncInst = AVCodecMod->findFuncExports(

diff --git a/test/plugins/wasmedge_ffmpeg/avcodec/avPacket.cpp b/test/plugins/wasmedge_ffmpeg/avcodec/avPacket.cpp
@@ -45,6 +45,20 @@ TEST_F(FFmpegTest, AVPacketTest) {
   ASSERT_TRUE(PacketId > 0);
   ASSERT_TRUE(PacketId2 > 0);
 
+  uint32_t PacketDataSize = 0;
+  FuncInst =
+      AVCodecMod->findFuncExports("wasmedge_ffmpeg_avcodec_av_packet_size");
+  ASSERT_NE(FuncInst, nullptr);
+  ASSERT_TRUE(FuncInst->isHostFunction());
+  auto &HostFuncAVPacketSize = FuncInst->getHostFunc();
+  auto ExpectPacketSize = [&](uint32_t ExpectedSize) {
+    EXPECT_TRUE(HostFuncAVPacketSize.run(
+        CallFrame, std::initializer_list<WasmEdge::ValVariant>{PacketId},
+        Result));
+    PacketDataSize = static_cast<uint32_t>(Result[0].get<int32_t>());
+    EXPECT_EQ(PacketDataSize, ExpectedSize);
+  };
+
   FuncInst =
       AVCodecMod->findFuncExports("wasmedge_ffmpeg_avcodec_av_new_packet");
   ASSERT_NE(FuncInst, nullptr);
@@ -58,6 +72,7 @@ TEST_F(FFmpegTest, AVPacketTest) {
         CallFrame, std::initializer_list<WasmEdge::ValVariant>{PacketId, Size},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), 0);
+    ExpectPacketSize(Size);
   }
 
   FuncInst =
@@ -72,6 +87,7 @@ TEST_F(FFmpegTest, AVPacketTest) {
         CallFrame, std::initializer_list<WasmEdge::ValVariant>{PacketId, Size},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), 0);
+    ExpectPacketSize(80);
   }
 
   FuncInst =
@@ -86,6 +102,7 @@ TEST_F(FFmpegTest, AVPacketTest) {
         CallFrame, std::initializer_list<WasmEdge::ValVariant>{PacketId, Size},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), 0);
+    ExpectPacketSize(Size);
   }
 
   uint32_t StreamIdx = 3;
@@ -116,21 +133,6 @@ TEST_F(FFmpegTest, AVPacketTest) {
     EXPECT_EQ(Result[0].get<int32_t>(), StreamIdx);
   }
 
-  uint32_t Size = 0;
-  FuncInst =
-      AVCodecMod->findFuncExports("wasmedge_ffmpeg_avcodec_av_packet_size");
-  ASSERT_NE(FuncInst, nullptr);
-  ASSERT_TRUE(FuncInst->isHostFunction());
-  auto &HostFuncAVPacketSize = FuncInst->getHostFunc();
-
-  {
-    EXPECT_TRUE(HostFuncAVPacketSize.run(
-        CallFrame, std::initializer_list<WasmEdge::ValVariant>{PacketId},
-        Result));
-    Size = Result[0].get<int32_t>();
-    EXPECT_TRUE(Size > 0);
-  }
-
   uint32_t Flags = 5;
 
   FuncInst = AVCodecMod->findFuncExports(
@@ -290,7 +292,8 @@ TEST_F(FFmpegTest, AVPacketTest) {
   {
     EXPECT_TRUE(HostFuncAVPacketData.run(
         CallFrame,
-        std::initializer_list<WasmEdge::ValVariant>{PacketId, DataPtr, Size},
+        std::initializer_list<WasmEdge::ValVariant>{PacketId, DataPtr,
+                                                    PacketDataSize},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
   }

diff --git a/test/plugins/wasmedge_ffmpeg/avcodec/avcodec_func.cpp b/test/plugins/wasmedge_ffmpeg/avcodec/avcodec_func.cpp
@@ -209,6 +209,12 @@ TEST_F(FFmpegTest, AVCodecFunc) {
                                                     CodecNamePtr, Length},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+
+    uint32_t DecoderByNameId = readUInt32(MemInst, CodecDecoderPtr);
+    EXPECT_TRUE(HostFuncAVCodecIsDecoder.run(
+        CallFrame, std::initializer_list<WasmEdge::ValVariant>{DecoderByNameId},
+        Result));
+    EXPECT_EQ(Result[0].get<int32_t>(), 1);
   }
 
   FuncInst = AVCodecMod->findFuncExports(
@@ -227,6 +233,12 @@ TEST_F(FFmpegTest, AVCodecFunc) {
                                                     CodecNamePtr, Length},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+
+    uint32_t EncoderByNameId = readUInt32(MemInst, CodecEncoderPtr);
+    EXPECT_TRUE(HostFuncAVCodecIsEncoder.run(
+        CallFrame, std::initializer_list<WasmEdge::ValVariant>{EncoderByNameId},
+        Result));
+    EXPECT_EQ(Result[0].get<int32_t>(), 1);
   }
 
   FuncInst = AVCodecMod->findFuncExports(
@@ -273,7 +285,7 @@ TEST_F(FFmpegTest, AVCodecFunc) {
   {
     EXPECT_TRUE(HostFuncAVCodecVersion.run(
         CallFrame, std::initializer_list<WasmEdge::ValVariant>{}, Result));
-    EXPECT_TRUE(Result[0].get<int32_t>() > 0);
+    EXPECT_TRUE((Result[0].get<int32_t>() >> 16) > 0);
   }
 
   FuncInst = AVCodecMod->findFuncExports(
@@ -305,6 +317,10 @@ TEST_F(FFmpegTest, AVCodecFunc) {
         CallFrame, std::initializer_list<WasmEdge::ValVariant>{StrPtr, Length},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+    EXPECT_NE(std::string_view(MemInst->getPointer<char *>(StrPtr),
+                               static_cast<size_t>(Length))
+                  .find("--"),
+              std::string_view::npos);
   }
 
   FuncInst = AVCodecMod->findFuncExports(
@@ -336,6 +352,10 @@ TEST_F(FFmpegTest, AVCodecFunc) {
         CallFrame, std::initializer_list<WasmEdge::ValVariant>{StrPtr, Length},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+    EXPECT_EQ(std::string_view(MemInst->getPointer<char *>(StrPtr),
+                               static_cast<size_t>(Length))
+                  .find("--"),
+              std::string_view::npos);
   }
 
   FuncInst = AVCodecMod->findFuncExports(

diff --git a/test/plugins/wasmedge_ffmpeg/avfilter/avfilter.cpp b/test/plugins/wasmedge_ffmpeg/avfilter/avfilter.cpp
@@ -14,6 +14,7 @@ namespace Host {
 namespace WasmEdgeFFmpeg {
 
 TEST_F(FFmpegTest, AVFilterStructs) {
+  using namespace std::literals::string_view_literals;
   ASSERT_TRUE(AVFilterMod != nullptr);
 
   uint32_t FilterPtr = UINT32_C(8);
@@ -82,6 +83,9 @@ TEST_F(FFmpegTest, AVFilterStructs) {
         std::initializer_list<WasmEdge::ValVariant>{FilterId, StrPtr, Length},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+    EXPECT_EQ(std::string_view(MemInst->getPointer<char *>(StrPtr),
+                               static_cast<size_t>(Length)),
+              "abuffer"sv);
   }
 
   FuncInst = AVFilterMod->findFuncExports(
@@ -114,6 +118,10 @@ TEST_F(FFmpegTest, AVFilterStructs) {
         std::initializer_list<WasmEdge::ValVariant>{FilterId, StrPtr, Length},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+    EXPECT_EQ(std::string_view(MemInst->getPointer<char *>(StrPtr),
+                               static_cast<size_t>(Length)),
+              "Buffer audio frames, and make them accessible to the "
+              "filterchain."sv);
   }
 
   FuncInst = AVFilterMod->findFuncExports(
@@ -166,12 +174,14 @@ TEST_F(FFmpegTest, AVFilterStructs) {
   auto &HostFuncAVFilterGetInputsFilterPad = FuncInst->getHostFunc();
 
   {
+    writeUInt32(MemInst, UINT32_C(0), InputFilterPadPtr);
     EXPECT_TRUE(HostFuncAVFilterGetInputsFilterPad.run(
         CallFrame,
         std::initializer_list<WasmEdge::ValVariant>{FilterId,
                                                     InputFilterPadPtr},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+    EXPECT_EQ(readUInt32(MemInst, InputFilterPadPtr), UINT32_C(0));
   }
 
   FuncInst = AVFilterMod->findFuncExports(
@@ -224,6 +234,9 @@ TEST_F(FFmpegTest, AVFilterStructs) {
                                                     StrPtr, Length},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+    EXPECT_EQ(std::string_view(MemInst->getPointer<char *>(StrPtr),
+                               static_cast<size_t>(Length)),
+              "default"sv);
   }
 
   FuncInst = AVFilterMod->findFuncExports(

diff --git a/test/plugins/wasmedge_ffmpeg/avfilter/avfilter_func.cpp b/test/plugins/wasmedge_ffmpeg/avfilter/avfilter_func.cpp
@@ -384,7 +384,7 @@ TEST_F(FFmpegTest, AVFilterFunc) {
   {
     EXPECT_TRUE(HostFuncAVFilterVersion.run(
         CallFrame, std::initializer_list<WasmEdge::ValVariant>{}, Result));
-    ASSERT_TRUE(Result[0].get<int32_t>() > 0);
+    ASSERT_TRUE((Result[0].get<int32_t>() >> 16) > 0);
   }
 
   FuncInst = AVFilterMod->findFuncExports(
@@ -414,6 +414,10 @@ TEST_F(FFmpegTest, AVFilterFunc) {
         CallFrame, std::initializer_list<WasmEdge::ValVariant>{StrPtr, Length},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+    EXPECT_NE(std::string_view(MemInst->getPointer<char *>(StrPtr),
+                               static_cast<size_t>(Length))
+                  .find("--"),
+              std::string_view::npos);
   }
 
   FuncInst = AVFilterMod->findFuncExports(
@@ -442,6 +446,10 @@ TEST_F(FFmpegTest, AVFilterFunc) {
         CallFrame, std::initializer_list<WasmEdge::ValVariant>{StrPtr, Length},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+    EXPECT_EQ(std::string_view(MemInst->getPointer<char *>(StrPtr),
+                               static_cast<size_t>(Length))
+                  .find("--"),
+              std::string_view::npos);
   }
 
   // ==================================================================

diff --git a/test/plugins/wasmedge_ffmpeg/avformat/avInputOutputContext.cpp b/test/plugins/wasmedge_ffmpeg/avformat/avInputOutputContext.cpp
@@ -14,6 +14,7 @@ namespace Host {
 namespace WasmEdgeFFmpeg {
 
 TEST_F(FFmpegTest, AVInputFormat) {
+  using namespace std::literals::string_view_literals;
   std::string FileName = "ffmpeg-assets/sample_video.mp4"; // 32 chars
   uint32_t FormatCtxPtr = UINT32_C(24);
   uint32_t InputFormatPtr = UINT32_C(28);
@@ -78,6 +79,9 @@ TEST_F(FFmpegTest, AVInputFormat) {
                                                     Length},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+    EXPECT_EQ(std::string_view(MemInst->getPointer<char *>(StrBuf),
+                               static_cast<size_t>(Length)),
+              "mov,mp4,m4a,3gp,3g2,mj2"sv);
   }
 
   FuncInst = AVFormatMod->findFuncExports(
@@ -109,6 +113,9 @@ TEST_F(FFmpegTest, AVInputFormat) {
         Result));
 
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
+    EXPECT_EQ(std::string_view(MemInst->getPointer<char *>(StrBuf),
+                               static_cast<size_t>(Length)),
+              "QuickTime / MOV"sv);
   }
 
   FuncInst = AVFormatMod->findFuncExports(

diff --git a/test/plugins/wasmedge_ffmpeg/avformat/avformatContext.cpp b/test/plugins/wasmedge_ffmpeg/avformat/avformatContext.cpp
@@ -92,7 +92,7 @@ TEST_F(FFmpegTest, AVFormatContextStruct) {
     EXPECT_TRUE(HostFuncAVFormatCtxDuration.run(
         CallFrame, std::initializer_list<WasmEdge::ValVariant>{FormatCtxId},
         Result));
-    EXPECT_TRUE(Result[0].get<int64_t>() >= 0 || Result[0].get<int64_t>() < 0);
+    EXPECT_EQ(Result[0].get<int64_t>(), INT64_C(2000000));
   }
 
   FuncInst = AVFormatMod->findFuncExports(

diff --git a/test/plugins/wasmedge_ffmpeg/avformat/avformat_func.cpp b/test/plugins/wasmedge_ffmpeg/avformat/avformat_func.cpp
@@ -243,7 +243,7 @@ TEST_F(FFmpegTest, AVInputFormatFunc) {
     EXPECT_TRUE(HostFuncAVFormatVersion.run(
         CallFrame, std::initializer_list<WasmEdge::ValVariant>{}, Result));
 
-    EXPECT_TRUE(Result[0].get<int32_t>() >= 0);
+    EXPECT_TRUE((Result[0].get<int32_t>() >> 16) > 0);
   }
 
   FuncInst = AVFormatMod->findFuncExports(
@@ -274,6 +274,10 @@ TEST_F(FFmpegTest, AVInputFormatFunc) {
         Result));
 
     EXPECT_TRUE(Result[0].get<int32_t>() >= 0);
+    EXPECT_NE(std::string_view(MemInst->getPointer<char *>(StrPtr),
+                               static_cast<size_t>(Length))
+                  .find("--"),
+              std::string_view::npos);
   }
 
   FuncInst = AVFormatMod->findFuncExports(
@@ -304,6 +308,10 @@ TEST_F(FFmpegTest, AVInputFormatFunc) {
         Result));
 
     EXPECT_TRUE(Result[0].get<int32_t>() >= 0);
+    EXPECT_EQ(std::string_view(MemInst->getPointer<char *>(StrPtr),
+                               static_cast<size_t>(Length))
+                  .find("--"),
+              std::string_view::npos);
   }
 }
 

diff --git a/test/plugins/wasmedge_ffmpeg/avutil/avDictionary.cpp b/test/plugins/wasmedge_ffmpeg/avutil/avDictionary.cpp
@@ -114,7 +114,12 @@ TEST_F(FFmpegTest, AVDictionary) {
             UINT32_C(3), PrevDictEntryIdx, Flags},
         Result));
     EXPECT_EQ(Result[0].get<int32_t>(), 1);
-    // Verify String. Read String from MemInst
+    EXPECT_EQ(std::string_view(MemInst->getPointer<char *>(KeyBufPtr),
+                               static_cast<size_t>(KeyLen)),
+              "KEY"sv);
+    EXPECT_EQ(std::string_view(MemInst->getPointer<char *>(ValueBufPtr),
+                               static_cast<size_t>(ValueLen)),
+              "VALUE"sv);
 
     // Pass a Null Dict and testing.
     EXPECT_TRUE(HostFuncAVDictGetKeyValue.run(

diff --git a/test/plugins/wasmedge_ffmpeg/avutil/avError.cpp b/test/plugins/wasmedge_ffmpeg/avutil/avError.cpp
@@ -29,10 +29,11 @@ TEST_F(FFmpegTest, AVError) {
   auto &HostFuncAVUtilAVStrError = FuncInst->getHostFunc();
 
   {
-    HostFuncAVUtilAVStrError.run(
-        CallFrame, std::initializer_list<WasmEdge::ValVariant>{}, Result);
-
-    EXPECT_EQ(Result[0].get<int32_t>(), 0);
+    EXPECT_TRUE(HostFuncAVUtilAVStrError.run(
+        CallFrame,
+        std::initializer_list<WasmEdge::ValVariant>{ErrNum, ErrStartPtr,
+                                                    ErrSize},
+        Result));
   }
 
   FuncInst = AVUtilMod->findFuncExports("wasmedge_ffmpeg_avutil_AVERROR");

diff --git a/test/plugins/wasmedge_ffmpeg/avutil/avFrame.cpp b/test/plugins/wasmedge_ffmpeg/avutil/avFrame.cpp
@@ -36,12 +36,13 @@ TEST_F(FFmpegTest, AVFrame) {
   ASSERT_TRUE(FuncInst->isHostFunction());
   auto &HostFuncAVFrameAlloc = FuncInst->getHostFunc();
 
-  uint32_t EmptyFramePtr = UINT32_C(64);
+  uint32_t EmptyFramePtr = UINT32_C(88);
 
   {
-    HostFuncAVFrameAlloc.run(
+    writeUInt32(MemInst, UINT32_C(0), EmptyFramePtr);
+    EXPECT_TRUE(HostFuncAVFrameAlloc.run(
         CallFrame, std::initializer_list<WasmEdge::ValVariant>{EmptyFramePtr},
-        Result);
+        Result));
 
     EXPECT_EQ(Result[0].get<int32_t>(), static_cast<int32_t>(ErrNo::Success));
     EXPECT_TRUE(readUInt32(MemInst, EmptyFramePtr) > 0);