wit-bindgen-cli 0.56.0

CLI tool to generate bindings for WIT documents and the component model. 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

package export_wit_world

import (
	"fmt"
	test "wit_component/test_variants_to_test"

	. "go.bytecodealliance.org/pkg/wit/types"
)

func Run() {
	assertEqual(test.RoundtripOption(Some[float32](1.0)).Some(), 1)
	assertEqual(test.RoundtripOption(None[float32]()).Tag(), OptionNone)
	assertEqual(test.RoundtripOption(Some[float32](2.0)).Some(), 2)

	assertEqual(test.RoundtripResult(Ok[uint32, float32](2)).Ok(), 2.0)
	assertEqual(test.RoundtripResult(Ok[uint32, float32](4)).Ok(), 4.0)
	assertEqual(test.RoundtripResult(Err[uint32, float32](5.3)).Err(), 5)

	assertEqual(test.InvertBool(true), false)
	assertEqual(test.InvertBool(false), true)

	{
		a, b, c, d, e, f := test.VariantCasts(test.Casts{
			test.MakeC1A(1),
			test.MakeC2A(2),
			test.MakeC3A(3),
			test.MakeC4A(4),
			test.MakeC5A(5),
			test.MakeC6A(6.0),
		})
		assertEqual(a.A(), 1)
		assertEqual(b.A(), 2)
		assertEqual(c.A(), 3)
		assertEqual(d.A(), 4)
		assertEqual(e.A(), 5)
		assertEqual(f.A(), 6.0)
	}

	{
		a, b, c, d, e, f := test.VariantCasts(test.Casts{
			test.MakeC1B(1),
			test.MakeC2B(2.0),
			test.MakeC3B(3.0),
			test.MakeC4B(4.0),
			test.MakeC5B(5.0),
			test.MakeC6B(6.0),
		})
		assertEqual(a.B(), 1)
		assertEqual(b.B(), 2.0)
		assertEqual(c.B(), 3.0)
		assertEqual(d.B(), 4.0)
		assertEqual(e.B(), 5.0)
		assertEqual(f.B(), 6.0)
	}

	{
		a, b, c, d := test.VariantZeros(test.Zeros{
			test.MakeZ1A(1),
			test.MakeZ2A(2),
			test.MakeZ3A(3.0),
			test.MakeZ4A(4.0),
		})
		assertEqual(a.A(), 1)
		assertEqual(b.A(), 2)
		assertEqual(c.A(), 3.0)
		assertEqual(d.A(), 4.0)
	}

	{
		a, b, c, d := test.VariantZeros(test.Zeros{
			test.MakeZ1B(),
			test.MakeZ2B(),
			test.MakeZ3B(),
			test.MakeZ4B(),
		})
		assertEqual(a.Tag(), test.Z1B)
		assertEqual(b.Tag(), test.Z2B)
		assertEqual(c.Tag(), test.Z3B)
		assertEqual(d.Tag(), test.Z4B)
	}

	test.VariantTypedefs(None[uint32](), false, Err[uint32, Unit](Unit{}))

	{
		a, b, c := test.VariantEnums(true, Ok[Unit, Unit](Unit{}), test.MyErrnoSuccess)
		assertEqual(a, true)
		b.Ok()
		assertEqual(c, test.MyErrnoSuccess)
	}
}

func assertEqual[T comparable](a T, b T) {
	if a != b {
		panic(fmt.Sprintf("%v not equal to %v", a, b))
	}
}