Debian Codegraph @

.cargo/vendor/bitstream-io/tests/roundtrip.rs

raw
1 // Copyright 2017 Brian Langenberger
2 //
3 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
4 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
5 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
6 // option. This file may not be copied, modified, or distributed
7 // except according to those terms.
8
9 use bitstream_io::{
10 BigEndian, BitRead, BitReader, BitWrite, BitWriter, Endianness, Integer, LittleEndian,
11 Primitive,
12 };
13
14 fn roundtrip<E: Endianness>() {
15 /*unsigned values*/
16 for bits in 1..17 {
17 let max = 1 << bits;
18 let mut output: Vec<u8> = Vec::with_capacity(max);
19 {
20 let mut writer = BitWriter::<_, E>::new(&mut output);
21 for value in 0..max {
22 writer.write_var(bits, value as u32).unwrap();
23 }
24 writer.byte_align().unwrap();
25 }
26 {
27 let mut reader = BitReader::<_, E>::new(output.as_slice());
28 for value in 0..max {
29 assert_eq!(reader.read_var::<u32>(bits).unwrap(), value as u32);
30 }
31 }
32 }
33
34 /*signed values*/
35 for bits in 2..17 {
36 let min = -1i32 << (bits - 1);
37 let max = 1i32 << (bits - 1);
38 let mut output: Vec<u8> = Vec::with_capacity(max as usize);
39 {
40 let mut writer = BitWriter::<_, E>::new(&mut output);
41 for value in min..max {
42 writer.write_signed_var(bits, value as i32).unwrap();
43 }
44 writer.byte_align().unwrap();
45 }
46 {
47 let mut reader = BitReader::<_, E>::new(output.as_slice());
48 for value in min..max {
49 assert_eq!(reader.read_signed_var::<i32>(bits).unwrap(), value as i32);
50 }
51 }
52 }
53 }
54
55 #[test]
56 fn test_rountrip_be() {
57 roundtrip::<BigEndian>();
58 }
59
60 #[test]
61 fn test_roundtrip_le() {
62 roundtrip::<LittleEndian>();
63 }
64
65 fn wide_roundtrip<const BITS: u32, E, I>(start: I, end: I, increment: I)
66 where
67 E: Endianness,
68 I: Integer
69 + Copy
70 + std::fmt::Debug
71 + std::ops::AddAssign
72 + std::cmp::PartialEq
73 + std::cmp::PartialOrd,
74 {
75 let mut w = BitWriter::<Vec<u8>, E>::new(vec![]);
76 // add an extra bit to check non byte-aligned values
77 w.write_bit(true).unwrap();
78 let mut v = start;
79 while v < end {
80 w.write::<BITS, I>(v).unwrap();
81 v += increment;
82 }
83 w.byte_align().unwrap();
84
85 let vec = w.into_writer();
86 let mut r = BitReader::<_, E>::new(vec.as_slice());
87 assert_eq!(r.read_bit().unwrap(), true);
88 let mut v = start;
89 while v < end {
90 assert_eq!(r.read::<BITS, I>().unwrap(), v);
91 v += increment;
92 }
93 }
94
95 #[test]
96 fn test_roundtrip_u7_be() {
97 wide_roundtrip::<7, BigEndian, u8>(u8::MIN, u8::MAX / 2, 1);
98 }
99
100 #[test]
101 fn test_roundtrip_u7_le() {
102 wide_roundtrip::<7, LittleEndian, u8>(u8::MIN, u8::MAX / 2, 1);
103 }
104
105 #[test]
106 fn test_roundtrip_u8_be() {
107 wide_roundtrip::<8, BigEndian, u8>(u8::MIN, u8::MAX, 1);
108 }
109
110 #[test]
111 fn test_roundtrip_u8_le() {
112 wide_roundtrip::<8, LittleEndian, u8>(u8::MIN, u8::MAX, 1);
113 }
114
115 #[test]
116 fn test_roundtrip_i8_be() {
117 wide_roundtrip::<8, BigEndian, i8>(i8::MIN, i8::MAX, 1);
118 }
119
120 #[test]
121 fn test_roundtrip_i8_le() {
122 wide_roundtrip::<8, LittleEndian, i8>(i8::MIN, i8::MAX, 1);
123 }
124
125 #[test]
126 fn test_roundtrip_u9_be() {
127 wide_roundtrip::<9, BigEndian, u16>(u16::MIN, u8::MAX as u16 * 2, 1);
128 }
129
130 #[test]
131 fn test_roundtrip_u9_le() {
132 wide_roundtrip::<9, LittleEndian, u16>(u16::MIN, u8::MAX as u16 * 2, 1);
133 }
134
135 #[test]
136 fn test_roundtrip_u15_be() {
137 wide_roundtrip::<15, BigEndian, u16>(u16::MIN, u16::MAX / 2, 1);
138 }
139
140 #[test]
141 fn test_roundtrip_u15_le() {
142 wide_roundtrip::<15, LittleEndian, u16>(u16::MIN, u16::MAX / 2, 1);
143 }
144
145 #[test]
146 fn test_roundtrip_u16_be() {
147 wide_roundtrip::<16, BigEndian, u16>(u16::MIN, u16::MAX, 1);
148 }
149
150 #[test]
151 fn test_roundtrip_u16_le() {
152 wide_roundtrip::<16, LittleEndian, u16>(u16::MIN, u16::MAX, 1);
153 }
154
155 #[test]
156 fn test_roundtrip_i16_be() {
157 wide_roundtrip::<16, BigEndian, i16>(i16::MIN, i16::MAX, 1);
158 }
159
160 #[test]
161 fn test_roundtrip_i16_le() {
162 wide_roundtrip::<16, LittleEndian, i16>(i16::MIN, i16::MAX, 1);
163 }
164
165 #[test]
166 fn test_roundtrip_u32_be() {
167 wide_roundtrip::<32, BigEndian, u32>(u32::MIN, u32::MAX - 65536, 65536);
168 }
169
170 #[test]
171 fn test_roundtrip_u32_le() {
172 wide_roundtrip::<32, LittleEndian, u32>(u32::MIN, u32::MAX - 65536, 65536);
173 }
174
175 #[test]
176 fn test_roundtrip_i32_be() {
177 wide_roundtrip::<32, BigEndian, i32>(i32::MIN, i32::MAX - 65536, 65536);
178 }
179
180 #[test]
181 fn test_roundtrip_i32_le() {
182 wide_roundtrip::<32, LittleEndian, i32>(i32::MIN, i32::MAX - 65536, 65536);
183 }
184
185 #[test]
186 fn test_roundtrip_u64_be() {
187 wide_roundtrip::<64, BigEndian, u64>(u64::MIN, u64::MAX - u64::MAX / 65536, u64::MAX / 65536);
188 }
189
190 #[test]
191 fn test_roundtrip_u64_le() {
192 wide_roundtrip::<64, LittleEndian, u64>(
193 u64::MIN,
194 u64::MAX - u64::MAX / 65536,
195 u64::MAX / 65536,
196 );
197 }
198
199 #[test]
200 fn test_roundtrip_i64_be() {
201 wide_roundtrip::<64, BigEndian, i64>(i64::MIN, i64::MAX - i64::MAX / 65536, i64::MAX / 65536);
202 }
203
204 #[test]
205 fn test_roundtrip_i64_le() {
206 wide_roundtrip::<64, LittleEndian, i64>(
207 i64::MIN,
208 i64::MAX - i64::MAX / 65536,
209 i64::MAX / 65536,
210 );
211 }
212
213 #[test]
214 fn test_roundtrip_u128_be() {
215 wide_roundtrip::<128, BigEndian, u128>(
216 u128::MIN,
217 u128::MAX - u128::MAX / 65536,
218 u128::MAX / 65536,
219 );
220 }
221
222 #[test]
223 fn test_roundtrip_u128_le() {
224 wide_roundtrip::<128, LittleEndian, u128>(
225 u128::MIN,
226 u128::MAX - u128::MAX / 65536,
227 u128::MAX / 65536,
228 );
229 }
230
231 #[test]
232 fn test_roundtrip_i128_be() {
233 wide_roundtrip::<128, BigEndian, i128>(
234 i128::MIN,
235 i128::MAX - i128::MAX / 65536,
236 i128::MAX / 65536,
237 );
238 }
239
240 #[test]
241 fn test_roundtrip_i128_le() {
242 wide_roundtrip::<128, LittleEndian, i128>(
243 i128::MIN,
244 i128::MAX - i128::MAX / 65536,
245 i128::MAX / 65536,
246 );
247 }
248
249 fn unary<E: Endianness>() {
250 let mut output: Vec<u8> = Vec::new();
251 {
252 let mut writer = BitWriter::<_, E>::new(&mut output);
253 for value in 0..1024 {
254 writer.write_unary::<0>(value).unwrap();
255 }
256 writer.byte_align().unwrap();
257 }
258 {
259 let mut c = output.as_slice();
260 let mut reader = BitReader::<_, E>::new(&mut c);
261 for value in 0..1024 {
262 assert_eq!(reader.read_unary::<0>().unwrap(), value);
263 }
264 }
265
266 let mut output: Vec<u8> = Vec::new();
267 {
268 let mut writer = BitWriter::<_, E>::new(&mut output);
269 for value in 0..1024 {
270 writer.write_unary::<1>(value).unwrap();
271 }
272 writer.byte_align().unwrap();
273 }
274 {
275 let mut c = output.as_slice();
276 let mut reader = BitReader::<_, E>::new(&mut c);
277 for value in 0..1024 {
278 assert_eq!(reader.read_unary::<1>().unwrap(), value);
279 }
280 }
281 }
282
283 #[test]
284 fn test_unary_roundtrip_be() {
285 unary::<BigEndian>()
286 }
287
288 #[test]
289 fn test_unary_roundtrip_le() {
290 unary::<LittleEndian>()
291 }
292
293 fn float<E, P>()
294 where
295 E: Endianness,
296 P: Primitive + From<u16> + core::fmt::Debug + core::cmp::PartialEq,
297 {
298 let mut output: Vec<u8> = Vec::new();
299 {
300 let mut writer = BitWriter::<_, E>::new(&mut output);
301 // these values should all be exact in floating-point
302 for value in 0..1024 {
303 writer.write_from(P::from(value)).unwrap();
304 }
305 writer.byte_align().unwrap();
306 }
307 {
308 let mut c = output.as_slice();
309 let mut reader = BitReader::<_, E>::new(&mut c);
310 for value in 0..1024 {
311 assert_eq!(reader.read_to::<P>().unwrap(), P::from(value));
312 }
313 }
314 }
315
316 #[test]
317 fn test_f32_roundtrip_be() {
318 float::<BigEndian, f32>()
319 }
320
321 #[test]
322 fn test_f64_roundtrip_be() {
323 float::<BigEndian, f64>()
324 }
325
326 #[test]
327 fn test_f32_roundtrip_le() {
328 float::<LittleEndian, f32>()
329 }
330
331 #[test]
332 fn test_f64_roundtrip_le() {
333 float::<LittleEndian, f64>()
334 }
335
336 #[test]
337 fn test_auto_signedness() {
338 use bitstream_io::{
339 BigEndian, BitRead, BitReader, BitWrite, BitWriter, Endianness, Integer, LittleEndian,
340 SignedInteger, UnsignedInteger,
341 };
342
343 macro_rules! define_roundtrip {
344 ($n:ident, $i:ident, $w:ident, $r:ident) => {
345 fn $n<I: Integer + $i + core::ops::AddAssign, E: Endianness>(
346 mut start: I,
347 end: I,
348 bits: u32,
349 ) {
350 let mut w: BitWriter<_, E> = BitWriter::new(Vec::new());
351 w.write_bit(true).unwrap();
352 let mut i = start;
353 while i < end {
354 w.$w(bits, i).unwrap();
355 i += I::ONE;
356 }
357 w.$w(bits, end).unwrap();
358
359 w.byte_align().unwrap();
360
361 let v = w.into_writer();
362 let mut r: BitReader<_, E> = BitReader::new(v.as_slice());
363 assert_eq!(r.read_bit().unwrap(), true);
364 while start < end {
365 assert_eq!(r.$r::<I>(bits).unwrap(), start);
366 start += I::ONE;
367 }
368 assert_eq!(r.$r::<I>(bits).unwrap(), end);
369 }
370 };
371 }
372
373 define_roundtrip!(
374 test_writer_unsigned,
375 UnsignedInteger,
376 write_var,
377 read_unsigned_var
378 );
379 test_writer_unsigned::<_, BigEndian>(u8::MIN, u8::MAX, 8);
380 test_writer_unsigned::<_, LittleEndian>(u8::MIN, u8::MAX, 8);
381
382 define_roundtrip!(
383 test_writer_signed,
384 SignedInteger,
385 write_var,
386 read_signed_var
387 );
388 test_writer_signed::<_, BigEndian>(i8::MIN, i8::MAX, 8);
389 test_writer_signed::<_, LittleEndian>(i8::MIN, i8::MAX, 8);
390
391 define_roundtrip!(
392 test_reader_unsigned,
393 UnsignedInteger,
394 write_unsigned_var,
395 read_var
396 );
397 test_reader_unsigned::<_, BigEndian>(u8::MIN, u8::MAX, 8);
398 test_reader_unsigned::<_, LittleEndian>(u8::MIN, u8::MAX, 8);
399
400 define_roundtrip!(
401 test_reader_signed,
402 SignedInteger,
403 write_signed_var,
404 read_var
405 );
406 test_reader_signed::<_, BigEndian>(i8::MIN, i8::MAX, 8);
407 test_reader_signed::<_, LittleEndian>(i8::MIN, i8::MAX, 8);
408 }
409
410 #[test]
411 fn test_bit_count() {
412 use bitstream_io::{BigEndian, BitRead, BitReader, BitWrite, BitWriter};
413
414 let data: &[u8] = &[0b1111_0000];
415
416 // read a count from a 4-bit field
417 let count = BitReader::endian(data, BigEndian)
418 .read_count::<0b1111>()
419 .unwrap();
420 assert_eq!(u32::from(count), 0b1111);
421
422 // increment it by 1
423 let count = count.try_map::<16, _>(|i| i.checked_add(1)).unwrap();
424 assert_eq!(u32::from(count), 0b1111 + 1);
425
426 // decrement it by 1
427 let count = count.try_map::<0b1111, _>(|i| i.checked_sub(1)).unwrap();
428 assert_eq!(u32::from(count), 0b1111);
429
430 // write the count back to disk
431 let mut w = BitWriter::endian(vec![], BigEndian);
432 w.write_count::<0b1111>(count).unwrap();
433 w.byte_align().unwrap();
434 assert_eq!(w.into_writer(), data);
435 }
436
437 fn test_primitives<E: Endianness>() {
438 use bitstream_io::{BitRead, BitReader, BitWrite, BitWriter};
439
440 // try a lot of primitive values, shifted by 1 bit
441 let mut w = BitWriter::<Vec<u8>, E>::new(vec![]);
442 w.write_bit(true).unwrap();
443 w.write_from::<u8>(u8::MAX - 10).unwrap();
444 w.write_from::<u16>(u16::MAX - 10).unwrap();
445 w.write_from::<u32>(u32::MAX - 10).unwrap();
446 w.write_from::<u64>(u64::MAX - 10).unwrap();
447 w.write_from::<u128>(u128::MAX - 10).unwrap();
448 w.write_from::<i8>(i8::MAX - 10).unwrap();
449 w.write_from::<i16>(i16::MAX - 10).unwrap();
450 w.write_from::<i32>(i32::MAX - 10).unwrap();
451 w.write_from::<i64>(i64::MAX - 10).unwrap();
452 w.write_from::<i128>(i128::MAX - 10).unwrap();
453 w.write_from::<f32>(1.0).unwrap();
454 w.write_from::<f64>(2.0).unwrap();
455 w.write_from::<[u8; 3]>([9, 8, 7]).unwrap();
456 w.byte_align().unwrap();
457
458 let v = w.into_writer();
459 let mut r = BitReader::<&[u8], E>::new(v.as_slice());
460 assert_eq!(r.read_bit().unwrap(), true);
461 assert_eq!(r.read_to::<u8>().unwrap(), u8::MAX - 10);
462 assert_eq!(r.read_to::<u16>().unwrap(), u16::MAX - 10);
463 assert_eq!(r.read_to::<u32>().unwrap(), u32::MAX - 10);
464 assert_eq!(r.read_to::<u64>().unwrap(), u64::MAX - 10);
465 assert_eq!(r.read_to::<u128>().unwrap(), u128::MAX - 10);
466 assert_eq!(r.read_to::<i8>().unwrap(), i8::MAX - 10);
467 assert_eq!(r.read_to::<i16>().unwrap(), i16::MAX - 10);
468 assert_eq!(r.read_to::<i32>().unwrap(), i32::MAX - 10);
469 assert_eq!(r.read_to::<i64>().unwrap(), i64::MAX - 10);
470 assert_eq!(r.read_to::<i128>().unwrap(), i128::MAX - 10);
471 assert_eq!(r.read_to::<f32>().unwrap(), 1.0);
472 assert_eq!(r.read_to::<f64>().unwrap(), 2.0);
473 assert_eq!(r.read_to::<[u8; 3]>().unwrap(), [9, 8, 7]);
474 }
475
476 #[test]
477 fn test_primitives_be() {
478 test_primitives::<BigEndian>()
479 }
480
481 #[test]
482 fn test_primitives_le() {
483 test_primitives::<LittleEndian>()
484 }