arraygen 0.3.2

Derive macro for generating arrays from struct fields.
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

extern crate arraygen;

#[allow(dead_code)]
#[allow(non_snake_case)]
mod tests {
    use arraygen::Arraygen;

    #[test]
    fn test_implicit_select_all___given_f32___returns_all_f32_fields() {
        #[derive(Arraygen)]
        #[gen_array(fn get_all_prices: f32, implicit_select_all: f32)]
        struct ImplicitPrices {
            pub water: f32,
            pub oil: f32,
            pub tomato: f32,
            pub chocolate: f32,
            pub gold: f64,
        }

        let prices = ImplicitPrices {
            water: 2.0,
            oil: 4.0,
            tomato: 3.0,
            chocolate: 5.0,
            gold: 1000.0,
        };

        assert_eq!(prices.get_all_prices().into_iter().sum::<f32>(), 14.0);
    }

    #[test]
    fn test_implicit_select_all___given_wildcard___returns_all_fields() {
        trait All {}

        struct A {}
        struct B {}
        struct C {}

        impl All for A {}
        impl All for B {}
        impl All for C {}

        #[derive(Arraygen)]
        #[gen_array(fn all: &dyn All, implicit_select_all: _)]
        struct Sut {
            pub a: A,
            pub b: B,
            pub c: C,
        }

        let actual = Sut {
            a: A {},
            b: B {},
            c: C {},
        };

        assert_eq!(actual.all().len(), 3);
    }

    #[test]
    fn test_implicit_select_all___given_option_with_wildcard___returns_all_option_fields() {
        trait OptionTrait {}

        impl<T> OptionTrait for Option<T> {}

        #[derive(Arraygen)]
        #[gen_array(fn options: &dyn OptionTrait, implicit_select_all: Option<_>)]
        struct Sut {
            pub a: Option<i32>,
            pub b: Option<bool>,
            pub c: f32,
        }

        let actual = Sut {
            a: Some(1),
            b: Some(false),
            c: 3.0,
        };

        assert_eq!(actual.options().len(), 2);
    }

    #[test]
    fn test_implicit_select_all___given_result_with_wildcard___returns_all_result_fields() {
        #[derive(Arraygen)]
        #[gen_array(fn options: &Result<i32, std::fmt::Error>, implicit_select_all: Result<_, std::fmt::Error>)]
        struct Sut {
            pub a: Result<i32, std::fmt::Error>,
            pub b: f32,
        }

        let actual = Sut { a: Ok(1), b: 3.0 };

        assert_eq!(actual.options().len(), 1);
    }

    #[test]
    fn test_implicit_select_all___with_display_sim_bug_scenario___compiles_as_expected() {
        impl<T> ResetOption for Option<T> {
            fn reset(&mut self) {
                *self = None;
            }
        }

        pub trait ResetOption {
            fn reset(&mut self);
        }

        pub trait Tracked {}
        impl Tracked for i32 {}
        impl Tracked for Result<i32, i32> {}

        #[derive(Arraygen)]
        #[gen_array(pub fn options: &mut dyn ResetOption, implicit_select_all: Option<_>)]
        #[gen_array(pub fn tracked: &mut dyn Tracked, implicit_select_all: i32, Result<i32, i32>)]
        pub struct Sut {
            // tracked
            pub a: Result<i32, i32>,
            pub b: i32,

            // options
            pub c: Option<i32>,
        }

        let mut actual = Sut {
            a: Ok(1),
            b: 3,
            c: Some(1),
        };
        assert_eq!(actual.options().len(), 1);
        assert_eq!(actual.tracked().len(), 2);
    }
}