bitpattern 0.1.0

bitwise pattern matching and extracting
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

use bitpattern::bitpattern;

#[test]
fn test_bit1() {
    let x = 0u8;
    assert_eq!(bitpattern!("0", x), Some(()));
    assert_eq!(bitpattern!("1", x), None);
    assert_eq!(bitpattern!("?", x), Some(()));
    assert_eq!(bitpattern!("a", x), Some(0));
    let x = 1;
    assert_eq!(bitpattern!("0", x), None);
    assert_eq!(bitpattern!("1", x), Some(()));
    assert_eq!(bitpattern!("?", x), Some(()));
    assert_eq!(bitpattern!("a", x), Some(1));
}

#[test]
fn test_bit8() {
    let x = 0xacu8;
    assert_eq!(bitpattern!("10101100", x), Some(()));
    assert_eq!(bitpattern!("10100100", x), None);
    assert_eq!(bitpattern!("1?101?00", x), Some(()));
    assert_eq!(bitpattern!("1a101100", x), Some(0));
    assert_eq!(bitpattern!("1ab011c0", x), Some((0, 1, 0)));
    assert_eq!(bitpattern!("1ab0?1c?", x), Some((0, 1, 0)));
    assert_eq!(bitpattern!("aaa01bb0", x), Some((5, 2)));
}

#[test]
fn test_bit16() {
    let x = 0xacf0u16;
    assert_eq!(bitpattern!("1010_1100_1111_0000", x), Some(()));
    assert_eq!(bitpattern!("1010_0100_1111_0000", x), None);
    assert_eq!(bitpattern!("1?10_1?00_1?11_0??0", x), Some(()));
    assert_eq!(bitpattern!("1a10_1100_1111_0000", x), Some(0));
    assert_eq!(bitpattern!("1ab0_11c0_1111_0000", x), Some((0, 1, 0)));
    assert_eq!(bitpattern!("1ab0_?1c?_1111_0000", x), Some((0, 1, 0)));
    assert_eq!(bitpattern!("aaa0_1bb0_111x_xxxx", x), Some((5, 2, 16)));
}

#[test]
fn test_bit32() {
    let x = 0xacf0acf0u32;
    assert_eq!(
        bitpattern!("1010_1100_1111_0000_1010_1100_1111_0000", x),
        Some(())
    );
    assert_eq!(
        bitpattern!("1010_0100_1111_0000_1010_0100_1111_0000", x),
        None
    );
    assert_eq!(
        bitpattern!("1?10_1?00_1?11_0??0_1?10_1?00_1?11_0??0", x),
        Some(())
    );
    assert_eq!(
        bitpattern!("1a10_1100_1111_0000_1a10_1100_1111_0000", x),
        Some((0, 0))
    );
    assert_eq!(
        bitpattern!("1ab0_11c0_1111_0000_1ab0_11c0_1111_0000", x),
        Some((0, 1, 0, 0, 1, 0))
    );
    assert_eq!(
        bitpattern!("1ab0_?1c?_1111_0000_1ab0_?1c?_1111_0000", x),
        Some((0, 1, 0, 0, 1, 0))
    );
    assert_eq!(
        bitpattern!("aaa0_1bb0_111x_xxxx_aaa0_1bb0_111x_xxxx", x),
        Some((5, 2, 16, 5, 2, 16))
    );
}

#[test]
fn test_bit64() {
    let x = 0xacf0acf0acf0acf0u64;
    assert_eq!(
        bitpattern!(
            "1010_1100_1111_0000_1010_1100_1111_0000_1010_1100_1111_0000_1010_1100_1111_0000",
            x
        ),
        Some(())
    );
    assert_eq!(
        bitpattern!(
            "1010_0100_1111_0000_1010_0100_1111_0000_1010_0100_1111_0000_1010_0100_1111_0000",
            x
        ),
        None
    );
    assert_eq!(
        bitpattern!(
            "1?10_1?00_1?11_0??0_1?10_1?00_1?11_0??0_1?10_1?00_1?11_0??0_1?10_1?00_1?11_0??0",
            x
        ),
        Some(())
    );
    assert_eq!(
        bitpattern!(
            "1a10_1100_1111_0000_1a10_1100_1111_0000_1a10_1100_1111_0000_1a10_1100_1111_0000",
            x
        ),
        Some((0, 0, 0, 0))
    );
    assert_eq!(
        bitpattern!(
            "1ab0_11c0_1111_0000_1ab0_11c0_1111_0000_1ab0_11c0_1111_0000_1ab0_11c0_1111_0000",
            x
        ),
        Some((0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0))
    );
    assert_eq!(
        bitpattern!(
            "1ab0_?1c?_1111_0000_1ab0_?1c?_1111_0000_1ab0_?1c?_1111_0000_1ab0_?1c?_1111_0000",
            x
        ),
        Some((0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0))
    );
    assert_eq!(
        bitpattern!(
            "aaa0_1bb0_111x_xxxx_aaa0_1bb0_111x_xxxx_aaa0_1bb0_111x_xxxx_aaa0_1bb0_111x_xxxx",
            x
        ),
        Some((5, 2, 16, 5, 2, 16, 5, 2, 16, 5, 2, 16))
    );
}

