wit-bindgen-cli 0.57.1

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

include!(env!("BINDINGS"));

use crate::test::variants::to_test::*;

struct Component;

export!(Component);

impl Guest for Component {
    fn run() {
        assert_eq!(roundtrip_option(Some(1.0)), Some(1));
        assert_eq!(roundtrip_option(None), None);
        assert_eq!(roundtrip_option(Some(2.0)), Some(2));
        assert_eq!(roundtrip_result(Ok(2)), Ok(2.0));
        assert_eq!(roundtrip_result(Ok(4)), Ok(4.0));
        assert_eq!(roundtrip_result(Err(5.3)), Err(5));

        assert_eq!(roundtrip_enum(E1::A), E1::A);
        assert_eq!(roundtrip_enum(E1::B), E1::B);

        assert_eq!(invert_bool(true), false);
        assert_eq!(invert_bool(false), true);

        let (a1, a2, a3, a4, a5, a6) =
            variant_casts((C1::A(1), C2::A(2), C3::A(3), C4::A(4), C5::A(5), C6::A(6.0)));
        assert!(matches!(a1, C1::A(1)));
        assert!(matches!(a2, C2::A(2)));
        assert!(matches!(a3, C3::A(3)));
        assert!(matches!(a4, C4::A(4)));
        assert!(matches!(a5, C5::A(5)));
        assert!(matches!(a6, C6::A(b) if b == 6.0));

        let (a1, a2, a3, a4, a5, a6) = variant_casts((
            C1::B(1),
            C2::B(2.0),
            C3::B(3.0),
            C4::B(4.0),
            C5::B(5.0),
            C6::B(6.0),
        ));
        assert!(matches!(a1, C1::B(1)));
        assert!(matches!(a2, C2::B(b) if b == 2.0));
        assert!(matches!(a3, C3::B(b) if b == 3.0));
        assert!(matches!(a4, C4::B(b) if b == 4.0));
        assert!(matches!(a5, C5::B(b) if b == 5.0));
        assert!(matches!(a6, C6::B(b) if b == 6.0));

        let (a1, a2, a3, a4) = variant_zeros((Z1::A(1), Z2::A(2), Z3::A(3.0), Z4::A(4.0)));
        assert!(matches!(a1, Z1::A(1)));
        assert!(matches!(a2, Z2::A(2)));
        assert!(matches!(a3, Z3::A(b) if b == 3.0));
        assert!(matches!(a4, Z4::A(b) if b == 4.0));

        let (a1, a2, a3, a4) = variant_zeros((Z1::B, Z2::B, Z3::B, Z4::B));
        assert!(matches!(a1, Z1::B));
        assert!(matches!(a2, Z2::B));
        assert!(matches!(a3, Z3::B));
        assert!(matches!(a4, Z4::B));

        variant_typedefs(None, false, Err(()));

        assert_eq!(
            variant_enums(true, Ok(()), MyErrno::Success),
            (true, Ok(()), MyErrno::Success)
        );
    }
}