1 #include <gtest/gtest.h>
2 #include <wasmtime.hh>
3
4 using namespace wasmtime;
5
unwrap(Result<T,E> result)6 template <typename T, typename E> T unwrap(Result<T, E> result) {
7 if (result) {
8 return result.ok();
9 }
10 std::cerr << "error: " << result.err().message() << "\n";
11 std::abort();
12 }
13
TEST(ValType,Smoke)14 TEST(ValType, Smoke) {
15 EXPECT_EQ(ValType(ValKind::I32)->kind(), ValKind::I32);
16 EXPECT_EQ(ValType(ValKind::I64)->kind(), ValKind::I64);
17 EXPECT_EQ(ValType(ValKind::F32)->kind(), ValKind::F32);
18 EXPECT_EQ(ValType(ValKind::F64)->kind(), ValKind::F64);
19 EXPECT_EQ(ValType(ValKind::V128)->kind(), ValKind::V128);
20 EXPECT_EQ(ValType(ValKind::FuncRef)->kind(), ValKind::FuncRef);
21 EXPECT_EQ(ValType(ValKind::ExternRef)->kind(), ValKind::ExternRef);
22
23 ValType t(ValKind::I32);
24 t = ValKind::I64;
25 ValType t2(ValKind::F32);
26 t = t2;
27 ValType t3(t2);
28
29 ValType t4(**t);
30 ValType::Ref r(t4);
31 }
32
TEST(MemoryType,Smoke)33 TEST(MemoryType, Smoke) {
34 MemoryType t(1);
35
36 EXPECT_EQ(t->min(), 1);
37 EXPECT_EQ(t->max(), std::nullopt);
38 MemoryType t2 = t;
39 t2 = t;
40 }
41
TEST(TableType,Smoke)42 TEST(TableType, Smoke) {
43 TableType t(ValKind::FuncRef, 1);
44
45 EXPECT_EQ(t->min(), 1);
46 EXPECT_EQ(t->max(), std::nullopt);
47 EXPECT_EQ(t->element().kind(), ValKind::FuncRef);
48
49 TableType t2 = t;
50 t2 = t;
51 }
52
TEST(GlobalType,Smoke)53 TEST(GlobalType, Smoke) {
54 GlobalType t(ValKind::FuncRef, true);
55
56 EXPECT_EQ(t->content().kind(), ValKind::FuncRef);
57 EXPECT_TRUE(t->is_mutable());
58
59 GlobalType t2 = t;
60 t2 = t;
61 }
62
TEST(ModuleType,Smoke)63 TEST(ModuleType, Smoke) {
64 Engine engine;
65 Module module = unwrap(Module::compile(engine, "(module)"));
66 EXPECT_EQ(module.imports().size(), 0);
67 EXPECT_EQ(module.exports().size(), 0);
68
69 module =
70 unwrap(Module::compile(engine, "(module"
71 "(import \"a\" \"b\" (func))"
72 "(global (export \"x\") i32 (i32.const 0))"
73 ")"));
74
75 auto imports = module.imports();
76 EXPECT_EQ(imports.size(), 1);
77 auto i = *imports.begin();
78 EXPECT_EQ(i.module(), "a");
79 EXPECT_EQ(i.name(), "b");
80 auto import_ty = std::get<FuncType::Ref>(ExternType::from_import(i));
81 EXPECT_EQ(import_ty.params().size(), 0);
82 EXPECT_EQ(import_ty.results().size(), 0);
83
84 for (auto &imp : imports) {
85 }
86
87 auto exports = module.exports();
88 EXPECT_EQ(exports.size(), 1);
89 auto e = *exports.begin();
90 EXPECT_EQ(e.name(), "x");
91 auto export_ty = std::get<GlobalType::Ref>(ExternType::from_export(e));
92 EXPECT_EQ(export_ty.content().kind(), ValKind::I32);
93 EXPECT_FALSE(export_ty.is_mutable());
94
95 for (auto &exp : exports) {
96 }
97
98 auto other_imports = module.imports();
99 other_imports = std::move(imports);
100 ImportType::List last_imports(std::move(other_imports));
101
102 auto other_exports = module.exports();
103 other_exports = std::move(exports);
104 ExportType::List last_exports(std::move(other_exports));
105 }
106
TEST(MemoryType,SixtyFour)107 TEST(MemoryType, SixtyFour) {
108 MemoryType t(1);
109 EXPECT_FALSE(t->is_64());
110 t = MemoryType::New64(1);
111 EXPECT_TRUE(t->is_64());
112 EXPECT_EQ(t->min(), 1);
113 EXPECT_EQ(t->max(), std::nullopt);
114
115 t = MemoryType::New64(0x100000000, 0x100000001);
116 EXPECT_TRUE(t->is_64());
117 EXPECT_EQ(t->min(), 0x100000000);
118 EXPECT_EQ(t->max(), 0x100000001);
119 }
120