struct_to_array_derive 0.2.0

Derive macro for struct_to_array
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

use quote::quote;
use syn::{DeriveInput, parse_quote};

/// Helper function that expects the macro to fail
fn expect_error(input: DeriveInput, expected_msg_fragment: &str) {
    let result = crate::expand_struct_to_array(&input);
    assert!(
        result.is_err(),
        "Expected error but got success for input:\n{}",
        quote!(#input)
    );
    let err = result.unwrap_err();
    let err_msg = err.to_string();
    assert!(
        err_msg.contains(expected_msg_fragment),
        "Error message '{}' does not contain expected fragment '{}'",
        err_msg,
        expected_msg_fragment
    );
}

#[test]
fn test_unit_struct_fails() {
    let input: DeriveInput = parse_quote! {
        struct UnitStruct;
    };

    expect_error(input, "cannot be derived for unit structs");
}

#[test]
fn test_enum_fails() {
    let input: DeriveInput = parse_quote! {
        enum MyEnum {
            A,
            B,
        }
    };

    expect_error(input, "can only be derived for structs");
}

#[test]
fn test_empty_named_struct_fails() {
    let input: DeriveInput = parse_quote! {
        struct Empty {}
    };

    expect_error(input, "requires at least one field");
}

#[test]
fn test_empty_tuple_struct_fails() {
    let input: DeriveInput = parse_quote! {
        struct Empty();
    };

    expect_error(input, "requires at least one field");
}

#[test]
fn test_mixed_types_named_fails() {
    let input: DeriveInput = parse_quote! {
        struct MixedTypes {
            x: f32,
            y: i32,
        }
    };

    expect_error(input, "identical type tokens");
}

#[test]
fn test_mixed_types_tuple_fails() {
    let input: DeriveInput = parse_quote! {
        struct MixedTypes(String, i32);
    };

    expect_error(input, "identical type tokens");
}

#[test]
fn test_mixed_types_three_fields_first_two_match() {
    let input: DeriveInput = parse_quote! {
        struct MixedTypes {
            a: f32,
            b: f32,
            c: i32,
        }
    };

    expect_error(input, "identical type tokens");
}

#[test]
fn test_mixed_types_three_fields_last_two_match() {
    let input: DeriveInput = parse_quote! {
        struct MixedTypes {
            a: i32,
            b: f32,
            c: f32,
        }
    };

    expect_error(input, "identical type tokens");
}

#[test]
fn test_similar_but_different_types_fail() {
    // Vec<i32> vs Vec<u32> should fail
    let input: DeriveInput = parse_quote! {
        struct SimilarTypes {
            a: Vec<i32>,
            b: Vec<u32>,
        }
    };

    expect_error(input, "identical type tokens");
}

#[test]
fn test_different_references_fail() {
    // &i32 vs &mut i32 should fail
    let input: DeriveInput = parse_quote! {
        struct RefTypes {
            a: &'static i32,
            b: &'static mut i32,
        }
    };

    expect_error(input, "identical type tokens");
}