wit-bindgen-cli 0.57.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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

#include <assert.h>
#include <runner.h>
#include <stddef.h>

void exports_runner_run() {
    {
        float a = 1;
        uint8_t r;
        assert(test_variants_to_test_roundtrip_option(&a, &r) && r == 1);
        assert(!test_variants_to_test_roundtrip_option(NULL, &r));
        a = 2;
        assert(test_variants_to_test_roundtrip_option(&a, &r) && r == 2);
    }

    {
        test_variants_to_test_result_u32_f32_t a;
        double b_ok;
        uint8_t b_err;

        a.is_err = false;
        a.val.ok = 2;
        assert(test_variants_to_test_roundtrip_result(&a, &b_ok, &b_err));
        assert(b_ok == 2.0);

        a.val.ok = 4;
        assert(test_variants_to_test_roundtrip_result(&a, &b_ok, &b_err));
        assert(b_ok == 4);

        a.is_err = true;
        a.val.err = 5.3;
        assert(!test_variants_to_test_roundtrip_result(&a, &b_ok, &b_err));
        assert(b_err == 5);
    }

    assert(test_variants_to_test_roundtrip_enum(TEST_VARIANTS_TO_TEST_E1_A) == TEST_VARIANTS_TO_TEST_E1_A);
    assert(test_variants_to_test_roundtrip_enum(TEST_VARIANTS_TO_TEST_E1_B) == TEST_VARIANTS_TO_TEST_E1_B);

    assert(test_variants_to_test_invert_bool(true) == false);
    assert(test_variants_to_test_invert_bool(false) == true);

    {
        test_variants_to_test_casts_t c, ret;
        c.f0.tag = TEST_VARIANTS_TO_TEST_C1_A;
        c.f0.val.a = 1;
        c.f1.tag = TEST_VARIANTS_TO_TEST_C2_A;
        c.f1.val.a = 2;
        c.f2.tag = TEST_VARIANTS_TO_TEST_C3_A;
        c.f2.val.a = 3;
        c.f3.tag = TEST_VARIANTS_TO_TEST_C4_A;
        c.f3.val.a = 4;
        c.f4.tag = TEST_VARIANTS_TO_TEST_C5_A;
        c.f4.val.a = 5;
        c.f5.tag = TEST_VARIANTS_TO_TEST_C6_A;
        c.f5.val.a = 6;
        test_variants_to_test_variant_casts(&c, &ret);
        assert(ret.f0.tag == TEST_VARIANTS_TO_TEST_C1_A && ret.f0.val.a == 1);
        assert(ret.f1.tag == TEST_VARIANTS_TO_TEST_C2_A && ret.f1.val.a == 2);
        assert(ret.f2.tag == TEST_VARIANTS_TO_TEST_C3_A && ret.f2.val.a == 3);
        assert(ret.f3.tag == TEST_VARIANTS_TO_TEST_C4_A && ret.f3.val.a == 4);
        assert(ret.f4.tag == TEST_VARIANTS_TO_TEST_C5_A && ret.f4.val.a == 5);
        assert(ret.f5.tag == TEST_VARIANTS_TO_TEST_C6_A && ret.f5.val.a == 6);
    }

    {
        test_variants_to_test_casts_t c, ret;
        c.f0.tag = TEST_VARIANTS_TO_TEST_C1_B;
        c.f0.val.b = 1;
        c.f1.tag = TEST_VARIANTS_TO_TEST_C2_B;
        c.f1.val.b = 2;
        c.f2.tag = TEST_VARIANTS_TO_TEST_C3_B;
        c.f2.val.b = 3;
        c.f3.tag = TEST_VARIANTS_TO_TEST_C4_B;
        c.f3.val.b = 4;
        c.f4.tag = TEST_VARIANTS_TO_TEST_C5_B;
        c.f4.val.b = 5;
        c.f5.tag = TEST_VARIANTS_TO_TEST_C6_B;
        c.f5.val.b = 6;
        test_variants_to_test_variant_casts(&c, &ret);
        assert(ret.f0.tag == TEST_VARIANTS_TO_TEST_C1_B && ret.f0.val.b == 1);
        assert(ret.f1.tag == TEST_VARIANTS_TO_TEST_C2_B && ret.f1.val.b == 2);
        assert(ret.f2.tag == TEST_VARIANTS_TO_TEST_C3_B && ret.f2.val.b == 3);
        assert(ret.f3.tag == TEST_VARIANTS_TO_TEST_C4_B && ret.f3.val.b == 4);
        assert(ret.f4.tag == TEST_VARIANTS_TO_TEST_C5_B && ret.f4.val.b == 5);
        assert(ret.f5.tag == TEST_VARIANTS_TO_TEST_C6_B && ret.f5.val.b == 6);
    }

    {
        test_variants_to_test_zeros_t c, ret;
        c.f0.tag = TEST_VARIANTS_TO_TEST_Z1_A;
        c.f0.val.a = 1;
        c.f1.tag = TEST_VARIANTS_TO_TEST_Z2_A;
        c.f1.val.a = 2;
        c.f2.tag = TEST_VARIANTS_TO_TEST_Z3_A;
        c.f2.val.a = 3;
        c.f3.tag = TEST_VARIANTS_TO_TEST_Z4_A;
        c.f3.val.a = 4;
        test_variants_to_test_variant_zeros(&c, &ret);
        assert(ret.f0.tag == TEST_VARIANTS_TO_TEST_Z1_A && ret.f0.val.a == 1);
        assert(ret.f1.tag == TEST_VARIANTS_TO_TEST_Z2_A && ret.f1.val.a == 2);
        assert(ret.f2.tag == TEST_VARIANTS_TO_TEST_Z3_A && ret.f2.val.a == 3);
        assert(ret.f3.tag == TEST_VARIANTS_TO_TEST_Z4_A && ret.f3.val.a == 4);
    }

    {
        test_variants_to_test_zeros_t c, ret;
        c.f0.tag = TEST_VARIANTS_TO_TEST_Z1_B;
        c.f1.tag = TEST_VARIANTS_TO_TEST_Z2_B;
        c.f2.tag = TEST_VARIANTS_TO_TEST_Z3_B;
        c.f3.tag = TEST_VARIANTS_TO_TEST_Z4_B;
        test_variants_to_test_variant_zeros(&c, &ret);
        assert(ret.f0.tag == TEST_VARIANTS_TO_TEST_Z1_B);
        assert(ret.f1.tag == TEST_VARIANTS_TO_TEST_Z2_B);
        assert(ret.f2.tag == TEST_VARIANTS_TO_TEST_Z3_B);
        assert(ret.f3.tag == TEST_VARIANTS_TO_TEST_Z4_B);
    }

    {
        bool b = false;
        test_variants_to_test_result_typedef_t c;
        c.is_err = true;
        test_variants_to_test_variant_typedefs(NULL, b, &c);
    }

    {
        test_variants_to_test_tuple3_bool_result_void_void_my_errno_t ret;
        test_variants_to_test_result_void_void_t b;
        b.is_err = false;
        test_variants_to_test_variant_enums(true, &b, TEST_VARIANTS_TO_TEST_MY_ERRNO_SUCCESS, &ret);
        assert(ret.f0 == true);
        assert(!ret.f1.is_err);
        assert(ret.f2 == TEST_VARIANTS_TO_TEST_MY_ERRNO_SUCCESS);
    }
}