Function TEST

test/executor/ExecutorRegressionTest.cpp:530–788

Regression test for ref.test on externalized nullable references. The bug: runRefTestOp always created non-nullable types for externalized references (TypeCode::Ref), discarding the original nullability info. The fix preserves nullability by checking isNullableRefType(). This test exercises the externalized reference code path in ref.test via the extern.convert_any + ref.test pattern, verifying

/// both nullable and non-nullable ref.test targets, as well as null and
/// non-null input values.
TEST(ExecutorRegression, RefTestNullAbility) {
  WasmEdge::Configure Conf;
  WasmEdge::VM::VM VM(Conf);

  ASSERT_TRUE(VM.loadWasm(RefTestNullabilityWasm));
  ASSERT_TRUE(VM.validate());
  ASSERT_TRUE(VM.instantiate());

  // --- Part 1: Non-null anyref input ---
  //
  // When a non-null anyref is externalized via extern.convert_any, the
  // externalized flag is set on the value. The ref.test instruction must
  // correctly handle this externalized type when matching against both
  // nullable and non-nullable extern targets.
  //
  // Note: The runtime parameter-pushing code converts non-null nullable refs
  // to non-nullable before execution. So the externalized type at ref.test
  // time will be non-nullable. Both ref.test targets should succeed.
  {
    int DummyObj = 42;
    RefVariant AnyRefVal(ValType(TypeCode::RefNull, TypeCode::AnyRef),
                         reinterpret_cast<void *>(&DummyObj));

    std::vector<ValVariant> Params = {ValVariant(AnyRefVal)};
    std::vector<ValType> ParamTypes = {ValType(TypeCode::AnyRef)};

    // Test 1: extern.convert_any + ref.test (ref null extern)
    // Non-null externalized ref with non-nullable type should match
    // nullable extern target.
    {
      auto Result = VM.execute("test_nullable", Params, ParamTypes);
      ASSERT_TRUE(Result);
      ASSERT_EQ((*Result).size(), 1U);
      EXPECT_EQ((*Result)[0].first.get<uint32_t>(), 1U)
          << "Non-null externalized anyref should match (ref null extern)";
    }

    // Test 2: extern.convert_any + ref.test (ref extern)
    // Non-null externalized ref with non-nullable type should also match
    // non-nullable extern target (the externalized type is (ref extern)
    // because the runtime made it non-nullable before execution).
    {
      auto Result = VM.execute("test_nonnull", Params, ParamTypes);
      ASSERT_TRUE(Result);
      ASSERT_EQ((*Result).size(), 1U);
      EXPECT_EQ((*Result)[0].first.get<uint32_t>(), 1U)
          << "Non-null externalized anyref should match (ref extern)";
    }
  }

  // --- Part 2: Null anyref input ---
  //
  // When a null anyref is externalized, extern.convert_any creates a new
  // RefVariant with type (ref null noextern) without setting the externalized
  // flag. ref.test follows the normal (non-externalized) code path.
  // A null value should match nullable target but not non-nullable.
  {
    RefVariant NullAnyRef(ValType(TypeCode::RefNull, TypeCode::NullRef));