bitvec 0.22.3

A crate for manipulating memory, bit by bit
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
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201

//! Unit tests for the `field` module.

use super::*;
use crate::prelude::*;

#[test]
fn get_value() {
	let data = [5u32 << 3, 0x01234567, !5];
	let bits = data.view_bits::<Lsb0>();

	let (head, elem, tail) = bits[3 .. 6].domain().enclave().unwrap();
	let byte = get::<u32, u8>(elem, Lsb0::mask(head, tail), 3);
	assert_eq!(byte, 5u8);

	let (head, body, tail) = bits[32 .. 48].domain().region().unwrap();
	assert!(head.is_none());
	assert!(body.is_empty());
	let (elem, tail) = tail.unwrap();
	let short = get::<u32, u16>(elem, Lsb0::mask(None, tail), 0);
	assert_eq!(short, 0x4567u16);

	let (head, body, tail) = bits[48 .. 64].domain().region().unwrap();
	assert!(tail.is_none());
	assert!(body.is_empty());
	let (head, elem) = head.unwrap();
	let short = get::<u32, u16>(elem, Lsb0::mask(head, None), 16);
	assert_eq!(short, 0x0123u16);

	let (head, body, tail) = bits[64 .. 96].domain().region().unwrap();
	assert!(head.is_none());
	assert_eq!(body, &[!5]);
	assert!(tail.is_none());
}

#[test]
fn set_value() {
	let mut data = [0u32; 3];
	let bits = data.view_bits_mut::<Lsb0>();

	let (head, elem, tail) = bits[3 .. 6].domain_mut().enclave().unwrap();
	set::<u32, u16>(elem, 13u16, Lsb0::mask(head, tail), 3);

	let (head, body, tail) = bits[32 .. 48].domain_mut().region().unwrap();
	assert!(head.is_none());
	assert!(body.is_empty());
	let (elem, tail) = tail.unwrap();
	set::<u32, u16>(elem, 0x4567u16, Lsb0::mask(None, tail), 0);

	let (head, body, tail) = bits[48 .. 64].domain_mut().region().unwrap();
	assert!(tail.is_none());
	assert!(body.is_empty());
	let (head, elem) = head.unwrap();
	set::<u32, u16>(elem, 0x0123u16, Lsb0::mask(head, None), 16);

	assert_eq!(data[0], 5 << 3);
	assert_eq!(data[1], 0x01234567u32);
}

#[test]
fn byte_fields() {
	let mut data = [0u8; 3];

	data.view_bits_mut::<Msb0>()[4 .. 20].store_be(0xABCDu16);
	assert_eq!(data, [0x0A, 0xBC, 0xD0]);
	assert_eq!(data.view_bits::<Msb0>()[4 .. 20].load_be::<u16>(), 0xABCD);

	data.view_bits_mut::<Msb0>()[2 .. 6].store_be(9u8);
	assert_eq!(data, [0x26, 0xBC, 0xD0]);
	assert_eq!(data.view_bits::<Msb0>()[2 .. 6].load_be::<u8>(), 9);

	data = [0; 3];
	data.view_bits_mut::<Lsb0>()[4 .. 20].store_be(0xABCDu16);
	assert_eq!(data, [0xA0, 0xBC, 0x0D]);
	assert_eq!(data.view_bits::<Lsb0>()[4 .. 20].load_be::<u16>(), 0xABCD);

	data.view_bits_mut::<Lsb0>()[2 .. 6].store_be(9u8);
	//  0b1010_0000 | 0b00_1001_00
	assert_eq!(data, [0xA4, 0xBC, 0x0D]);
	assert_eq!(data.view_bits::<Lsb0>()[2 .. 6].load_be::<u8>(), 9);

	data = [0; 3];
	data.view_bits_mut::<Msb0>()[4 .. 20].store_le(0xABCDu16);
	assert_eq!(data, [0x0D, 0xBC, 0xA0]);
	assert_eq!(data.view_bits::<Msb0>()[4 .. 20].load_le::<u16>(), 0xABCD);

	data.view_bits_mut::<Msb0>()[.. 8].set_all(false);
	data.view_bits_mut::<Msb0>()[2 .. 6].store_le(5u8);
	assert_eq!(data[0], 20);
	assert_eq!(data.view_bits::<Msb0>()[2 .. 6].load_le::<u8>(), 5);

	data = [0; 3];
	data.view_bits_mut::<Lsb0>()[4 .. 20].store_le(0xABCDu16);
	assert_eq!(data, [0xD0, 0xBC, 0x0A]);
	assert_eq!(data.view_bits::<Lsb0>()[4 .. 20].load_le::<u16>(), 0xABCD);

	data.view_bits_mut::<Lsb0>()[.. 8].set_all(false);
	data.view_bits_mut::<Lsb0>()[2 .. 6].store_le(5u8);
	assert_eq!(data[0], 20);
	assert_eq!(data.view_bits::<Lsb0>()[2 .. 6].load_le::<u8>(), 5);
}

