1 #include "utils.h"
2 
3 #include <gtest/gtest.h>
4 #include <wasmtime.h>
5 #include <wasmtime/component.hh>
6 #include <wasmtime/store.hh>
7 
8 #include <array>
9 #include <format>
10 #include <optional>
11 #include <span>
12 #include <variant>
13 
14 using namespace wasmtime::component;
15 using wasmtime::Engine;
16 using wasmtime::Result;
17 using wasmtime::Span;
18 using wasmtime::Store;
19 
20 static std::string echo_component(std::string_view type, std::string_view func,
21                                   std::string_view host_params) {
22   return std::format(
23       R"END(
24 (component
25 	(type $Foo' {})
26 	(import "foo" (type $Foo (eq $Foo')))
27 	(import "do" (func $do (param "a" $Foo) (result $Foo)))
28 	(core module $libc
29 		(memory (export "memory") 1)
30 		{}
31 	)
32 	(core instance $libc (instantiate $libc))
33 	(core func $do_lower (canon lower (func $do) (memory $libc "memory") (realloc (func $libc "realloc"))))
34 
35 	(core module $doer
36 		(import "host" "do" (func $do {}))
37 		(import "libc" "memory" (memory 1))
38 		(import "libc" "realloc" (func $realloc (param i32 i32 i32 i32) (result i32)))
39 
40 		(func (export "call")
41 			{})
42 	)
43 	(core instance $doer (instantiate $doer
44 		(with "host" (instance (export "do" (func $do_lower))))
45 		(with "libc" (instance $libc))
46 	))
47 
48 	(func $call
49 		(param "a" $Foo)
50 		(result $Foo)
51 		(canon lift
52 			(core func $doer "call")
53 			(memory $libc "memory")
54 			(realloc (func $libc "realloc")))
55 	)
56 
57 	(export "call" (func $call))
58 )
59 		  )END",
60       type, REALLOC_AND_FREE, host_params, func);
61 }
62 
63 struct Context {
64   Store store;
65   Store::Context context;
66   Instance instance;
67   Func func;
68 
69   static Context New(Engine &engine, std::string_view component_text,
70                      Linker &linker) {
71     Store store(engine);
72     const auto context = store.context();
73     Component component = Component::compile(engine, component_text).unwrap();
74 
75     auto f = component.export_index(nullptr, "call");
76 
77     EXPECT_TRUE(f);
78 
79     auto instance = linker.instantiate(context, component).unwrap();
80     auto func = *instance.get_func(context, *f);
81 
82     return Context{
83         .store = std::move(store),
84         .context = context,
85         .instance = instance,
86         .func = func,
87     };
88   }
89 };
90 
91 typedef Result<std::monostate> (*host_func_t)(Store::Context, const FuncType &,
92                                               Span<const Val>, Span<Val>);
93 
94 static Context create(std::string_view type, std::string_view body,
95                       std::string_view host_params, host_func_t callback) {
96   Engine engine;
97   Linker linker(engine);
98   linker.root().add_func("do", callback).unwrap();
99   auto component_text = echo_component(type, body, host_params);
100   return Context::New(engine, component_text, linker);
101 }
102 
103 TEST(component, value_record) {
104   static const auto check = [](const Val &v, uint64_t x, uint64_t y) {
105     EXPECT_TRUE(v.is_record());
106     const Record &r = v.get_record();
107     EXPECT_EQ(r.size(), 2);
108 
109     const auto &x_field = *r.begin();
110     EXPECT_EQ(x_field.name(), "x");
111     const auto &x_field_val = x_field.value();
112     EXPECT_TRUE(x_field_val.is_u64());
113     EXPECT_EQ(x_field_val.get_u64(), x);
114 
115     const auto &y_field = *(r.begin() + 1);
116     EXPECT_EQ(y_field.name(), "y");
117     const auto &y_field_val = y_field.value();
118     EXPECT_TRUE(y_field_val.is_u64());
119     EXPECT_EQ(y_field_val.get_u64(), y);
120   };
121 
122   static const auto make = [](uint64_t x, uint64_t y) -> Val {
123     return Record({
124         {"x", x},
125         {"y", y},
126     });
127   };
128 
129   auto ctx = create(
130       R"((record (field "x" u64) (field "y" u64)))", R"(
131 (param $x i64)
132 (param $y i64)
133 (result i32)
134 (local $res i32)
135 local.get $x
136 local.get $y
137 (call $realloc
138 	(i32.const 0)
139 	(i32.const 0)
140 	(i32.const 4)
141 	(i32.const 16))
142 local.tee $res
143 call $do
144 local.get $res
145 	  )",
146       "(param i64 i64 i32)",
147       +[](Store::Context, const FuncType &_ty, Span<const Val> args,
148           Span<Val> rets) -> Result<std::monostate> {
149         EXPECT_EQ(args.size(), 1);
150         check(args[0], 1, 2);
151 
152         EXPECT_EQ(rets.size(), 1);
153         rets[0] = make(3, 4);
154 
155         return std::monostate();
156       });
157 
158   auto arg = make(1, 2);
159   auto res = Val(false);
160 
161   ctx.func.call(ctx.context, Span<const Val>(&arg, 1), Span<Val>(&res, 1))
162       .unwrap();
163   ctx.func.post_return(ctx.context).unwrap();
164 
165   check(res, 3, 4);
166 }
167 
168 TEST(component, value_string) {
169   static const auto check = [](const Val &v, std::string_view text) {
170     EXPECT_TRUE(v.is_string());
171     EXPECT_EQ(v.get_string(), text);
172   };
173 
174   static const auto make = [](std::string_view text) -> Val {
175     return Val::string(text);
176   };
177 
178   auto ctx = create(
179       R"(string)", R"(
180 (param $x i32)
181 (param $y i32)
182 (result i32)
183 (local $res i32)
184 local.get $x
185 local.get $y
186 (call $realloc
187 	(i32.const 0)
188 	(i32.const 0)
189 	(i32.const 4)
190 	(i32.const 8))
191 local.tee $res
192 call $do
193 local.get $res
194 	  )",
195       "(param i32 i32 i32)",
196       +[](Store::Context, const FuncType &, Span<const Val> args,
197           Span<Val> rets) -> Result<std::monostate> {
198         EXPECT_EQ(args.size(), 1);
199         check(args[0], "hello from A!");
200 
201         EXPECT_EQ(rets.size(), 1);
202         rets[0] = make("hello from B!");
203 
204         return std::monostate();
205       });
206 
207   auto arg = make("hello from A!");
208   auto res = Val(false);
209 
210   ctx.func.call(ctx.context, Span<const Val>(&arg, 1), Span<Val>(&res, 1))
211       .unwrap();
212   ctx.func.post_return(ctx.context).unwrap();
213 
214   check(res, "hello from B!");
215 }
216 
217 TEST(component, value_list) {
218   static const auto check = [](const Val &v, std::vector<uint32_t> data) {
219     EXPECT_TRUE(v.is_list());
220     const List &l = v.get_list();
221     EXPECT_EQ(l.size(), data.size());
222 
223     for (auto i = 0; i < data.size(); i++) {
224       const auto &elem = l.begin()[i];
225       EXPECT_TRUE(elem.is_u32());
226       EXPECT_EQ(elem.get_u32(), data[i]);
227     }
228   };
229 
230   static const auto make = [](std::vector<Val> data) -> Val {
231     return List(data);
232   };
233 
234   auto ctx = create(
235       R"((list u32))", R"(
236 (param $x i32)
237 (param $y i32)
238 (result i32)
239 (local $res i32)
240 local.get $x
241 local.get $y
242 (call $realloc
243 	(i32.const 0)
244 	(i32.const 0)
245 	(i32.const 4)
246 	(i32.const 8))
247 local.tee $res
248 call $do
249 local.get $res
250 	  )",
251       "(param i32 i32 i32)",
252       +[](Store::Context, const FuncType &, Span<const Val> args,
253           Span<Val> rets) -> Result<std::monostate> {
254         EXPECT_EQ(args.size(), 1);
255         check(args[0], {1, 2, 3});
256 
257         EXPECT_EQ(rets.size(), 1);
258         rets[0] = make({uint32_t(4), uint32_t(5), uint32_t(6), uint32_t(7)});
259 
260         return std::monostate();
261       });
262 
263   auto arg = make({uint32_t(1), uint32_t(2), uint32_t(3)});
264   auto res = Val(false);
265 
266   ctx.func.call(ctx.context, Span<const Val>(&arg, 1), Span<Val>(&res, 1))
267       .unwrap();
268   ctx.func.post_return(ctx.context).unwrap();
269 
270   check(res, {4, 5, 6, 7});
271 }
272 
273 TEST(component, value_tuple) {
274   static const auto check = [](const Val &v, std::vector<uint32_t> data) {
275     EXPECT_TRUE(v.is_tuple());
276     const Tuple &t = v.get_tuple();
277     EXPECT_EQ(t.size(), data.size());
278     for (auto i = 0; i < data.size(); i++) {
279       const auto &elem = t.begin()[i];
280       EXPECT_TRUE(elem.is_u32());
281       EXPECT_EQ(elem.get_u32(), data[i]);
282     }
283   };
284 
285   static const auto make = [](std::vector<Val> data) -> Val {
286     return Tuple(data);
287   };
288 
289   auto ctx = create(
290       R"((tuple u32 u32 u32))", R"(
291 (param $x i32)
292 (param $y i32)
293 (param $z i32)
294 (result i32)
295 (local $res i32)
296 local.get $x
297 local.get $y
298 local.get $z
299 (call $realloc
300 	(i32.const 0)
301 	(i32.const 0)
302 	(i32.const 4)
303 	(i32.const 12))
304 local.tee $res
305 call $do
306 local.get $res
307 	  )",
308       "(param i32 i32 i32 i32)",
309       +[](Store::Context, const FuncType &, Span<const Val> args,
310           Span<Val> rets) -> Result<std::monostate> {
311         EXPECT_EQ(args.size(), 1);
312         check(args[0], {1, 2, 3});
313 
314         EXPECT_EQ(rets.size(), 1);
315         rets[0] = make({uint32_t(4), uint32_t(5), uint32_t(6)});
316 
317         return std::monostate();
318       });
319 
320   auto arg = make({uint32_t(1), uint32_t(2), uint32_t(3)});
321   auto res = Val(false);
322 
323   ctx.func.call(ctx.context, Span<const Val>(&arg, 1), Span<Val>(&res, 1))
324       .unwrap();
325   ctx.func.post_return(ctx.context).unwrap();
326 
327   check(res, {4, 5, 6});
328 }
329 
330 TEST(component, value_variant) {
331   static const auto check_aa = [](const Val &v, uint32_t value) {
332     EXPECT_TRUE(v.is_variant());
333     const Variant &var = v.get_variant();
334     EXPECT_EQ(var.discriminant(), "aa");
335     EXPECT_NE(var.value(), nullptr);
336     EXPECT_TRUE(var.value()->is_u32());
337     EXPECT_EQ(var.value()->get_u32(), value);
338   };
339 
340   static const auto check_bb = [](const Val &v, std::string_view value) {
341     EXPECT_TRUE(v.is_variant());
342     const Variant &var = v.get_variant();
343     EXPECT_EQ(var.discriminant(), "bb");
344     EXPECT_NE(var.value(), nullptr);
345     EXPECT_TRUE(var.value()->is_string());
346     EXPECT_EQ(var.value()->get_string(), value);
347   };
348 
349   static const auto make_aa = [](uint32_t value) -> Val {
350     return Variant("aa", Val(value));
351   };
352 
353   static const auto make_bb = [](std::string_view value) -> Val {
354     return Variant("bb", Val::string(value));
355   };
356 
357   auto ctx = create(
358       R"(
359 (variant
360 	(case "aa" u32)
361 	(case "bb" string)
362 )
363 	  )",
364       R"(
365 (param $x i32)
366 (param $y i32)
367 (param $z i32)
368 (result i32)
369 (local $res i32)
370 local.get $x
371 local.get $y
372 local.get $z
373 (call $realloc
374 	(i32.const 0)
375 	(i32.const 0)
376 	(i32.const 4)
377 	(i32.const 12))
378 local.tee $res
379 call $do
380 local.get $res
381 	  )",
382       "(param i32 i32 i32 i32)",
383       +[](Store::Context, const FuncType &, Span<const Val> args,
384           Span<Val> rets) -> Result<std::monostate> {
385         EXPECT_EQ(args.size(), 1);
386         check_aa(args[0], 123);
387 
388         EXPECT_EQ(rets.size(), 1);
389         rets[0] = make_bb("textt");
390 
391         return std::monostate();
392       });
393 
394   auto arg = make_aa(123);
395   auto res = Val(false);
396 
397   ctx.func.call(ctx.context, Span<const Val>(&arg, 1), Span<Val>(&res, 1))
398       .unwrap();
399   ctx.func.post_return(ctx.context).unwrap();
400 
401   check_bb(res, "textt");
402 }
403 
404 TEST(component, value_enum) {
405   static const auto check = [](const Val &v, std::string_view text) {
406     EXPECT_TRUE(v.is_enum());
407     EXPECT_EQ(v.get_enum(), text);
408   };
409 
410   static const auto make = [](std::string_view text) -> Val {
411     return Val::enum_(text);
412   };
413 
414   auto ctx = create(
415       R"((enum "aa" "bb"))", R"(
416 (param $x i32)
417 (result i32)
418 local.get $x
419 call $do
420 	  )",
421       "(param i32) (result i32)",
422       +[](Store::Context, const FuncType &, Span<const Val> args,
423           Span<Val> rets) -> Result<std::monostate> {
424         EXPECT_EQ(args.size(), 1);
425         check(args[0], "aa");
426 
427         EXPECT_EQ(rets.size(), 1);
428         rets[0] = make("bb");
429 
430         return std::monostate();
431       });
432 
433   auto arg = make("aa");
434   auto res = Val(false);
435 
436   ctx.func.call(ctx.context, Span<const Val>(&arg, 1), Span<Val>(&res, 1))
437       .unwrap();
438   ctx.func.post_return(ctx.context).unwrap();
439 
440   check(res, "bb");
441 }
442 
443 TEST(component, value_option) {
444   static const auto check = [](const Val &v, std::optional<uint32_t> value) {
445     EXPECT_TRUE(v.is_option());
446     const WitOption &o = v.get_option();
447     if (value.has_value()) {
448       EXPECT_NE(o.value(), nullptr);
449       EXPECT_TRUE(o.value()->is_u32());
450       EXPECT_EQ(o.value()->get_u32(), *value);
451     } else {
452       EXPECT_EQ(o.value(), nullptr);
453     }
454   };
455 
456   static const auto make = [](std::optional<uint32_t> value) -> Val {
457     if (value) {
458       return WitOption(Val(*value));
459     }
460     return WitOption(std::nullopt);
461   };
462 
463   auto ctx = create(
464       R"((option u32))", R"(
465 (param $x i32)
466 (param $y i32)
467 (result i32)
468 (local $res i32)
469 local.get $x
470 local.get $y
471 (call $realloc
472 	(i32.const 0)
473 	(i32.const 0)
474 	(i32.const 4)
475 	(i32.const 8))
476 local.tee $res
477 call $do
478 local.get $res
479 	  )",
480       "(param i32 i32 i32)",
481       +[](Store::Context, const FuncType &, Span<const Val> args,
482           Span<Val> rets) -> Result<std::monostate> {
483         EXPECT_EQ(args.size(), 1);
484         check(args[0], 123);
485 
486         EXPECT_EQ(rets.size(), 1);
487         rets[0] = make({});
488 
489         return std::monostate();
490       });
491 
492   auto arg = make(123);
493   auto res = Val(false);
494 
495   ctx.func.call(ctx.context, Span<const Val>(&arg, 1), Span<Val>(&res, 1))
496       .unwrap();
497   ctx.func.post_return(ctx.context).unwrap();
498 
499   check(res, {});
500 }
501 
502 TEST(component, value_result) {
503   static const auto check = [](const Val &v, bool expected_is_ok,
504                                uint32_t expected_value) {
505     EXPECT_TRUE(v.is_result());
506     const WitResult &r = v.get_result();
507     EXPECT_EQ(r.is_ok(), expected_is_ok);
508     EXPECT_NE(r.payload(), nullptr);
509     EXPECT_TRUE(r.payload()->is_u32());
510     EXPECT_EQ(r.payload()->get_u32(), expected_value);
511   };
512 
513   static const auto make = [](bool is_ok, uint32_t value) -> Val {
514     if (is_ok) {
515       return WitResult::ok(Val(value));
516     }
517     return WitResult::err(Val(value));
518   };
519 
520   auto ctx = create(
521       R"((result u32 (error u32)))", R"(
522 (param $x i32)
523 (param $y i32)
524 (result i32)
525 (local $res i32)
526 local.get $x
527 local.get $y
528 (call $realloc
529 	(i32.const 0)
530 	(i32.const 0)
531 	(i32.const 4)
532 	(i32.const 8))
533 local.tee $res
534 call $do
535 local.get $res
536 	  )",
537       "(param i32 i32 i32)",
538       +[](Store::Context, const FuncType &, Span<const Val> args,
539           Span<Val> rets) -> Result<std::monostate> {
540         EXPECT_EQ(args.size(), 1);
541         check(args[0], true, 123);
542 
543         EXPECT_EQ(rets.size(), 1);
544         rets[0] = make(false, 456);
545 
546         return std::monostate();
547       });
548 
549   auto arg = make(true, 123);
550   auto res = Val(false);
551 
552   ctx.func.call(ctx.context, Span<const Val>(&arg, 1), Span<Val>(&res, 1))
553       .unwrap();
554   ctx.func.post_return(ctx.context).unwrap();
555 
556   check(res, false, 456);
557 }
558 
559 TEST(component, value_flags) {
560   static const auto check = [](const Val &v, std::vector<std::string> data) {
561     EXPECT_TRUE(v.is_flags());
562     const Flags &f = v.get_flags();
563 
564     EXPECT_EQ(f.size(), data.size());
565     for (auto i = 0; i < data.size(); i++) {
566       EXPECT_EQ(f.begin()[i].name(), data[i]);
567     }
568   };
569 
570   static const auto make = [](std::vector<Flag> data) -> Val {
571     return Flags(data);
572   };
573 
574   auto ctx = create(
575       R"((flags "aa" "bb"))", R"(
576 (param $x i32)
577 (result i32)
578 local.get $x
579 call $do
580 	  )",
581       "(param i32) (result i32)",
582       +[](Store::Context, const FuncType &, Span<const Val> args,
583           Span<Val> rets) -> Result<std::monostate> {
584         EXPECT_EQ(args.size(), 1);
585         check(args[0], {"aa"});
586 
587         EXPECT_EQ(rets.size(), 1);
588         rets[0] = make({Flag("aa"), Flag("bb")});
589 
590         return std::monostate();
591       });
592 
593   auto arg = make({Flag("aa")});
594   auto res = Val(false);
595 
596   ctx.func.call(ctx.context, Span<const Val>(&arg, 1), Span<Val>(&res, 1))
597       .unwrap();
598   ctx.func.post_return(ctx.context).unwrap();
599 
600   check(res, {"aa", "bb"});
601 }
602 
603 TEST(component, value_list_inner) {
604   auto x = wasmtime_component_val_t{
605       .kind = WASMTIME_COMPONENT_LIST,
606   };
607   wasmtime_component_vallist_new_empty(&x.of.list);
608   EXPECT_EQ(x.of.list.data, nullptr);
609   EXPECT_EQ(x.of.list.size, 0);
610 
611   wasmtime_component_vallist_new_uninit(&x.of.list, 1);
612   EXPECT_NE(x.of.list.data, nullptr);
613   EXPECT_EQ(x.of.list.size, 1);
614 
615   wasmtime_component_vallist_delete(&x.of.list);
616 
617   auto items = std::array{
618       wasmtime_component_val_t{
619           .kind = WASMTIME_COMPONENT_U32,
620           .of = {.u32 = 123},
621       },
622   };
623 
624   wasmtime_component_vallist_new(&x.of.list, items.size(), items.data());
625   EXPECT_NE(x.of.list.data, nullptr);
626   EXPECT_EQ(x.of.list.size, 1);
627 
628   EXPECT_EQ(x.of.list.data[0].kind, WASMTIME_COMPONENT_U32);
629   EXPECT_EQ(x.of.list.data[0].of.u32, 123);
630 
631   auto clone = wasmtime_component_val_t{
632       .kind = WASMTIME_COMPONENT_LIST,
633   };
634 
635   wasmtime_component_vallist_copy(&clone.of.list, &x.of.list);
636   wasmtime_component_vallist_delete(&x.of.list);
637 
638   EXPECT_NE(clone.of.list.data, nullptr);
639   EXPECT_EQ(clone.of.list.size, 1);
640 
641   EXPECT_EQ(clone.of.list.data[0].kind, WASMTIME_COMPONENT_U32);
642   EXPECT_EQ(clone.of.list.data[0].of.u32, 123);
643 
644   wasmtime_component_vallist_delete(&clone.of.list);
645 }
646 
647 TEST(component, records) {
648   Record r({{"x", uint64_t(1)}, {"y", uint64_t(2)}});
649   EXPECT_EQ(r.size(), 2);
650 
651   for (auto &field : r) {
652     if (field.name() == "x") {
653       EXPECT_EQ(field.value().get_u64(), 1);
654     } else if (field.name() == "y") {
655       EXPECT_EQ(field.value().get_u64(), 2);
656     } else {
657       FAIL() << "unexpected field name: " << field.name();
658     }
659   }
660 
661   Record r2({{"x", r}, {"y", uint64_t(2)}});
662   EXPECT_EQ(r2.size(), 2);
663   EXPECT_EQ(r.size(), 2);
664 
665   for (auto &field : r2) {
666     if (field.name() == "x") {
667       auto inner = field.value().get_record();
668       EXPECT_EQ(inner.size(), 2);
669       for (auto &inner_field : inner) {
670         if (inner_field.name() == "x") {
671           EXPECT_EQ(inner_field.value().get_u64(), 1);
672         } else if (inner_field.name() == "y") {
673           EXPECT_EQ(inner_field.value().get_u64(), 2);
674         } else {
675           FAIL() << "unexpected inner field name: " << inner_field.name();
676         }
677       }
678     } else if (field.name() == "y") {
679       EXPECT_EQ(field.value().get_u64(), 2);
680     } else {
681       FAIL() << "unexpected field name: " << field.name();
682     }
683   }
684 
685   Val record = r2;
686   EXPECT_TRUE(record.is_record());
687   EXPECT_EQ(r2.size(), 2);
688   Val record2 = std::move(r2);
689   EXPECT_TRUE(record2.is_record());
690   EXPECT_EQ(r2.size(), 0);
691 }
692 
693 TEST(component, lists) {
694   List l({uint32_t(1), uint32_t(2), uint32_t(3)});
695   EXPECT_EQ(l.size(), 3);
696   uint32_t expected = 1;
697   for (auto &val : l) {
698     EXPECT_EQ(val.get_u32(), expected);
699     expected++;
700   }
701 
702   List l2 = l;
703   EXPECT_EQ(l.size(), 3);
704   EXPECT_EQ(l2.size(), 3);
705 
706   List l3 = std::move(l);
707   EXPECT_EQ(l.size(), 0);
708   EXPECT_EQ(l3.size(), 3);
709 
710   Val value(l3);
711   value.get_list();
712 }
713 
714 TEST(component, tuples) {
715   Tuple l({uint32_t(1), uint64_t(2), uint8_t(3)});
716   EXPECT_EQ(l.size(), 3);
717 
718   Val value(l);
719   EXPECT_TRUE(value.is_tuple());
720   EXPECT_EQ(l.size(), 3);
721 
722   for (auto &val : l) {
723     if (val.is_u32()) {
724       EXPECT_EQ(val.get_u32(), 1);
725     } else if (val.is_u64()) {
726       EXPECT_EQ(val.get_u64(), 2);
727     } else if (val.is_u8()) {
728       EXPECT_EQ(val.get_u8(), 3);
729     } else {
730       FAIL() << "unexpected tuple value type";
731     }
732   }
733 }
734 
735 TEST(component, variants) {
736   Variant v("hello", uint32_t(42));
737   EXPECT_EQ(v.discriminant(), "hello");
738   EXPECT_TRUE(v.value()->is_u32());
739   EXPECT_EQ(v.value()->get_u32(), 42);
740 
741   Variant v2("another", v);
742   EXPECT_EQ(v.discriminant(), "hello");
743   EXPECT_TRUE(v.value()->is_u32());
744   EXPECT_EQ(v.value()->get_u32(), 42);
745   EXPECT_EQ(v2.discriminant(), "another");
746   EXPECT_TRUE(v2.value()->is_variant());
747   auto inner = v2.value()->get_variant();
748   EXPECT_EQ(inner.discriminant(), "hello");
749   EXPECT_TRUE(inner.value()->is_u32());
750   EXPECT_EQ(inner.value()->get_u32(), 42);
751 
752   Val value = v;
753   EXPECT_TRUE(value.is_variant());
754   auto v3 = value.get_variant();
755   EXPECT_EQ(v3.discriminant(), "hello");
756   EXPECT_TRUE(v3.value()->is_u32());
757   EXPECT_EQ(v3.value()->get_u32(), 42);
758 }
759 
760 TEST(component, strings) {
761   Val v = Val::string("hi");
762   EXPECT_TRUE(v.is_string());
763   EXPECT_EQ(v.get_string(), "hi");
764 
765   v = Val::string("another");
766   EXPECT_TRUE(v.is_string());
767   EXPECT_EQ(v.get_string(), "another");
768 }
769 
770 TEST(component, results) {
771   WitResult r = WitResult::ok(uint32_t(42));
772   EXPECT_TRUE(r.is_ok());
773   EXPECT_EQ(r.payload()->get_u32(), 42);
774 
775   r = WitResult::ok(std::nullopt);
776   EXPECT_TRUE(r.is_ok());
777   EXPECT_EQ(r.payload(), nullptr);
778 
779   r = WitResult::err(std::nullopt);
780   EXPECT_FALSE(r.is_ok());
781   EXPECT_EQ(r.payload(), nullptr);
782 
783   Val v = r;
784   EXPECT_TRUE(v.is_result());
785   auto r2 = v.get_result();
786   EXPECT_FALSE(r2.is_ok());
787   EXPECT_EQ(r2.payload(), nullptr);
788 
789   r = WitResult::ok(uint32_t(99));
790   v = r;
791   EXPECT_TRUE(r.is_ok());
792   EXPECT_NE(r.payload(), nullptr);
793   EXPECT_EQ(r.payload()->get_u32(), 99);
794 }
795 
796 TEST(component, enums) {
797   Val v = Val::enum_("hi");
798   EXPECT_TRUE(v.is_enum());
799   EXPECT_EQ(v.get_enum(), "hi");
800 
801   v = Val::enum_("another");
802   EXPECT_TRUE(v.is_enum());
803   EXPECT_EQ(v.get_enum(), "another");
804 }
805 
806 TEST(component, options) {
807   WitOption o(Val(uint32_t(42)));
808   EXPECT_NE(o.value(), nullptr);
809   EXPECT_TRUE(o.value()->is_u32());
810   EXPECT_EQ(o.value()->get_u32(), 42);
811 
812   Val v(o);
813   WitOption o2(v);
814   EXPECT_NE(o.value(), nullptr);
815   EXPECT_TRUE(o2.value()->is_option());
816   auto inner = o2.value()->get_option();
817   auto value = inner.value();
818   EXPECT_NE(value, nullptr);
819   EXPECT_TRUE(value->is_u32());
820   EXPECT_EQ(value->get_u32(), 42);
821 
822   EXPECT_NE(o.value(), nullptr);
823   EXPECT_TRUE(o.value()->is_u32());
824   EXPECT_EQ(o.value()->get_u32(), 42);
825 
826   WitOption o3(std::nullopt);
827   EXPECT_EQ(o3.value(), nullptr);
828 }
829 
830 TEST(component, flags) {
831   std::vector<Flag> flags = {
832       Flag("a"),
833       Flag("b"),
834       Flag("c"),
835   };
836   Flags f(flags);
837   EXPECT_EQ(f.size(), 3);
838   for (auto i = 0; i < f.size(); i++) {
839     EXPECT_EQ(f.begin()[i].name(), flags[i].name());
840   }
841 
842   flags.clear();
843   Flags f2(flags);
844   EXPECT_EQ(f2.size(), 0);
845   EXPECT_EQ(f.size(), 3);
846 
847   Val v = f;
848   EXPECT_TRUE(v.is_flags());
849   Flags f3 = v.get_flags();
850   EXPECT_EQ(f3.size(), 3);
851   EXPECT_EQ(f.size(), 3);
852 }
853 
854 TEST(component, value_host_resource) {
855   static const uint32_t RESOURCE_TYPE = 100;
856 
857   static const auto check = [](Store::Context cx, const Val &v, uint32_t rep) {
858     EXPECT_TRUE(v.is_resource());
859     const ResourceAny &f = v.get_resource();
860     EXPECT_EQ(f.type(), ResourceType(RESOURCE_TYPE));
861     ResourceHost r = f.to_host(cx).unwrap();
862     EXPECT_EQ(r.rep(), rep);
863     EXPECT_EQ(r.type(), RESOURCE_TYPE);
864   };
865 
866   static const auto make = [](Store::Context cx, uint32_t rep) -> Val {
867     return ResourceHost(true, rep, RESOURCE_TYPE).to_any(cx).unwrap();
868   };
869 
870   Engine engine;
871   Linker linker(engine);
872   {
873     LinkerInstance i = linker.root();
874 
875     i.add_resource(
876          "r", ResourceType(RESOURCE_TYPE),
877          +[](Store::Context, uint32_t rep) -> Result<std::monostate> {
878            EXPECT_EQ(rep, 42);
879            return std::monostate();
880          })
881         .unwrap();
882 
883     i.add_func(
884          "f",
885          +[](Store::Context cx, const FuncType &_ty, Span<const Val> args,
886              Span<Val> rets) -> Result<std::monostate> {
887            EXPECT_EQ(args.size(), 1);
888            check(cx, args[0], 42);
889 
890            EXPECT_EQ(rets.size(), 1);
891            rets[0] = make(cx, 43);
892            return std::monostate();
893          })
894         .unwrap();
895   }
896 
897   auto ctx = Context::New(engine,
898                           R"(
899 (component
900   (import "r" (type $r (sub resource)))
901   (import "f" (func $f (param "a" (own $r)) (result (own $r))))
902   (core func $f (canon lower (func $f)))
903 
904   (core module $m
905     (import "" "f" (func $f (param i32) (result i32)))
906 
907     (func (export "call") (param i32) (result i32)
908       local.get 0
909       call $f)
910   )
911 
912   (core instance $m (instantiate $m
913     (with "" (instance
914       (export "f" (func $f))
915     ))
916   ))
917 
918   (func (export "call") (param "a" (own $r)) (result (own $r))
919     (canon lift (core func $m "call")))
920 )
921 )",
922                           linker);
923 
924   auto arg = make(ctx.context, 42);
925   auto res = Val(false);
926 
927   ctx.func.call(ctx.context, Span<const Val>(&arg, 1), Span<Val>(&res, 1))
928       .unwrap();
929   ctx.func.post_return(ctx.context).unwrap();
930 
931   check(ctx.context, res, 43);
932 }
933 
934 TEST(component, value_guest_resource) {
935   Engine engine;
936   Linker linker(engine);
937   Store store(engine);
938 
939   Component c = Component::compile(engine,
940                                    R"(
941 (component
942   (core module $a
943     (global $g (mut i32) (i32.const 0))
944 
945     (func (export "dtor") (param i32) (global.set $g (local.get 0)))
946     (func (export "last-dtor-rep") (result i32) global.get $g)
947   )
948   (core instance $a (instantiate $a))
949   (type $r' (resource (rep i32) (dtor (func $a "dtor"))))
950   (export $r "r" (type $r'))
951 
952   (core func $new (canon resource.new $r))
953   (core func $drop (canon resource.drop $r))
954 
955   (core module $b
956     (import "" "new" (func $new (param i32) (result i32)))
957     (import "" "drop" (func $drop (param i32)))
958 
959     (func (export "new") (param i32) (result i32)
960       local.get 0
961       call $new)
962 
963     (func (export "rep") (param i32) (result i32)
964       local.get 0)
965 
966     (func (export "drop") (param i32)
967       local.get 0
968       call $drop)
969   )
970   (core instance $b (instantiate $b
971     (with "" (instance
972       (export "new" (func $new))
973       (export "drop" (func $drop))
974     ))
975   ))
976 
977   (func (export "new") (param "x" u32) (result (own $r))
978     (canon lift (core func $b "new")))
979   (func (export "rep") (param "x" (borrow $r)) (result u32)
980     (canon lift (core func $b "rep")))
981   (func (export "drop") (param "x" (own $r))
982     (canon lift (core func $b "drop")))
983   (func (export "last-dtor-rep") (result u32)
984     (canon lift (core func $a "last-dtor-rep")))
985 
986 )
987 )")
988                     .unwrap();
989 
990   auto instance = linker.instantiate(store, c).unwrap();
991   auto new_index = *instance.get_export_index(store, nullptr, "new");
992   auto rep_index = *instance.get_export_index(store, nullptr, "rep");
993   auto drop_index = *instance.get_export_index(store, nullptr, "drop");
994   auto last_dtor_rep_index =
995       *instance.get_export_index(store, nullptr, "last-dtor-rep");
996   auto new_func = *instance.get_func(store, new_index);
997   auto rep_func = *instance.get_func(store, rep_index);
998   auto drop_func = *instance.get_func(store, drop_index);
999   auto last_dtor_rep_func = *instance.get_func(store, last_dtor_rep_index);
1000 
1001   auto arg1 = Val(uint32_t(100));
1002   auto res1 = Val(false);
1003   new_func.call(store, Span<const Val>(&arg1, 1), Span<Val>(&res1, 1)).unwrap();
1004   new_func.post_return(store).unwrap();
1005 
1006   auto arg2 = Val(uint32_t(101));
1007   auto res2 = Val(false);
1008   new_func.call(store, Span<const Val>(&arg2, 1), Span<Val>(&res2, 1)).unwrap();
1009   new_func.post_return(store).unwrap();
1010 
1011   {
1012     EXPECT_TRUE(res1.is_resource());
1013     EXPECT_TRUE(res2.is_resource());
1014     const auto &resource1 = res1.get_resource();
1015     const auto &resource2 = res2.get_resource();
1016     EXPECT_NE(resource1.type(), ResourceType(100));
1017     EXPECT_NE(resource2.type(), ResourceType(100));
1018     EXPECT_EQ(resource1.type(), resource2.type());
1019     EXPECT_FALSE(resource1.to_host(store));
1020     EXPECT_FALSE(resource2.to_host(store));
1021     EXPECT_TRUE(resource1.owned());
1022     EXPECT_TRUE(resource2.owned());
1023     arg1 = resource1;
1024     arg2 = resource2;
1025   }
1026 
1027   rep_func.call(store, Span<const Val>(&arg1, 1), Span<Val>(&res1, 1)).unwrap();
1028   rep_func.post_return(store).unwrap();
1029   rep_func.call(store, Span<const Val>(&arg2, 1), Span<Val>(&res2, 1)).unwrap();
1030   rep_func.post_return(store).unwrap();
1031 
1032   EXPECT_TRUE(res1.is_u32());
1033   EXPECT_TRUE(res2.is_u32());
1034   EXPECT_EQ(res1.get_u32(), 100);
1035   EXPECT_EQ(res2.get_u32(), 101);
1036 
1037   Val last_rep(false);
1038   last_dtor_rep_func.call(store, Span<const Val>(), Span<Val>(&last_rep, 1))
1039       .unwrap();
1040   last_dtor_rep_func.post_return(store).unwrap();
1041   EXPECT_EQ(last_rep.get_u32(), 0);
1042 
1043   drop_func.call(store, Span<const Val>(&arg1, 1), Span<Val>()).unwrap();
1044   drop_func.post_return(store).unwrap();
1045 
1046   last_dtor_rep_func.call(store, Span<const Val>(), Span<Val>(&last_rep, 1))
1047       .unwrap();
1048   last_dtor_rep_func.post_return(store).unwrap();
1049   EXPECT_EQ(last_rep.get_u32(), 100);
1050 
1051   arg2.get_resource().drop(store).unwrap();
1052 
1053   last_dtor_rep_func.call(store, Span<const Val>(), Span<Val>(&last_rep, 1))
1054       .unwrap();
1055   last_dtor_rep_func.post_return(store).unwrap();
1056   EXPECT_EQ(last_rep.get_u32(), 101);
1057 }
1058 
1059 TEST(component, resources) {
1060   ResourceHost r1(true, 1, 2);
1061   EXPECT_TRUE(r1.owned());
1062   EXPECT_EQ(r1.rep(), 1);
1063   EXPECT_EQ(r1.type(), 2);
1064 
1065   ResourceHost r2 = r1;
1066   EXPECT_TRUE(r1.owned());
1067   EXPECT_EQ(r1.rep(), 1);
1068   EXPECT_EQ(r1.type(), 2);
1069   EXPECT_TRUE(r2.owned());
1070   EXPECT_EQ(r2.rep(), 1);
1071   EXPECT_EQ(r2.type(), 2);
1072 
1073   Engine engine;
1074   Store store(engine);
1075   ResourceAny r3 = r2.to_any(store).unwrap();
1076   EXPECT_TRUE(r3.owned());
1077   ResourceType t3 = r3.type();
1078   EXPECT_EQ(t3, ResourceType(2));
1079 
1080   ResourceHost r4 = r3.to_host(store).unwrap();
1081   EXPECT_TRUE(r4.owned());
1082   EXPECT_EQ(r4.rep(), 1);
1083   EXPECT_EQ(r4.type(), 2);
1084 
1085   EXPECT_FALSE(r3.drop(store));
1086   EXPECT_TRUE(r4.to_any(store).unwrap().drop(store));
1087 
1088   Val v = r4.to_any(store).unwrap();
1089   EXPECT_TRUE(v.is_resource());
1090   const ResourceAny &r5 = v.get_resource();
1091   EXPECT_TRUE(r5.owned());
1092   EXPECT_EQ(r5.type(), ResourceType(2));
1093 }
1094