macroonz-harness 0.2.0

Safe-Rust property, fuzz, fault, schedule, mutation, network, and benchmark testing with typed evidence, reduction, and replay.
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

//! One closed-seat storage and saturating increment mechanism for harness censuses.

macro_rules! declare_census {
    (
        $(#[$census_meta:meta])*
        $visibility:vis struct $census:ident {
            count: $count:ty,
            seat: $seat:ident,
            context { $( $context:ident: $context_type:ty, )* }
            array $counts:ident [$seat_count:expr] {
                $( $variant:ident => $field:ident, )+
            }
        }
    ) => {
        $(#[$census_meta])*
        $visibility struct $census {
            $( $context: $context_type, )*
            $counts: [$count; $seat_count],
        }

        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
        pub(crate) enum $seat {
            $( $variant, )+
        }
    };
    (
        $(#[$census_meta:meta])*
        $visibility:vis struct $census:ident {
            count: $count:ty,
            seat: $seat:ident,
            context { $( $context:ident: $context_type:ty, )* }
            fields {
                $( $variant:ident => $field:ident, )+
            }
        }
    ) => {
        $(#[$census_meta])*
        $visibility struct $census {
            $( $context: $context_type, )*
            $( $field: $count, )+
        }

        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
        pub(crate) enum $seat {
            $( $variant, )+
        }
    };
}

macro_rules! implement_census {
    (
        impl $census:ident {
            count: $count:ty,
            zero: $zero:expr,
            seat: $seat:ident,
            context { $( $context:ident: $context_type:ty, )* }
            array $counts:ident [$seat_count:expr] {
                $( $variant:ident => $field:ident, )+
            }
        }
    ) => {
        impl $census {
            pub(crate) const fn empty($( $context: $context_type, )*) -> Self {
                Self {
                    $( $context, )*
                    $counts: [$zero; $seat_count],
                }
            }

            pub(crate) fn increment(&mut self, seat: $seat, amount: $count) {
                let [$($field),+] = &mut self.$counts;
                match seat {
                    $(
                        $seat::$variant => *$field = $field.saturating_add(amount),
                    )+
                }
            }

            pub(crate) const fn count_at(&self, seat: $seat) -> $count {
                let [$($field),+] = &self.$counts;
                match seat {
                    $(
                        $seat::$variant => *$field,
                    )+
                }
            }
        }
    };
    (
        impl $census:ident {
            count: $count:ty,
            zero: $zero:expr,
            seat: $seat:ident,
            context { $( $context:ident: $context_type:ty, )* }
            fields {
                $( $variant:ident => $field:ident, )+
            }
        }
    ) => {
        impl $census {
            pub(crate) const fn empty($( $context: $context_type, )*) -> Self {
                Self {
                    $( $context, )*
                    $( $field: $zero, )+
                }
            }

            pub(crate) fn increment(&mut self, seat: $seat, amount: $count) {
                match seat {
                    $(
                        $seat::$variant => {
                            self.$field = self.$field.saturating_add(amount);
                        }
                    )+
                }
            }

            pub(crate) const fn count_at(&self, seat: $seat) -> $count {
                match seat {
                    $(
                        $seat::$variant => self.$field,
                    )+
                }
            }
        }
    };
}

pub(crate) use {declare_census, implement_census};