bit-struct 0.3.2

Define structs which have fields which are assigned to individual bits, not bytes
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

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

use quickcheck::{Arbitrary, Gen};

bit_struct::enums! {
    pub Color { Orange, Red, Blue, Yellow, Green }
}

bit_struct::bit_struct! {
    struct BitStruct(u32) {
        a_color: Color,
        b: bit_struct::u3,
    }
}

impl Arbitrary for Color {
    fn arbitrary(g: &mut Gen) -> Self {
        *g.choose(&[
            Self::Orange,
            Self::Red,
            Self::Blue,
            Self::Yellow,
            Self::Green,
        ])
        .unwrap()
    }
}

impl Arbitrary for BitStruct {
    fn arbitrary(g: &mut Gen) -> Self {
        let b = *g
            .choose(&[
                bit_struct::u3!(0),
                bit_struct::u3!(1),
                bit_struct::u3!(2),
                bit_struct::u3!(3),
                bit_struct::u3!(4),
                bit_struct::u3!(5),
                bit_struct::u3!(6),
                bit_struct::u3!(7),
            ])
            .unwrap();
        Self::new(Color::arbitrary(g), b)
    }
}

#[quickcheck_macros::quickcheck]
fn test_round_trip_serialize_json_enum(color: Color) -> bool {
    use serde_json::{from_value, to_value};
    let round_trip: Color =
        from_value(to_value(color).expect("Failed to serialize")).expect("Failed to deserialize");
    round_trip == color
}

#[quickcheck_macros::quickcheck]
fn test_round_trip_serialize_postcard_enum(color: Color) -> bool {
    use postcard::{from_bytes, to_allocvec};
    let round_trip: Color = from_bytes(&to_allocvec(&color).expect("Failed to serialize"))
        .expect("Failed to deserialize");
    round_trip == color
}

#[quickcheck_macros::quickcheck]
fn test_round_trip_serialize_json_struct(bits: BitStruct) -> bool {
    use serde_json::{from_value, to_value};
    let round_trip: BitStruct =
        from_value(to_value(bits).expect("Failed to serialize")).expect("Failed to deserialize");
    round_trip == bits
}

#[quickcheck_macros::quickcheck]
fn test_round_trip_serialize_postcard_struct(bits: BitStruct) -> bool {
    use postcard::{from_bytes, to_allocvec};
    let round_trip: BitStruct = from_bytes(&to_allocvec(&bits).expect("Failed to serialize"))
        .expect("Failed to deserialize");
    round_trip == bits
}