1 use BitArray;
2 use BitField;
3
4 #[test]
test_integer_bit_lengths()5 fn test_integer_bit_lengths() {
6 assert_eq!(u8::BIT_LENGTH, 8);
7 assert_eq!(u16::BIT_LENGTH, 16);
8 assert_eq!(u32::BIT_LENGTH, 32);
9 assert_eq!(u64::BIT_LENGTH, 64);
10 assert_eq!(u128::BIT_LENGTH, 128);
11
12 assert_eq!(i8::BIT_LENGTH, 8);
13 assert_eq!(i16::BIT_LENGTH, 16);
14 assert_eq!(i32::BIT_LENGTH, 32);
15 assert_eq!(i64::BIT_LENGTH, 64);
16 assert_eq!(i128::BIT_LENGTH, 128);
17 }
18
19 #[test]
test_set_reset_u8()20 fn test_set_reset_u8() {
21 let mut field = 0b11110010u8;
22 let mut bit_i = |i| {
23 field.set_bit(i, true);
24 assert_eq!(field.get_bit(i), true);
25 field.set_bit(i, false);
26 assert_eq!(field.get_bit(i), false);
27 field.set_bit(i, true);
28 assert_eq!(field.get_bit(i), true);
29 };
30 for i in 0..8 {
31 bit_i(i);
32 }
33 }
34
35 #[test]
test_set_reset_u16()36 fn test_set_reset_u16() {
37 let mut field = 0b1111001010010110u16;
38 let mut bit_i = |i| {
39 field.set_bit(i, true);
40 assert_eq!(field.get_bit(i), true);
41 field.set_bit(i, false);
42 assert_eq!(field.get_bit(i), false);
43 field.set_bit(i, true);
44 assert_eq!(field.get_bit(i), true);
45 };
46 for i in 0..16 {
47 bit_i(i);
48 }
49 }
50
51 #[test]
test_read_u32()52 fn test_read_u32() {
53 let field = 0b1111111111010110u32;
54 assert_eq!(field.get_bit(0), false);
55 assert_eq!(field.get_bit(1), true);
56 assert_eq!(field.get_bit(2), true);
57 assert_eq!(field.get_bit(3), false);
58 assert_eq!(field.get_bit(4), true);
59 assert_eq!(field.get_bit(5), false);
60 for i in 6..16 {
61 assert_eq!(field.get_bit(i), true);
62 }
63 for i in 16..32 {
64 assert_eq!(field.get_bit(i), false);
65 }
66
67 assert_eq!(field.get_bits(16..), 0);
68 assert_eq!(field.get_bits(16..32), 0);
69 assert_eq!(field.get_bits(16..=31), 0);
70
71 assert_eq!(field.get_bits(6..16), 0b1111111111);
72 assert_eq!(field.get_bits(6..=15), 0b1111111111);
73
74 assert_eq!(field.get_bits(..6), 0b010110);
75 assert_eq!(field.get_bits(0..6), 0b010110);
76 assert_eq!(field.get_bits(0..=5), 0b010110);
77
78 assert_eq!(field.get_bits(..10), 0b1111010110);
79 assert_eq!(field.get_bits(0..10), 0b1111010110);
80 assert_eq!(field.get_bits(0..=9), 0b1111010110);
81
82 assert_eq!(field.get_bits(5..12), 0b1111110);
83 assert_eq!(field.get_bits(5..=11), 0b1111110);
84 }
85
86 #[test]
test_set_reset_u32()87 fn test_set_reset_u32() {
88 let mut field = 0b1111111111010110u32;
89 let mut bit_i = |i| {
90 field.set_bit(i, true);
91 assert_eq!(field.get_bit(i), true);
92 field.set_bit(i, false);
93 assert_eq!(field.get_bit(i), false);
94 field.set_bit(i, true);
95 assert_eq!(field.get_bit(i), true);
96 };
97 for i in 0..32 {
98 bit_i(i);
99 }
100 }
101
102 #[test]
test_set_range_u32()103 fn test_set_range_u32() {
104 let mut field = 0b1111111111010110u32;
105 field.set_bits(10..15, 0b00000);
106 assert_eq!(field.get_bits(10..15), 0b00000);
107 assert_eq!(field.get_bits(10..=14), 0b00000);
108 field.set_bits(10..15, 0b10101);
109 assert_eq!(field.get_bits(10..15), 0b10101);
110 assert_eq!(field.get_bits(10..=14), 0b10101);
111 field.set_bits(10..15, 0b01010);
112 assert_eq!(field.get_bits(10..15), 0b01010);
113 assert_eq!(field.get_bits(10..=14), 0b01010);
114 field.set_bits(10..15, 0b11111);
115 assert_eq!(field.get_bits(10..15), 0b11111);
116 assert_eq!(field.get_bits(10..=14), 0b11111);
117
118 field.set_bits(10..=14, 0b00000);
119 assert_eq!(field.get_bits(10..15), 0b00000);
120 assert_eq!(field.get_bits(10..=14), 0b00000);
121 field.set_bits(10..=14, 0b10101);
122 assert_eq!(field.get_bits(10..15), 0b10101);
123 assert_eq!(field.get_bits(10..=14), 0b10101);
124 field.set_bits(10..=14, 0b01010);
125 assert_eq!(field.get_bits(10..15), 0b01010);
126 assert_eq!(field.get_bits(10..=14), 0b01010);
127 field.set_bits(10..=14, 0b11111);
128 assert_eq!(field.get_bits(10..15), 0b11111);
129 assert_eq!(field.get_bits(10..=14), 0b11111);
130
131 field.set_bits(0..16, 0xdead);
132 field.set_bits(14..32, 0xbeaf);
133 assert_eq!(field.get_bits(0..16), 0xdead);
134 assert_eq!(field.get_bits(14..32), 0xbeaf);
135
136 field.set_bits(..16, 0xdead);
137 field.set_bits(14.., 0xbeaf);
138 assert_eq!(field.get_bits(..16), 0xdead);
139 assert_eq!(field.get_bits(14..), 0xbeaf);
140 }
141
142 #[test]
test_read_u64()143 fn test_read_u64() {
144 let field = 0b1111111111010110u64 << 32;
145 for i in 0..32 {
146 assert_eq!(field.get_bit(i), false);
147 }
148 assert_eq!(field.get_bit(32), false);
149 assert_eq!(field.get_bit(33), true);
150 assert_eq!(field.get_bit(34), true);
151 assert_eq!(field.get_bit(35), false);
152 assert_eq!(field.get_bit(36), true);
153 assert_eq!(field.get_bit(37), false);
154 for i in 38..48 {
155 assert_eq!(field.get_bit(i), true);
156 }
157 for i in 48..64 {
158 assert_eq!(field.get_bit(i), false);
159 }
160
161 assert_eq!(field.get_bits(..32), 0);
162 assert_eq!(field.get_bits(0..32), 0);
163 assert_eq!(field.get_bits(0..=31), 0);
164
165 assert_eq!(field.get_bits(48..), 0);
166 assert_eq!(field.get_bits(48..64), 0);
167 assert_eq!(field.get_bits(48..=63), 0);
168
169 assert_eq!(field.get_bits(38..48), 0b1111111111);
170 assert_eq!(field.get_bits(38..=47), 0b1111111111);
171
172 assert_eq!(field.get_bits(32..38), 0b010110);
173 assert_eq!(field.get_bits(32..=37), 0b010110);
174
175 assert_eq!(field.get_bits(32..42), 0b1111010110);
176 assert_eq!(field.get_bits(32..=41), 0b1111010110);
177
178 assert_eq!(field.get_bits(37..44), 0b1111110);
179 assert_eq!(field.get_bits(37..=43), 0b1111110);
180 }
181
182 #[test]
test_set_reset_u64()183 fn test_set_reset_u64() {
184 let mut field = 0b1111111111010110u64 << 32;
185 let mut bit_i = |i| {
186 field.set_bit(i, true);
187 assert_eq!(field.get_bit(i), true);
188 field.set_bit(i, false);
189 assert_eq!(field.get_bit(i), false);
190 field.set_bit(i, true);
191 assert_eq!(field.get_bit(i), true);
192 };
193 for i in 0..64 {
194 bit_i(i);
195 }
196 }
197
198 #[test]
test_set_range_u64()199 fn test_set_range_u64() {
200 let mut field = 0b1111111111010110u64 << 32;
201 field.set_bits(42..47, 0b00000);
202 assert_eq!(field.get_bits(42..47), 0b00000);
203 assert_eq!(field.get_bits(42..=46), 0b00000);
204 field.set_bits(10..15, 0b10101);
205 assert_eq!(field.get_bits(10..15), 0b10101);
206 assert_eq!(field.get_bits(10..=14), 0b10101);
207 field.set_bits(40..45, 0b01010);
208 assert_eq!(field.get_bits(40..45), 0b01010);
209 assert_eq!(field.get_bits(40..=44), 0b01010);
210 field.set_bits(40..45, 0b11111);
211 assert_eq!(field.get_bits(40..45), 0b11111);
212 assert_eq!(field.get_bits(40..=44), 0b11111);
213
214 field.set_bits(42..=46, 0b00000);
215 assert_eq!(field.get_bits(42..47), 0b00000);
216 assert_eq!(field.get_bits(42..=46), 0b00000);
217 field.set_bits(10..=14, 0b10101);
218 assert_eq!(field.get_bits(10..15), 0b10101);
219 assert_eq!(field.get_bits(10..=14), 0b10101);
220 field.set_bits(40..=44, 0b01010);
221 assert_eq!(field.get_bits(40..45), 0b01010);
222 assert_eq!(field.get_bits(40..=44), 0b01010);
223 field.set_bits(40..=44, 0b11111);
224 assert_eq!(field.get_bits(40..45), 0b11111);
225 assert_eq!(field.get_bits(40..=44), 0b11111);
226
227 field.set_bits(0..16, 0xdead);
228 field.set_bits(14..32, 0xbeaf);
229 field.set_bits(32..64, 0xcafebabe);
230 assert_eq!(field.get_bits(0..16), 0xdead);
231 assert_eq!(field.get_bits(14..32), 0xbeaf);
232 assert_eq!(field.get_bits(32..64), 0xcafebabe);
233
234 field.set_bits(..16, 0xdead);
235 field.set_bits(14..=31, 0xbeaf);
236 field.set_bits(32.., 0xcafebabe);
237 assert_eq!(field.get_bits(..16), 0xdead);
238 assert_eq!(field.get_bits(14..=31), 0xbeaf);
239 assert_eq!(field.get_bits(32..), 0xcafebabe);
240 }
241
242 #[test]
test_read_u128()243 fn test_read_u128() {
244 let field = 0b1111111111010110u128 << 32;
245 for i in 0..32 {
246 assert_eq!(field.get_bit(i), false);
247 }
248 assert_eq!(field.get_bit(32), false);
249 assert_eq!(field.get_bit(33), true);
250 assert_eq!(field.get_bit(34), true);
251 assert_eq!(field.get_bit(35), false);
252 assert_eq!(field.get_bit(36), true);
253 assert_eq!(field.get_bit(37), false);
254 for i in 38..48 {
255 assert_eq!(field.get_bit(i), true);
256 }
257 for i in 48..64 {
258 assert_eq!(field.get_bit(i), false);
259 }
260
261 assert_eq!(field.get_bits(..32), 0);
262 assert_eq!(field.get_bits(0..32), 0);
263 assert_eq!(field.get_bits(0..=31), 0);
264
265 assert_eq!(field.get_bits(48..), 0);
266 assert_eq!(field.get_bits(48..64), 0);
267 assert_eq!(field.get_bits(48..=63), 0);
268
269 assert_eq!(field.get_bits(38..48), 0b1111111111);
270 assert_eq!(field.get_bits(38..=47), 0b1111111111);
271
272 assert_eq!(field.get_bits(32..38), 0b010110);
273 assert_eq!(field.get_bits(32..=37), 0b010110);
274
275 assert_eq!(field.get_bits(32..42), 0b1111010110);
276 assert_eq!(field.get_bits(32..=41), 0b1111010110);
277
278 assert_eq!(field.get_bits(37..44), 0b1111110);
279 assert_eq!(field.get_bits(37..=43), 0b1111110);
280 }
281
282 #[test]
test_set_reset_u128()283 fn test_set_reset_u128() {
284 let mut field = 0b1111111111010110u128 << 32;
285 let mut bit_i = |i| {
286 field.set_bit(i, true);
287 assert_eq!(field.get_bit(i), true);
288 field.set_bit(i, false);
289 assert_eq!(field.get_bit(i), false);
290 field.set_bit(i, true);
291 assert_eq!(field.get_bit(i), true);
292 };
293 for i in 0..64 {
294 bit_i(i);
295 }
296 }
297
298 #[test]
test_set_range_u128()299 fn test_set_range_u128() {
300 let mut field = 0b1111111111010110u128 << 32;
301 field.set_bits(42..47, 0b00000);
302 assert_eq!(field.get_bits(42..47), 0b00000);
303 assert_eq!(field.get_bits(42..=46), 0b00000);
304 field.set_bits(10..15, 0b10101);
305 assert_eq!(field.get_bits(10..15), 0b10101);
306 assert_eq!(field.get_bits(10..=14), 0b10101);
307 field.set_bits(40..45, 0b01010);
308 assert_eq!(field.get_bits(40..45), 0b01010);
309 assert_eq!(field.get_bits(40..=44), 0b01010);
310 field.set_bits(40..45, 0b11111);
311 assert_eq!(field.get_bits(40..45), 0b11111);
312 assert_eq!(field.get_bits(40..=44), 0b11111);
313
314 field.set_bits(42..=46, 0b00000);
315 assert_eq!(field.get_bits(42..47), 0b00000);
316 assert_eq!(field.get_bits(42..=46), 0b00000);
317 field.set_bits(10..=14, 0b10101);
318 assert_eq!(field.get_bits(10..15), 0b10101);
319 assert_eq!(field.get_bits(10..=14), 0b10101);
320 field.set_bits(40..=44, 0b01010);
321 assert_eq!(field.get_bits(40..45), 0b01010);
322 assert_eq!(field.get_bits(40..=44), 0b01010);
323 field.set_bits(40..=44, 0b11111);
324 assert_eq!(field.get_bits(40..45), 0b11111);
325 assert_eq!(field.get_bits(40..=44), 0b11111);
326
327 field.set_bits(0..16, 0xdead);
328 field.set_bits(14..32, 0xbeaf);
329 field.set_bits(32..64, 0xcafebabe);
330 assert_eq!(field.get_bits(0..16), 0xdead);
331 assert_eq!(field.get_bits(14..32), 0xbeaf);
332 assert_eq!(field.get_bits(32..64), 0xcafebabe);
333
334 field.set_bits(..16, 0xdead);
335 field.set_bits(14..=31, 0xbeaf);
336 field.set_bits(32.., 0xcafebabe);
337 assert_eq!(field.get_bits(..16), 0xdead);
338 assert_eq!(field.get_bits(14..=31), 0xbeaf);
339 assert_eq!(field.get_bits(32..), 0xcafebabe);
340 }
341
342 #[test]
test_array_length()343 fn test_array_length() {
344 assert_eq!((&[2u8, 3u8, 4u8]).bit_length(), 24);
345 assert_eq!((&[2i8, 3i8, 4i8, 5i8]).bit_length(), 32);
346
347 assert_eq!((&[2u16, 3u16, 4u16]).bit_length(), 48);
348 assert_eq!((&[2i16, 3i16, 4i16, 5i16]).bit_length(), 64);
349
350 assert_eq!((&[2u32, 3u32, 4u32]).bit_length(), 96);
351 assert_eq!((&[2i32, 3i32, 4i32, 5i32]).bit_length(), 128);
352
353 assert_eq!((&[2u64, 3u64, 4u64]).bit_length(), 192);
354 assert_eq!((&[2i64, 3i64, 4i64, 5i64]).bit_length(), 256);
355 }
356
357 #[test]
test_set_bit_array()358 fn test_set_bit_array() {
359 let mut test_val = [0xffu8];
360 &test_val.set_bit(0, false);
361 assert_eq!(test_val, [0xfeu8]);
362 &test_val.set_bit(4, false);
363 assert_eq!(test_val, [0xeeu8]);
364
365 let mut test_array = [0xffu8, 0x00u8, 0xffu8];
366 &test_array.set_bit(7, false);
367 &test_array.set_bit(8, true);
368 &test_array.set_bit(16, false);
369
370 assert_eq!(test_array, [0x7fu8, 0x01u8, 0xfeu8]);
371 }
372
373 #[test]
test_get_bit_array()374 fn test_get_bit_array() {
375 let test_val = [0xefu8];
376 assert_eq!(test_val.get_bit(1), true);
377 assert_eq!(test_val.get_bit(4), false);
378
379 let test_array = [0xffu8, 0x00u8, 0xffu8];
380 assert_eq!(test_array.get_bit(7), true);
381 assert_eq!(test_array.get_bit(8), false);
382 assert_eq!(test_array.get_bit(16), true);
383 }
384
385 #[test]
test_set_bits_array()386 fn test_set_bits_array() {
387 let mut test_val = [0xffu8];
388
389 test_val.set_bits(0..4, 0x0u8);
390 assert_eq!(test_val, [0xf0u8]);
391
392 test_val.set_bits(0..4, 0xau8);
393 assert_eq!(test_val, [0xfau8]);
394
395 test_val.set_bits(4..8, 0xau8);
396 assert_eq!(test_val, [0xaau8]);
397
398 test_val.set_bits(.., 0xffu8);
399 assert_eq!(test_val, [0xffu8]);
400
401 test_val.set_bits(2..=5, 0x0u8);
402 assert_eq!(test_val, [0xc3u8]);
403
404 let mut test_array = [0xffu8, 0x00u8, 0xffu8];
405
406 test_array.set_bits(7..9, 0b10);
407 assert_eq!(test_array, [0x7f, 0x01, 0xff]);
408
409 test_array.set_bits(12..20, 0xaa);
410 assert_eq!(test_array, [0x7f, 0xa1, 0xfa]);
411
412 test_array.set_bits(16..24, 0xaa);
413 assert_eq!(test_array, [0x7f, 0xa1, 0xaa]);
414
415 test_array.set_bits(6..14, 0x00);
416 assert_eq!(test_array, [0x3f, 0x80, 0xaa]);
417
418 test_array.set_bits(..4, 0x00);
419 assert_eq!(test_array, [0x30, 0x80, 0xaa]);
420
421 test_array.set_bits(20.., 0x00);
422 assert_eq!(test_array, [0x30, 0x80, 0x0a]);
423
424 test_array.set_bits(7..=11, 0x1f);
425 assert_eq!(test_array, [0xb0, 0x8f, 0x0a]);
426 }
427
428 #[test]
test_get_bits_array()429 fn test_get_bits_array() {
430 let mut test_val = [0xf0u8];
431 assert_eq!(test_val.get_bits(0..4), 0x0u8);
432
433 test_val = [0xfau8];
434 assert_eq!(test_val.get_bits(0..4), 0xau8);
435
436 test_val = [0xaau8];
437 assert_eq!(test_val.get_bits(4..8), 0xau8);
438
439 let mut test_array: [u8; 3] = [0xff, 0x01, 0xff];
440 assert_eq!(test_array.get_bits(7..9), 0b11u8);
441
442 test_array = [0x7f, 0xa1, 0xfa];
443 assert_eq!(test_array.get_bits(12..20), 0xaa);
444
445 test_array = [0x7f, 0xa1, 0xaa];
446 assert_eq!(test_array.get_bits(16..24), 0xaa);
447
448 test_array = [0x3f, 0x80, 0xaa];
449 assert_eq!(test_array.get_bits(6..14), 0x00);
450 }
451