enum-bitset 0.2.1

Generate efficient bitsets out of your enum types
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
134
135
136
137
138
139

use assert2::check;
use enum_bitset::EnumBitset;

#[derive(EnumBitset, Debug, Copy, Clone)]
#[bitset(serde = false, repr = u16)]
enum CodeComment {
    TodoSinceFirstCommit,
    BlackMagic,
    LateNightRambling,
}


#[test]
fn layout() {
    use std::alloc::Layout;

    assert_eq!(Layout::new::<CodeCommentSet>(), Layout::new::<u16>());
}

#[test]
fn from_repr() {
    check!(CodeCommentSet::from_repr(0).unwrap() == CodeCommentSet::empty());
    check!(
        CodeCommentSet::from_repr(1).unwrap()
            == CodeCommentSet::from([CodeComment::TodoSinceFirstCommit])
    );
    check!(
        CodeCommentSet::from_repr(2).unwrap() == CodeCommentSet::from([CodeComment::BlackMagic])
    );
    check!(
        CodeCommentSet::from_repr(3).unwrap()
            == CodeCommentSet::from([CodeComment::TodoSinceFirstCommit, CodeComment::BlackMagic])
    );
    check!(
        CodeCommentSet::from_repr(4).unwrap()
            == CodeCommentSet::from([CodeComment::LateNightRambling])
    );
    check!(
        CodeCommentSet::from_repr(5).unwrap()
            == CodeCommentSet::from([
                CodeComment::TodoSinceFirstCommit,
                CodeComment::LateNightRambling
            ])
    );
    check!(
        CodeCommentSet::from_repr(6).unwrap()
            == CodeCommentSet::from([CodeComment::LateNightRambling, CodeComment::BlackMagic])
    );
    check!(
        CodeCommentSet::from_repr(7).unwrap()
            == CodeCommentSet::from([
                CodeComment::TodoSinceFirstCommit,
                CodeComment::LateNightRambling,
                CodeComment::BlackMagic
            ])
    );
    check!(CodeCommentSet::from_repr(8) == None);
    check!(CodeCommentSet::from_repr(9) == None);
    check!(CodeCommentSet::from_repr(10000) == None);
}

#[test]
fn from_is_valid_repr() {
    check!(CodeCommentSet::is_valid_repr(0));
    check!(CodeCommentSet::is_valid_repr(1));
    check!(CodeCommentSet::is_valid_repr(2));
    check!(CodeCommentSet::is_valid_repr(3));
    check!(CodeCommentSet::is_valid_repr(4));
    check!(CodeCommentSet::is_valid_repr(5));
    check!(CodeCommentSet::is_valid_repr(6));
    check!(CodeCommentSet::is_valid_repr(7));
    check!(!CodeCommentSet::is_valid_repr(8));
    check!(!CodeCommentSet::is_valid_repr(9));
    check!(!CodeCommentSet::is_valid_repr(10000));
}

#[test]
fn from_from_repr_unchecked() {
    let set = unsafe { CodeCommentSet::from_repr_unchecked(256) };

    check!(!set.contains(CodeComment::TodoSinceFirstCommit));
    check!(!set.contains(CodeComment::BlackMagic));
    check!(!set.contains(CodeComment::LateNightRambling));

    // This is UB, so results might not be what you expect. No variant, but not empty ?!
    check!(set.len() == 1);
    check!(!set.is_empty());
}

#[test]
fn to_repr() {
    check!(CodeCommentSet::empty().to_repr() == 0);
    check!(CodeCommentSet::from([CodeComment::TodoSinceFirstCommit]).to_repr() == 1);
    check!(CodeCommentSet::from([CodeComment::BlackMagic]).to_repr() == 2);
    check!(
        CodeCommentSet::from([CodeComment::TodoSinceFirstCommit, CodeComment::BlackMagic])
            .to_repr()
            == 3
    );
    check!(CodeCommentSet::from([CodeComment::LateNightRambling]).to_repr() == 4);
    check!(
        CodeCommentSet::from([
            CodeComment::TodoSinceFirstCommit,
            CodeComment::LateNightRambling
        ])
        .to_repr()
            == 5
    );
    check!(
        CodeCommentSet::from([CodeComment::LateNightRambling, CodeComment::BlackMagic]).to_repr()
            == 6
    );
    check!(
        CodeCommentSet::from([
            CodeComment::TodoSinceFirstCommit,
            CodeComment::LateNightRambling,
            CodeComment::BlackMagic
        ])
        .to_repr()
            == 7
    );
}


#[test]
fn as_bitset() {
    check!(
        CodeComment::TodoSinceFirstCommit.as_bitset()
            == CodeCommentSet::from_array([CodeComment::TodoSinceFirstCommit])
    );
    check!(
        CodeComment::BlackMagic.as_bitset()
            == CodeCommentSet::from_array([CodeComment::BlackMagic])
    );
    check!(
        CodeComment::LateNightRambling.as_bitset()
            == CodeCommentSet::from_array([CodeComment::LateNightRambling])
    );
}