#[test]
fn narrow_byte_fields() {
	let mut data = [0u16; 2];

	data.view_bits_mut::<Msb0>()[16 .. 24].store_be(0x12u8);
	assert_eq!(data, [0x0000, 0x1200]);
	assert_eq!(data.view_bits::<Msb0>()[16 .. 24].load_be::<u8>(), 0x12);

	data.view_bits_mut::<Msb0>()[8 .. 16].store_be(0x34u8);
	assert_eq!(data, [0x0034, 0x1200]);
	assert_eq!(data.view_bits::<Msb0>()[8 .. 16].load_be::<u8>(), 0x34);

	data.view_bits_mut::<Msb0>()[0 .. 8].store_be(0x56u8);
	assert_eq!(data, [0x5634, 0x1200]);
	assert_eq!(data.view_bits::<Msb0>()[0 .. 8].load_be::<u8>(), 0x56);

	data = [0; 2];

	data.view_bits_mut::<Msb0>()[16 .. 24].store_le(0x12u8);
	assert_eq!(data, [0x0000, 0x1200]);
	assert_eq!(data.view_bits::<Msb0>()[16 .. 24].load_le::<u8>(), 0x12);

	data.view_bits_mut::<Msb0>()[8 .. 16].store_le(0x34u8);
	assert_eq!(data, [0x0034, 0x1200]);
	assert_eq!(data.view_bits::<Msb0>()[8 .. 16].load_le::<u8>(), 0x34);

	data.view_bits_mut::<Msb0>()[0 .. 8].store_le(0x56u8);
	assert_eq!(data, [0x5634, 0x1200]);
	assert_eq!(data.view_bits::<Msb0>()[0 .. 8].load_le::<u8>(), 0x56);

	data = [0; 2];

	data.view_bits_mut::<Lsb0>()[16 .. 24].store_be(0x12u8);
	assert_eq!(data, [0x0000, 0x0012]);
	assert_eq!(data.view_bits::<Lsb0>()[16 .. 24].load_be::<u8>(), 0x12);

	data.view_bits_mut::<Lsb0>()[8 .. 16].store_be(0x34u8);
	assert_eq!(data, [0x3400, 0x0012]);
	assert_eq!(data.view_bits::<Lsb0>()[8 .. 16].load_be::<u8>(), 0x34);

	data.view_bits_mut::<Lsb0>()[0 .. 8].store_be(0x56u8);
	assert_eq!(data, [0x3456, 0x0012]);
	assert_eq!(data.view_bits::<Lsb0>()[0 .. 8].load_be::<u8>(), 0x56);

	data = [0; 2];

	data.view_bits_mut::<Lsb0>()[16 .. 24].store_le(0x12u8);
	assert_eq!(data, [0x0000, 0x0012]);
	assert_eq!(data.view_bits::<Lsb0>()[16 .. 24].load_le::<u8>(), 0x12);

	data.view_bits_mut::<Lsb0>()[8 .. 16].store_le(0x34u8);
	assert_eq!(data, [0x3400, 0x0012]);
	assert_eq!(data.view_bits::<Lsb0>()[8 .. 16].load_le::<u8>(), 0x34);

	data.view_bits_mut::<Lsb0>()[0 .. 8].store_le(0x56u8);
	assert_eq!(data, [0x3456, 0x0012]);
	assert_eq!(data.view_bits::<Lsb0>()[0 .. 8].load_le::<u8>(), 0x56);
}

#[test]
fn wide_load() {
	let mut data = bitarr![Lsb0, u16; 0; 256];
	assert_eq!(data[16 .. 144].load::<u128>(), 0u128);
	data[16 .. 144].store(!0u128);
	assert_eq!(data[16 .. 144].load::<u128>(), !0u128);
}

#[test]
#[should_panic]
#[cfg(not(target_arch = "riscv64"))]
fn check_panic() {
	check::<u8>("fail", 10);
}

#[test]
#[cfg(feature = "alloc")]
fn wrappers() {
	let mut a = bitarr![Msb0, u8; 0; 8];
	let b = bits![1; 8];
	let mut c = bitbox![0; 8];
	let mut d = bitvec![0; 8];

	a.store_le::<u8>(b.load_le::<u8>());
	a.store_be::<u8>(b.load_be::<u8>());
	assert_eq!(a[.. 8], b);
	assert_eq!(a.load_le::<u8>(), !0);
	assert_eq!(a.load_be::<u8>(), !0);

	c.store_le::<u8>(b.load_le::<u8>());
	c.store_be::<u8>(b.load_be::<u8>());
	assert_eq!(c, b);
	assert_eq!(c.load_le::<u8>(), !0);
	assert_eq!(c.load_be::<u8>(), !0);

	d.store_le::<u8>(b.load_le::<u8>());
	d.store_be::<u8>(b.load_be::<u8>());
	assert_eq!(d, b);
	assert_eq!(d.load_le::<u8>(), !0);
	assert_eq!(d.load_be::<u8>(), !0);
}