chapa 0.1.2

Bitfield structs, batteries included!
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

use chapa::{bitfield, BitEnum, BitField};

#[derive(Debug, PartialEq, BitEnum)]
pub enum VideoFormat {
    Ntsc = 0,
    Pal = 1,
    Mpal = 2,
    Debug = 3,
}

#[test]
fn from_raw_valid() {
    assert_eq!(VideoFormat::from_raw(0), VideoFormat::Ntsc);
    assert_eq!(VideoFormat::from_raw(1), VideoFormat::Pal);
    assert_eq!(VideoFormat::from_raw(2), VideoFormat::Mpal);
    assert_eq!(VideoFormat::from_raw(3), VideoFormat::Debug);
}

#[test]
fn from_raw_invalid_uses_last_variant() {
    assert_eq!(VideoFormat::from_raw(4), VideoFormat::Debug);
    assert_eq!(VideoFormat::from_raw(255), VideoFormat::Debug);
}

#[test]
fn raw_roundtrip() {
    for v in [
        VideoFormat::Ntsc,
        VideoFormat::Pal,
        VideoFormat::Mpal,
        VideoFormat::Debug,
    ] {
        assert_eq!(VideoFormat::from_raw(v.raw()), v);
    }
}

#[test]
fn storage_is_u8() {
    let _: u8 = VideoFormat::Ntsc.raw();
}

#[derive(Debug, PartialEq, BitEnum)]
pub enum AutoDiscrim {
    A,
    B,
    C,
}

#[test]
fn auto_discriminants() {
    assert_eq!(AutoDiscrim::A.raw(), 0);
    assert_eq!(AutoDiscrim::B.raw(), 1);
    assert_eq!(AutoDiscrim::C.raw(), 2);
}

#[test]
fn auto_discrim_from_raw() {
    assert_eq!(AutoDiscrim::from_raw(0), AutoDiscrim::A);
    assert_eq!(AutoDiscrim::from_raw(1), AutoDiscrim::B);
    assert_eq!(AutoDiscrim::from_raw(2), AutoDiscrim::C);
    assert_eq!(AutoDiscrim::from_raw(99), AutoDiscrim::C); // fallback
}

#[derive(Debug, PartialEq, BitEnum)]
pub enum Sparse {
    Low = 0,
    Mid = 5,
    High = 10,
}

#[test]
fn sparse_discriminants() {
    assert_eq!(Sparse::Low.raw(), 0);
    assert_eq!(Sparse::Mid.raw(), 5);
    assert_eq!(Sparse::High.raw(), 10);
    assert_eq!(Sparse::from_raw(5), Sparse::Mid);
    assert_eq!(Sparse::from_raw(7), Sparse::High); // fallback
}

// Enum used inside a bitfield struct.
#[bitfield(u16, order = lsb0)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct DisplayConfig {
    #[bits(0)]
    rst: bool,
    #[bits(1..=2)]
    fmt: VideoFormat,
    #[bits(3..=15)]
    _reserved: u16,
}

#[test]
fn enum_in_bitfield_roundtrip() {
    let dc = DisplayConfig::new()
        .with_rst(true)
        .with_fmt(VideoFormat::Mpal);
    assert_eq!(dc.rst(), true);
    assert_eq!(dc.fmt(), VideoFormat::Mpal);
}

#[test]
fn enum_in_bitfield_all_variants() {
    for (variant, expected_raw) in [
        (VideoFormat::Ntsc, 0u8),
        (VideoFormat::Pal, 1),
        (VideoFormat::Mpal, 2),
        (VideoFormat::Debug, 3),
    ] {
        let dc = DisplayConfig::new().with_fmt(variant);
        assert_eq!(dc.fmt(), variant);
        assert_eq!(variant.raw(), expected_raw);
    }
}