A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
#include <gtest/gtest.h>
#include <wasmtime.hh>
using namespace wasmtime;
TEST(EqRef, CopyAndMove) {
Config config;
config.wasm_gc(true);
Engine engine(std::move(config));
Store store(engine);
auto cx = store.context();
// Create an i31 eqref.
EqRef eq = EqRef::from_i31(cx, 42);
EXPECT_TRUE(eq.is_i31(cx));
// Copy constructor
EqRef eq2(eq);
// Move constructor
EqRef eq3(std::move(eq2));
// Copy assignment
EqRef eq4 = eq3;
// Move assignment
EqRef eq5 = std::move(eq4);
EXPECT_TRUE(eq.ty(cx).is_i31());
// Upcast to anyref and check value
AnyRef upcast = eq.to_anyref();
auto val = upcast.u31(cx);
ASSERT_TRUE(val.has_value());
EXPECT_EQ(*val, 42u);
EXPECT_TRUE(upcast.ty(cx).is_i31());
}
TEST(EqRef, NullEqRef) {
wasmtime_eqref_t raw;
wasmtime_eqref_set_null(&raw);
EXPECT_TRUE(wasmtime_eqref_is_null(&raw));
// Upcast null eqref to anyref via C API
wasmtime_anyref_t out;
wasmtime_eqref_to_anyref(&raw, &out);
EXPECT_TRUE(wasmtime_anyref_is_null(&out));
}
TEST(I31Ref, CreateAndRead) {
Config config;
config.wasm_gc(true);
Engine engine(std::move(config));
Store store(engine);
auto cx = store.context();
// Create an i31 eqref
EqRef eq = EqRef::from_i31(cx, 42);
EXPECT_TRUE(eq.is_i31(cx));
// Read unsigned
auto u = eq.i31_get_u(cx);
ASSERT_TRUE(u.has_value());
EXPECT_EQ(*u, 42u);
// Read signed (positive value)
auto s = eq.i31_get_s(cx);
ASSERT_TRUE(s.has_value());
EXPECT_EQ(*s, 42);
// Upcast to anyref and check is_i31
AnyRef any = eq.to_anyref();
EXPECT_TRUE(any.is_i31(cx));
}
TEST(I31Ref, SignedValues) {
Config config;
config.wasm_gc(true);
Engine engine(std::move(config));
Store store(engine);
auto cx = store.context();
// i31 wraps to 31 bits. 0x7FFFFFFF (all 31 bits set) should give -1 signed.
EqRef eq = EqRef::from_i31(cx, 0x7FFFFFFF);
auto u = eq.i31_get_u(cx);
ASSERT_TRUE(u.has_value());
EXPECT_EQ(*u, 0x7FFFFFFFu);
auto s = eq.i31_get_s(cx);
ASSERT_TRUE(s.has_value());
EXPECT_EQ(*s, -1);
}
TEST(StructRef, CreateAndReadFields) {
Config config;
config.wasm_gc(true);
Engine engine(std::move(config));
Store store(engine);
auto cx = store.context();
// Create a struct type with two mutable i32 fields.
auto ty = StructType::create(engine,
{
FieldType::mut_(ValType::i32()),
FieldType::mut_(ValType::i32()),
})
.unwrap();
auto pre = StructRefPre::create(cx, ty);
// Allocate a struct with field values 10 and 20.
auto result =
StructRef::create(cx, pre, {Val(int32_t(10)), Val(int32_t(20))});
ASSERT_TRUE(result);
StructRef s = result.ok();
EXPECT_EQ(s.ty(cx).num_fields(), 2);
// Read fields back.
auto v0 = s.field(cx, 0);
ASSERT_TRUE(v0);
EXPECT_EQ(v0.ok().i32(), 10);
auto v1 = s.field(cx, 1);
ASSERT_TRUE(v1);
EXPECT_EQ(v1.ok().i32(), 20);
// Write field 0 to 42 and read back.
auto set_result = s.set_field(cx, 0, Val(int32_t(42)));
ASSERT_TRUE(set_result);
auto v0b = s.field(cx, 0);
ASSERT_TRUE(v0b);
EXPECT_EQ(v0b.ok().i32(), 42);
}
TEST(StructType, TooManyFields) {
Config config;
config.wasm_gc(true);
Engine engine(std::move(config));
std::vector<FieldType> fields(10001, FieldType::const_(ValType::i32()));
EXPECT_FALSE(StructType::create(engine, fields));
}
TEST(StructRef, UpcastAndDowncast) {
Config config;
config.wasm_gc(true);
Engine engine(std::move(config));
Store store(engine);
auto cx = store.context();
auto ty = StructType::create(engine,
{
FieldType::const_(ValType::i32()),
})
.unwrap();
auto pre = StructRefPre::create(cx, ty);
auto result = StructRef::create(cx, pre, {Val(int32_t(99))});
ASSERT_TRUE(result);
StructRef s = result.ok();
EXPECT_EQ(s.ty(cx).num_fields(), 1);
// Upcast to eqref.
EqRef eq = s.to_eqref();
EXPECT_TRUE(eq.is_struct(cx));
EXPECT_FALSE(eq.is_i31(cx));
auto eqty = eq.ty(cx);
auto *sty = eqty.as_concrete_struct();
ASSERT_TRUE(sty);
EXPECT_EQ(sty->num_fields(), 1);
// Downcast back to structref.
auto s2_opt = eq.as_struct(cx);
ASSERT_TRUE(s2_opt.has_value());
StructRef s2 = *s2_opt;
auto v = s2.field(cx, 0);
ASSERT_TRUE(v);
EXPECT_EQ(v.ok().i32(), 99);
// Upcast to anyref.
AnyRef any = s.to_anyref();
EXPECT_FALSE(any.is_i31(cx));
auto anyty = any.ty(cx);
sty = anyty.as_concrete_struct();
ASSERT_TRUE(sty);
EXPECT_EQ(sty->num_fields(), 1);
}
TEST(ArrayRef, CreateAndReadElements) {
Config config;
config.wasm_gc(true);
Engine engine(std::move(config));
Store store(engine);
auto cx = store.context();
// Create an array type with mutable i32 elements.
ArrayType ty(engine, FieldType::mut_(ValType::i32()));
auto pre = ArrayRefPre::create(cx, ty);
// Allocate an array of 5 elements, all initialized to 7.
auto result = ArrayRef::create(cx, pre, Val(int32_t(7)), 5);
ASSERT_TRUE(result);
ArrayRef arr = result.ok();
EXPECT_TRUE(arr.ty(cx).element_type().is_mutable());
// Check length.
auto len_result = arr.len(cx);
ASSERT_TRUE(len_result);
EXPECT_EQ(len_result.ok(), 5u);
// Read elements.
for (uint32_t i = 0; i < 5; i++) {
auto v = arr.get(cx, i);
ASSERT_TRUE(v);
EXPECT_EQ(v.ok().i32(), 7);
}
// Write element 2 to 42, read back.
auto set_result = arr.set(cx, 2, Val(int32_t(42)));
ASSERT_TRUE(set_result);
auto v2 = arr.get(cx, 2);
ASSERT_TRUE(v2);
EXPECT_EQ(v2.ok().i32(), 42);
}
TEST(ArrayRef, UpcastAndDowncast) {
Config config;
config.wasm_gc(true);
Engine engine(std::move(config));
Store store(engine);
auto cx = store.context();
ArrayType ty(engine, FieldType::const_(ValType::i32()));
auto pre = ArrayRefPre::create(cx, ty);
auto result = ArrayRef::create(cx, pre, Val(int32_t(99)), 3);
ASSERT_TRUE(result);
ArrayRef arr = result.ok();
EXPECT_FALSE(arr.ty(cx).element_type().is_mutable());
// Upcast to eqref.
EqRef eq = arr.to_eqref();
EXPECT_TRUE(eq.is_array(cx));
EXPECT_FALSE(eq.is_struct(cx));
EXPECT_FALSE(eq.is_i31(cx));
auto eqty = eq.ty(cx);
auto *aty = eqty.as_concrete_array();
ASSERT_TRUE(aty);
EXPECT_FALSE(aty->element_type().is_mutable());
// Downcast back to arrayref.
auto arr2_opt = eq.as_array(cx);
ASSERT_TRUE(arr2_opt.has_value());
ArrayRef arr2 = *arr2_opt;
auto len = arr2.len(cx);
ASSERT_TRUE(len);
EXPECT_EQ(len.ok(), 3u);
auto v = arr2.get(cx, 0);
ASSERT_TRUE(v);
EXPECT_EQ(v.ok().i32(), 99);
// Upcast to anyref.
AnyRef any = arr.to_anyref();
EXPECT_FALSE(any.is_i31(cx));
auto anyty = any.ty(cx);
aty = anyty.as_concrete_array();
ASSERT_TRUE(aty);
EXPECT_FALSE(aty->element_type().is_mutable());
}
TEST(ArrayRef, NullAndMethods) {
Config config;
config.wasm_gc(true);
Engine engine(std::move(config));
Store store(engine);
wasmtime_arrayref_t null_raw;
wasmtime_arrayref_set_null(&null_raw);
ArrayRef null(null_raw);
EXPECT_FALSE(null.len(store));
EXPECT_FALSE(null.get(store, 0));
EXPECT_FALSE(null.set(store, 0, 0));
}
TEST(AnyRef, DowncastI31) {
Config config;
config.wasm_gc(true);
Engine engine(std::move(config));
Store store(engine);
auto cx = store.context();
AnyRef any = AnyRef::i31(cx, 42);
EXPECT_TRUE(any.is_i31(cx));
EXPECT_TRUE(any.is_eqref(cx));
EXPECT_FALSE(any.is_struct(cx));
EXPECT_FALSE(any.is_array(cx));
EXPECT_TRUE(any.ty(cx).is_i31());
// Downcast to eqref.
auto opt_eq = any.as_eqref(cx);
EXPECT_TRUE(opt_eq);
EqRef eq = *opt_eq;
EXPECT_TRUE(eq.is_i31(cx));
auto val = eq.i31_get_u(cx);
ASSERT_TRUE(val.has_value());
EXPECT_EQ(*val, 42u);
EXPECT_TRUE(eq.ty(cx).is_i31());
}
TEST(AnyRef, DowncastStruct) {
Config config;
config.wasm_gc(true);
Engine engine(std::move(config));
Store store(engine);
auto cx = store.context();
auto ty =
StructType::create(engine, {FieldType::const_(ValType::i32())}).unwrap();
auto pre = StructRefPre::create(cx, ty);
auto result = StructRef::create(cx, pre, {Val(int32_t(77))});
ASSERT_TRUE(result);
StructRef s = result.ok();
AnyRef any = s.to_anyref();
EXPECT_TRUE(any.is_eqref(cx));
EXPECT_TRUE(any.is_struct(cx));
EXPECT_FALSE(any.is_array(cx));
EXPECT_FALSE(any.is_i31(cx));
// Downcast back to struct.
auto opt_s2 = any.as_struct(cx);
EXPECT_TRUE(opt_s2);
StructRef s2 = *opt_s2;
auto v = s2.field(cx, 0);
ASSERT_TRUE(v);
EXPECT_EQ(v.ok().i32(), 77);
}
TEST(AnyRef, DowncastArray) {
Config config;
config.wasm_gc(true);
Engine engine(std::move(config));
Store store(engine);
auto cx = store.context();
auto ty = ArrayType(engine, FieldType::const_(ValType::i32()));
auto pre = ArrayRefPre::create(cx, ty);
auto result = ArrayRef::create(cx, pre, Val(int32_t(55)), 2);
ASSERT_TRUE(result);
ArrayRef arr = result.ok();
AnyRef any = arr.to_anyref();
EXPECT_TRUE(any.is_eqref(cx));
EXPECT_FALSE(any.is_struct(cx));
EXPECT_TRUE(any.is_array(cx));
EXPECT_FALSE(any.is_i31(cx));
// Downcast back to array.
auto opt_arr2 = any.as_array(cx);
EXPECT_TRUE(opt_arr2);
ArrayRef arr2 = *opt_arr2;
auto len = arr2.len(cx);
ASSERT_TRUE(len);
EXPECT_EQ(len.ok(), 2u);
}
TEST(StructRef, NullAndMethods) {
Config config;
config.wasm_gc(true);
Engine engine(std::move(config));
Store store(engine);
wasmtime_structref_t null_raw;
wasmtime_structref_set_null(&null_raw);
StructRef null(null_raw);
// EXPECT_FALSE(null.len(store));
EXPECT_FALSE(null.field(store, 0));
EXPECT_FALSE(null.set_field(store, 0, 0));
}