#[test]
fn test_bit128() {
    let x = 0xacf0acf0acf0acf0acf0acf0acf0acf0u128;
    assert_eq!( bitpattern!( "1010_1100_1111_0000_1010_1100_1111_0000_1010_1100_1111_0000_1010_1100_1111_0000_1010_1100_1111_0000_1010_1100_1111_0000_1010_1100_1111_0000_1010_1100_1111_0000", x), Some(()));
    assert_eq!( bitpattern!( "1010_0100_1111_0000_1010_0100_1111_0000_1010_0100_1111_0000_1010_0100_1111_0000_1010_0100_1111_0000_1010_0100_1111_0000_1010_0100_1111_0000_1010_0100_1111_0000", x), None);
    assert_eq!( bitpattern!( "1?10_1?00_1?11_0??0_1?10_1?00_1?11_0??0_1?10_1?00_1?11_0??0_1?10_1?00_1?11_0??0_1?10_1?00_1?11_0??0_1?10_1?00_1?11_0??0_1?10_1?00_1?11_0??0_1?10_1?00_1?11_0??0", x), Some(()));
    assert_eq!( bitpattern!( "1a10_1100_1111_0000_1a10_1100_1111_0000_1a10_1100_1111_0000_1a10_1100_1111_0000_1a10_1100_1111_0000_1a10_1100_1111_0000_1a10_1100_1111_0000_1a10_1100_1111_0000", x), Some((0, 0, 0, 0, 0, 0, 0, 0)));
}

#[test]
fn test_readme() {
    let x = 0xacu8; // 10101100

    // '0' means the bit must be 0.
    // '1' means the bit must be 1.
    // '_' can be uses as separator.
    assert_eq!(bitpattern!("1010_1100", x), Some(()));
    assert_eq!(bitpattern!("1010_0100", x), None);

    // '?' means the bit can be 0 or 1.
    assert_eq!(bitpattern!("1?10_1?00", x), Some(()));

    // Other charactors can be used for extracting.
    // 'a' extracts a single bit.
    assert_eq!(bitpattern!("1a10_1100", x), Some(0));
    assert_eq!(bitpattern!("10a0_1100", x), Some(1));

    // Multi-bit extracting by continuous charactors.
    assert_eq!(bitpattern!("1aaa_a100", x), Some(5));

    // Multiple extracting.
    assert_eq!(bitpattern!("1aa0_aa00", x), Some((1, 3)));

    // If the extracting fields are adjacent, the different charactors can be used.
    assert_eq!(bitpattern!("1aab_bccc", x), Some((1, 1, 4)));
}

#[test]
fn test_expr() {
    let x = 0xacu8;
    let y = 0x1;
    assert_eq!(bitpattern!("10101101", x + y), Some(()));
    assert_eq!(bitpattern!("10100101", x + y), None);
    assert_eq!(bitpattern!("1?101?01", x + y), Some(()));
    assert_eq!(bitpattern!("1a101101", x + y), Some(0));
    assert_eq!(bitpattern!("1ab011c1", x + y), Some((0, 1, 0)));
    assert_eq!(bitpattern!("1ab0?1c?", x + y), Some((0, 1, 0)));
    assert_eq!(bitpattern!("aaa01bb1", x + y), Some((5, 2)));

    assert_eq!(bitpattern!("10101101", 0xad), Some(()));
    assert_eq!(bitpattern!("10100101", 0xad), None);
    assert_eq!(bitpattern!("1?101?01", 0xad), Some(()));
    assert_eq!(bitpattern!("1a101101", 0xad), Some(0));
    assert_eq!(bitpattern!("1ab011c1", 0xad), Some((0, 1, 0)));
    assert_eq!(bitpattern!("1ab0?1c?", 0xad), Some((0, 1, 0)));
    assert_eq!(bitpattern!("aaa01bb1", 0xad), Some((5, 2)));
}