zlink 0.4.0

Async Varlink API
Documentation 
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
134
135
136
137
138
139
140
141
142
143
144
145
146

#![cfg(feature = "introspection")]

//! Integration test to verify end-to-end Type functionality.
//!
//! This test verifies that:
//! 1. The Type trait and derive macro are both available from zlink::introspect
//! 2. They work together seamlessly
//! 3. The macro generates correct Type implementations
//! 4. Both simple and complex types work as expected

use zlink::{idl, introspect::Type};

#[derive(Type)]
#[allow(dead_code)]
struct Person {
    name: String,
    age: u32,
    email: Option<String>,
}

#[derive(Type)]
struct Unit;

#[derive(Type)]
#[allow(dead_code)]
enum Status {
    Active,
    Inactive,
    Pending,
}

#[derive(Type)]
#[allow(dead_code)]
struct Complex {
    id: u64,
    tags: Vec<String>,
    metadata: Option<Vec<String>>,
    active: bool,
}

#[test]
fn type_integration() {
    // Test that TYPE is available and returns correct type
    match Person::TYPE {
        idl::Type::Object(fields) => {
            let field_vec: Vec<_> = fields.iter().collect();
            assert_eq!(field_vec.len(), 3);

            assert_eq!(field_vec[0].name(), "name");
            assert_eq!(field_vec[0].ty(), &idl::Type::String);

            assert_eq!(field_vec[1].name(), "age");
            assert_eq!(field_vec[1].ty(), &idl::Type::Int);

            assert_eq!(field_vec[2].name(), "email");
            match field_vec[2].ty() {
                idl::Type::Optional(inner) => assert_eq!(inner.inner(), &idl::Type::String),
                _ => panic!("Expected optional type"),
            }
        }
        _ => panic!("Expected struct type"),
    }

    // Test unit struct
    match Unit::TYPE {
        idl::Type::Object(fields) => {
            assert_eq!(fields.len(), 0);
        }
        _ => panic!("Expected struct type"),
    }

    // Test complex types
    match Complex::TYPE {
        idl::Type::Object(fields) => {
            let field_vec: Vec<_> = fields.iter().collect();
            assert_eq!(field_vec.len(), 4);

            // Test Vec<String> field
            assert_eq!(field_vec[1].name(), "tags");
            match field_vec[1].ty() {
                idl::Type::Array(inner) => assert_eq!(inner.inner(), &idl::Type::String),
                _ => panic!("Expected array type"),
            }

            // Test Option<Vec<String>> field
            assert_eq!(field_vec[2].name(), "metadata");
            match field_vec[2].ty() {
                idl::Type::Optional(optional_inner) => match optional_inner.inner() {
                    idl::Type::Array(array_inner) => {
                        assert_eq!(array_inner.inner(), &idl::Type::String)
                    }
                    _ => panic!("Expected array inside optional"),
                },
                _ => panic!("Expected optional type"),
            }
        }
        _ => panic!("Expected struct type"),
    }
}

#[test]
fn const_compatibility() {
    // Verify that TYPE can be used in const contexts
    const _PERSON_TYPE: &idl::Type<'static> = Person::TYPE;
    const _UNIT_TYPE: &idl::Type<'static> = Unit::TYPE;
    const _COMPLEX_TYPE: &idl::Type<'static> = Complex::TYPE;
}

#[test]
fn trait_and_macro_same_name() {
    // This test verifies that we can import both the trait and macro
    // with the same name from the same module, just like zvariant does
    use zlink::introspect::Type; // This imports both trait and macro

    #[derive(Type)]
    #[allow(dead_code)]
    struct Local {
        value: i32,
    }

    // Use the trait method
    match Local::TYPE {
        idl::Type::Object(fields) => {
            let field_vec: Vec<_> = fields.iter().collect();
            assert_eq!(field_vec.len(), 1);
            assert_eq!(field_vec[0].name(), "value");
            assert_eq!(field_vec[0].ty(), &idl::Type::Int);
        }
        _ => panic!("Expected struct type"),
    }
}

#[test]
fn enum_type_integration() {
    // This test verifies that enum Type works with the main API
    match Status::TYPE {
        idl::Type::Enum(variants) => {
            let variant_vec: Vec<_> = variants.iter().collect();
            assert_eq!(variant_vec.len(), 3);
            assert_eq!(variant_vec[0].name(), "Active");
            assert_eq!(variant_vec[1].name(), "Inactive");
            assert_eq!(variant_vec[2].name(), "Pending");
        }
        _ => panic!("Expected enum type for Status"),
    }
}