asn1rs/io/per/unaligned/
buffer.rs

1use super::*;
2use crate::io::per::Error;
3use crate::io::per::ErrorKind;
4
5#[derive(Debug, Default)]
6pub struct BitBuffer {
7    pub(crate) buffer: Vec<u8>,
8    pub(crate) write_position: usize,
9    pub(crate) read_position: usize,
10}
11
12impl BitBuffer {
13    pub fn with_capacity(capacity: usize) -> Self {
14        Self {
15            buffer: Vec::with_capacity(capacity),
16            ..Default::default()
17        }
18    }
19
20    pub fn from_bytes(buffer: Vec<u8>) -> Self {
21        let bits = buffer.len() * BYTE_LEN;
22        Self::from_bits(buffer, bits)
23    }
24
25    pub fn from_bits(buffer: Vec<u8>, bit_length: usize) -> Self {
26        assert!(bit_length <= buffer.len() * BYTE_LEN);
27        Self {
28            buffer,
29            write_position: bit_length,
30            read_position: 0,
31        }
32    }
33
34    pub fn from_bits_with_position(
35        buffer: Vec<u8>,
36        write_position: usize,
37        read_position: usize,
38    ) -> Self {
39        assert!(write_position <= buffer.len() * BYTE_LEN);
40        assert!(read_position <= buffer.len() * BYTE_LEN);
41        Self {
42            buffer,
43            write_position,
44            read_position,
45        }
46    }
47
48    pub fn clear(&mut self) {
49        self.buffer.clear();
50        self.write_position = 0;
51        self.read_position = 0;
52    }
53
54    pub fn reset_read_position(&mut self) {
55        self.read_position = 0;
56    }
57
58    pub fn content(&self) -> &[u8] {
59        &self.buffer
60    }
61
62    pub const fn bit_len(&self) -> usize {
63        self.write_position
64    }
65
66    pub fn byte_len(&self) -> usize {
67        self.buffer.len()
68    }
69
70    /// Changes the write-position to the given position for the closure call.
71    /// Restores the original write-position after the call.
72    ///
73    /// # Panics
74    /// Positions beyond the current buffer length will result in panics.
75    #[inline]
76    pub fn with_write_position_at<T, F: Fn(&mut Self) -> T>(&mut self, position: usize, f: F) -> T {
77        debug_assert!(position <= self.buffer.len() * 8);
78        let before = core::mem::replace(&mut self.write_position, position);
79        let result = f(self);
80        self.write_position = before;
81        result
82    }
83
84    /// Changes the read-position to the given position for the closure call.
85    /// Restores the original read-position after the call.
86    ///
87    /// # Panics
88    /// Positions beyond the current write-position will result in panics.
89    #[inline]
90    pub fn with_read_position_at<T, F: Fn(&mut Self) -> T>(&mut self, position: usize, f: F) -> T {
91        debug_assert!(position < self.write_position);
92        let before = core::mem::replace(&mut self.read_position, position);
93        let result = f(self);
94        self.read_position = before;
95        result
96    }
97
98    /// Sets the `write_position` to `read_position + max_read_len` for the call of the given
99    /// closure
100    pub fn with_max_read<T, F: Fn(&mut Self) -> T>(&mut self, max_read_len: usize, f: F) -> T {
101        let before =
102            core::mem::replace(&mut self.write_position, self.read_position + max_read_len);
103        let result = f(self);
104        self.write_position = before;
105        result
106    }
107
108    pub fn ensure_can_write_additional_bits(&mut self, bit_len: usize) {
109        if self.write_position + bit_len >= self.buffer.len() * BYTE_LEN {
110            let required_len = ((self.write_position + bit_len) + 7) / BYTE_LEN;
111            let extend_by_len = required_len - self.buffer.len();
112            self.buffer
113                .extend(core::iter::repeat(0u8).take(extend_by_len))
114        }
115    }
116}
117
118impl From<BitBuffer> for Vec<u8> {
119    fn from(bb: BitBuffer) -> Vec<u8> {
120        bb.buffer
121    }
122}
123
124impl From<Vec<u8>> for BitBuffer {
125    fn from(buffer: Vec<u8>) -> Self {
126        Self::from_bytes(buffer)
127    }
128}
129
130impl BitRead for BitBuffer {
131    #[inline]
132    fn read_bit(&mut self) -> Result<bool, Error> {
133        if self.read_position < self.write_position {
134            BitRead::read_bit(&mut (&self.buffer[..], &mut self.read_position))
135        } else {
136            Err(ErrorKind::EndOfStream.into())
137        }
138    }
139
140    #[inline]
141    fn read_bits(&mut self, dst: &mut [u8]) -> Result<(), Error> {
142        BitRead::read_bits(&mut (&self.buffer[..], &mut self.read_position), dst)
143    }
144
145    #[inline]
146    fn read_bits_with_offset(
147        &mut self,
148        dst: &mut [u8],
149        dst_bit_offset: usize,
150    ) -> Result<(), Error> {
151        BitRead::read_bits_with_offset(
152            &mut (&self.buffer[..], &mut self.read_position),
153            dst,
154            dst_bit_offset,
155        )
156    }
157
158    #[inline]
159    fn read_bits_with_len(&mut self, dst: &mut [u8], dst_bit_len: usize) -> Result<(), Error> {
160        BitRead::read_bits_with_len(
161            &mut (&self.buffer[..], &mut self.read_position),
162            dst,
163            dst_bit_len,
164        )
165    }
166
167    #[inline]
168    fn read_bits_with_offset_len(
169        &mut self,
170        dst: &mut [u8],
171        dst_bit_offset: usize,
172        dst_bit_len: usize,
173    ) -> Result<(), Error> {
174        BitRead::read_bits_with_offset_len(
175            &mut (&self.buffer[..], &mut self.read_position),
176            dst,
177            dst_bit_offset,
178            dst_bit_len,
179        )
180    }
181}
182
183impl BitWrite for BitBuffer {
184    #[inline]
185    fn write_bit(&mut self, bit: bool) -> Result<(), Error> {
186        self.ensure_can_write_additional_bits(1);
187        BitWrite::write_bit(&mut (&mut self.buffer[..], &mut self.write_position), bit)
188    }
189
190    #[inline]
191    fn write_bits(&mut self, src: &[u8]) -> Result<(), Error> {
192        self.ensure_can_write_additional_bits(src.len() * BYTE_LEN);
193        BitWrite::write_bits(&mut (&mut self.buffer[..], &mut self.write_position), src)
194    }
195
196    #[inline]
197    fn write_bits_with_offset(&mut self, src: &[u8], src_bit_offset: usize) -> Result<(), Error> {
198        self.ensure_can_write_additional_bits(src.len() * BYTE_LEN - src_bit_offset);
199        BitWrite::write_bits_with_offset(
200            &mut (&mut self.buffer[..], &mut self.write_position),
201            src,
202            src_bit_offset,
203        )
204    }
205
206    #[inline]
207    fn write_bits_with_len(&mut self, src: &[u8], bit_len: usize) -> Result<(), Error> {
208        self.ensure_can_write_additional_bits(bit_len);
209        BitWrite::write_bits_with_len(
210            &mut (&mut self.buffer[..], &mut self.write_position),
211            src,
212            bit_len,
213        )
214    }
215
216    #[inline]
217    fn write_bits_with_offset_len(
218        &mut self,
219        src: &[u8],
220        src_bit_offset: usize,
221        src_bit_len: usize,
222    ) -> Result<(), Error> {
223        self.ensure_can_write_additional_bits(src_bit_len);
224        BitWrite::write_bits_with_offset_len(
225            &mut (&mut self.buffer[..], &mut self.write_position),
226            src,
227            src_bit_offset,
228            src_bit_len,
229        )
230    }
231}
232
233pub struct Bits<'a> {
234    slice: &'a [u8],
235    pos: usize,
236    len: usize,
237}
238
239impl<'a> From<&'a [u8]> for Bits<'a> {
240    fn from(slice: &'a [u8]) -> Self {
241        Self {
242            slice,
243            pos: 0,
244            len: slice.len() * BYTE_LEN,
245        }
246    }
247}
248
249impl<'a> From<(&'a [u8], usize)> for Bits<'a> {
250    fn from((slice, len): (&'a [u8], usize)) -> Self {
251        debug_assert!(len <= slice.len() * BYTE_LEN);
252        Self { slice, pos: 0, len }
253    }
254}
255
256impl<'a> From<&'a BitBuffer> for Bits<'a> {
257    fn from(buffer: &'a BitBuffer) -> Self {
258        Self {
259            slice: buffer.content(),
260            pos: 0,
261            len: buffer.bit_len(),
262        }
263    }
264}
265
266impl BitRead for Bits<'_> {
267    #[inline]
268    fn read_bit(&mut self) -> Result<bool, Error> {
269        if self.pos < self.len {
270            BitRead::read_bit(&mut (self.slice, &mut self.pos))
271        } else {
272            Err(ErrorKind::EndOfStream.into())
273        }
274    }
275
276    #[inline]
277    fn read_bits(&mut self, dst: &mut [u8]) -> Result<(), Error> {
278        BitRead::read_bits(&mut (self.slice, &mut self.pos), dst)
279    }
280
281    #[inline]
282    fn read_bits_with_offset(
283        &mut self,
284        dst: &mut [u8],
285        dst_bit_offset: usize,
286    ) -> Result<(), Error> {
287        BitRead::read_bits_with_offset(&mut (self.slice, &mut self.pos), dst, dst_bit_offset)
288    }
289
290    #[inline]
291    fn read_bits_with_len(&mut self, dst: &mut [u8], dst_bit_len: usize) -> Result<(), Error> {
292        BitRead::read_bits_with_len(&mut (self.slice, &mut self.pos), dst, dst_bit_len)
293    }
294
295    #[inline]
296    fn read_bits_with_offset_len(
297        &mut self,
298        dst: &mut [u8],
299        dst_bit_offset: usize,
300        dst_bit_len: usize,
301    ) -> Result<(), Error> {
302        BitRead::read_bits_with_offset_len(
303            &mut (self.slice, &mut self.pos),
304            dst,
305            dst_bit_offset,
306            dst_bit_len,
307        )
308    }
309}
310
311impl ScopedBitRead for Bits<'_> {
312    #[inline]
313    fn pos(&self) -> usize {
314        self.pos
315    }
316
317    #[inline]
318    fn set_pos(&mut self, position: usize) -> usize {
319        let pos = position.min(self.len);
320        self.pos = pos;
321        pos
322    }
323
324    #[inline]
325    fn len(&self) -> usize {
326        self.len
327    }
328
329    #[inline]
330    fn set_len(&mut self, len: usize) -> usize {
331        let len = len.min(self.slice.len() * BYTE_LEN);
332        self.len = len;
333        len
334    }
335
336    #[inline]
337    fn remaining(&self) -> usize {
338        self.len - self.pos
339    }
340}
341
342#[cfg(test)]
343#[allow(clippy::identity_op, clippy::inconsistent_digit_grouping)] // this makes various examples easier to understand
344pub mod tests {
345    use super::*;
346    use crate::io::per::unaligned::BitRead;
347    use crate::io::per::unaligned::BitWrite;
348    use crate::io::per::unaligned::PackedRead;
349    use crate::io::per::unaligned::PackedWrite;
350
351    #[test]
352    pub fn bit_buffer_write_bit_keeps_correct_order() -> Result<(), Error> {
353        let mut buffer = BitBuffer::default();
354
355        buffer.write_bit(true)?;
356        buffer.write_bit(false)?;
357        buffer.write_bit(false)?;
358        buffer.write_bit(true)?;
359
360        buffer.write_bit(true)?;
361        buffer.write_bit(true)?;
362        buffer.write_bit(true)?;
363        buffer.write_bit(false)?;
364
365        assert_eq!(buffer.content(), &[0b1001_1110]);
366
367        buffer.write_bit(true)?;
368        buffer.write_bit(false)?;
369        buffer.write_bit(true)?;
370        buffer.write_bit(true)?;
371
372        buffer.write_bit(true)?;
373        buffer.write_bit(true)?;
374        buffer.write_bit(true)?;
375        buffer.write_bit(false)?;
376
377        assert_eq!(buffer.content(), &[0b1001_1110, 0b1011_1110]);
378
379        buffer.write_bit(true)?;
380        buffer.write_bit(false)?;
381        buffer.write_bit(true)?;
382        buffer.write_bit(false)?;
383
384        assert_eq!(buffer.content(), &[0b1001_1110, 0b1011_1110, 0b1010_0000]);
385
386        let mut buffer = BitBuffer::from_bits(buffer.content().into(), buffer.bit_len());
387        assert!(buffer.read_bit()?);
388        assert!(!buffer.read_bit()?);
389        assert!(!buffer.read_bit()?);
390        assert!(buffer.read_bit()?);
391
392        assert!(buffer.read_bit()?);
393        assert!(buffer.read_bit()?);
394        assert!(buffer.read_bit()?);
395        assert!(!buffer.read_bit()?);
396
397        assert!(buffer.read_bit()?);
398        assert!(!buffer.read_bit()?);
399        assert!(buffer.read_bit()?);
400        assert!(buffer.read_bit()?);
401
402        assert!(buffer.read_bit()?);
403        assert!(buffer.read_bit()?);
404        assert!(buffer.read_bit()?);
405        assert!(!buffer.read_bit()?);
406
407        assert!(buffer.read_bit()?);
408        assert!(!buffer.read_bit()?);
409        assert!(buffer.read_bit()?);
410        assert!(!buffer.read_bit()?);
411
412        assert_eq!(buffer.read_bit(), Err(ErrorKind::EndOfStream.into()));
413
414        Ok(())
415    }
416
417    #[test]
418    fn bit_buffer_bits() -> Result<(), Error> {
419        let content = &[0xFF, 0x74, 0xA6, 0x0F];
420        let mut buffer = BitBuffer::default();
421        buffer.write_bits(content)?;
422        assert_eq!(buffer.content(), content);
423
424        {
425            let mut buffer2 = BitBuffer::from_bits(buffer.content().into(), buffer.bit_len());
426            let mut content2 = vec![0_u8; content.len()];
427            buffer2.read_bits(&mut content2[..])?;
428            assert_eq!(&content[..], &content2[..]);
429        }
430
431        let mut content2 = vec![0xFF_u8; content.len()];
432        buffer.read_bits(&mut content2[..])?;
433        assert_eq!(&content[..], &content2[..]);
434
435        Ok(())
436    }
437
438    #[test]
439    fn bit_buffers_with_offset() -> Result<(), Error> {
440        let content = &[0b1111_1111, 0b0111_0100, 0b1010_0110, 0b0000_1111];
441        let mut buffer = BitBuffer::default();
442        buffer.write_bits_with_offset(content, 7)?;
443        assert_eq!(
444            buffer.content(),
445            &[0b1011_1010, 0b0101_0011, 0b0000_0111, 0b1000_0000]
446        );
447
448        {
449            let mut buffer2 = BitBuffer::from_bits(buffer.content().into(), buffer.bit_len());
450            let mut content2 = vec![0xFF_u8; content.len()];
451            content2[0] = content[0] & 0b1111_1110; // since we are skipping the first 7 bits
452            buffer2.read_bits_with_offset(&mut content2[..], 7)?;
453            assert_eq!(&content[..], &content2[..]);
454        }
455
456        let mut content2 = vec![0_u8; content.len()];
457        content2[0] = content[0] & 0b1111_1110; // since we are skipping the first 7 bits
458        buffer.read_bits_with_offset(&mut content2[..], 7)?;
459        assert_eq!(&content[..], &content2[..]);
460
461        Ok(())
462    }
463
464    #[test]
465    fn bit_buffer_bits_with_offset_len() -> Result<(), Error> {
466        let content = &[0b1111_1111, 0b0111_0100, 0b1010_0110, 0b0000_1111];
467        let mut buffer = BitBuffer::default();
468        buffer.write_bits_with_offset_len(content, 7, 12)?;
469        assert_eq!(buffer.content(), &[0b1011_1010, 0b0101_0000]);
470
471        {
472            let mut buffer2 = BitBuffer::from_bits(buffer.content().into(), buffer.bit_len());
473            let mut content2 = vec![0_u8; content.len()];
474            // since we are skipping the first 7 bits
475            let content = &[
476                content[0] & 0x01,
477                content[1],
478                content[2] & 0b1110_0000,
479                0x00,
480            ];
481            buffer2.read_bits_with_offset_len(&mut content2[..], 7, 12)?;
482            assert_eq!(&content[..], &content2[..]);
483        }
484
485        let mut content2 = vec![0x00_u8; content.len()];
486        // since we are skipping the first 7 bits
487        let content = &[
488            content[0] & 0x01,
489            content[1],
490            content[2] & 0b1110_0000,
491            0x00,
492        ];
493        buffer.read_bits_with_offset_len(&mut content2[..], 7, 12)?;
494        assert_eq!(&content[..], &content2[..]);
495
496        Ok(())
497    }
498
499    #[test]
500    fn bit_buffer_length_determinant_0() -> Result<(), Error> {
501        const DET: u64 = 0;
502        let mut buffer = BitBuffer::default();
503        buffer.write_length_determinant(None, None, DET)?;
504        assert_eq!(buffer.content(), &[0x00 | DET as u8]);
505
506        {
507            let mut buffer2 = BitBuffer::from_bits(buffer.content().into(), buffer.bit_len());
508            assert_eq!(DET, buffer2.read_length_determinant(None, None)?);
509        }
510
511        assert_eq!(DET, buffer.read_length_determinant(None, None)?);
512
513        Ok(())
514    }
515
516    #[test]
517    fn bit_buffer_length_determinant_1() -> Result<(), Error> {
518        const DET: u64 = 1;
519        let mut buffer = BitBuffer::default();
520        buffer.write_length_determinant(None, None, DET)?;
521        assert_eq!(buffer.content(), &[0x00 | DET as u8]);
522
523        {
524            let mut buffer2 = BitBuffer::from_bits(buffer.content().into(), buffer.bit_len());
525            assert_eq!(DET, buffer2.read_length_determinant(None, None)?);
526        }
527
528        assert_eq!(DET, buffer.read_length_determinant(None, None)?);
529        Ok(())
530    }
531
532    #[test]
533    fn bit_buffer_length_determinant_127() -> Result<(), Error> {
534        const DET: u64 = 126;
535        let mut buffer = BitBuffer::default();
536        buffer.write_length_determinant(None, None, DET)?;
537        assert_eq!(buffer.content(), &[0x00 | DET as u8]);
538
539        {
540            let mut buffer2 = BitBuffer::from_bits(buffer.content().into(), buffer.bit_len());
541            assert_eq!(DET, buffer2.read_length_determinant(None, None)?);
542        }
543
544        assert_eq!(DET, buffer.read_length_determinant(None, None)?);
545        Ok(())
546    }
547
548    #[test]
549    fn bit_buffer_length_determinant_128() -> Result<(), Error> {
550        const DET: u64 = 128;
551        let mut buffer = BitBuffer::default();
552        buffer.write_length_determinant(None, None, DET)?;
553        // detects that the value is greater than 127, so
554        //   10xx_xxxx xxxx_xxxx (header)
555        // | --00_0000 1000_0000 (128)
556        // =======================
557        //   1000_0000 1000_0000
558        assert_eq!(buffer.content(), &[0x80 | 0x00, 0x00 | DET as u8]);
559
560        {
561            let mut buffer2 = BitBuffer::from_bits(buffer.content().into(), buffer.bit_len());
562            assert_eq!(DET, buffer2.read_length_determinant(None, None)?);
563        }
564
565        assert_eq!(DET, buffer.read_length_determinant(None, None)?);
566        Ok(())
567    }
568
569    #[test]
570    fn bit_buffer_length_determinant_16383() -> Result<(), Error> {
571        const DET: u64 = 16383;
572        let mut buffer = BitBuffer::default();
573        buffer.write_length_determinant(None, None, DET)?;
574        // detects that the value is greater than 127, so
575        //   10xx_xxxx xxxx_xxxx (header)
576        // | --11_1111 1111_1111 (16383)
577        // =======================
578        //   1011_1111 1111_1111
579        assert_eq!(
580            buffer.content(),
581            &[0x80 | (DET >> 8) as u8, 0x00 | (DET & 0xFF) as u8]
582        );
583
584        {
585            let mut buffer2 = BitBuffer::from_bits(buffer.content().into(), buffer.bit_len());
586            assert_eq!(DET, buffer2.read_length_determinant(None, None)?);
587        }
588
589        assert_eq!(DET, buffer.read_length_determinant(None, None)?);
590        Ok(())
591    }
592
593    fn check_unconstrained_whole_number(buffer: &mut BitBuffer, int: i64) -> Result<(), Error> {
594        {
595            let mut buffer2 = BitBuffer::from_bits(buffer.content().into(), buffer.bit_len());
596            assert_eq!(int, buffer2.read_unconstrained_whole_number()?)
597        }
598
599        assert_eq!(int, buffer.read_unconstrained_whole_number()?);
600        Ok(())
601    }
602
603    #[test]
604    fn bit_buffer_unconstrained_whole_number_neg_12() -> Result<(), Error> {
605        const INT: i64 = -12;
606        let mut buffer = BitBuffer::default();
607        buffer.write_unconstrained_whole_number(INT)?;
608        // Can be represented in 1 byte,
609        // therefore the first byte is written
610        // with 0x00 (header) | 1 (byte len).
611        // The second byte is then the actual value
612        assert_eq!(buffer.content(), &[0x00 | 1, INT as u8]);
613        check_unconstrained_whole_number(&mut buffer, INT)?;
614        Ok(())
615    }
616
617    #[test]
618    fn bit_buffer_unconstrained_whole_number_0() -> Result<(), Error> {
619        const INT: i64 = 0;
620        let mut buffer = BitBuffer::default();
621        buffer.write_unconstrained_whole_number(INT)?;
622        // Can be represented in 1 byte,
623        // therefore the first byte is written
624        // with 0x00 (header) | 1 (byte len).
625        // The second byte is then the actual value
626        assert_eq!(buffer.content(), &[0x00 | 1, INT as u8]);
627        check_unconstrained_whole_number(&mut buffer, INT)?;
628        Ok(())
629    }
630
631    #[test]
632    fn bit_buffer_unconstrained_whole_number_127() -> Result<(), Error> {
633        const INT: i64 = 127; // u4::MAX as u64
634        let mut buffer = BitBuffer::default();
635        buffer.write_unconstrained_whole_number(INT)?;
636        // Can be represented in 1 byte,
637        // therefore the first byte is written
638        // with 0x00 (header) | 1 (byte len).
639        // The second byte is then the actual value
640        assert_eq!(buffer.content(), &[0x00 | 1, INT as u8]);
641        check_unconstrained_whole_number(&mut buffer, INT)?;
642        Ok(())
643    }
644
645    #[test]
646    fn bit_buffer_unconstrained_whole_number_128() -> Result<(), Error> {
647        const INT: i64 = 128; // u4::MAX as u64 + 1
648        let mut buffer = BitBuffer::default();
649        buffer.write_unconstrained_whole_number(INT)?;
650        assert_eq!(buffer.content(), &[0x02, 0x00, 0x80]);
651        check_unconstrained_whole_number(&mut buffer, INT)?;
652        Ok(())
653    }
654
655    #[test]
656    fn bit_buffer_unconstrained_whole_number_255() -> Result<(), Error> {
657        const INT: i64 = 255; // u8::MAX as u64
658        let mut buffer = BitBuffer::default();
659        buffer.write_unconstrained_whole_number(INT)?;
660        assert_eq!(buffer.content(), &[0x02, 0x00, 0xFF]);
661        check_unconstrained_whole_number(&mut buffer, INT)?;
662        Ok(())
663    }
664
665    #[test]
666    fn bit_buffer_unconstrained_whole_number_256() -> Result<(), Error> {
667        const INT: i64 = 256; // u8::MAX as u64 + 1
668        let mut buffer = BitBuffer::default();
669        buffer.write_unconstrained_whole_number(INT)?;
670        // Can be represented in 2 bytes,
671        // therefore the first byte is written
672        // with 0x00 (header) | 2 (byte len).
673        // The second byte is then the actual value
674        assert_eq!(
675            buffer.content(),
676            &[
677                0x00 | 2,
678                ((INT & 0xFF_00) >> 8) as u8,
679                ((INT & 0x00_ff) >> 0) as u8,
680            ]
681        );
682        check_unconstrained_whole_number(&mut buffer, INT)?;
683        Ok(())
684    }
685
686    #[test]
687    fn bit_buffer_unconstrained_whole_number_65535() -> Result<(), Error> {
688        const INT: i64 = 65_535; // u16::MAX as u64
689        let mut buffer = BitBuffer::default();
690        buffer.write_unconstrained_whole_number(INT)?;
691        assert_eq!(buffer.content(), &[0x03, 0x00, 0xFF, 0xFF]);
692        check_unconstrained_whole_number(&mut buffer, INT)?;
693        Ok(())
694    }
695
696    #[test]
697    fn bit_buffer_unconstrained_whole_number_65536() -> Result<(), Error> {
698        const INT: i64 = 65_536; // u16::MAX as u64 + 1
699        let mut buffer = BitBuffer::default();
700        buffer.write_unconstrained_whole_number(INT)?;
701        assert_eq!(buffer.content(), &[0x03, 0x01, 0x00, 0x00]);
702        check_unconstrained_whole_number(&mut buffer, INT)?;
703        Ok(())
704    }
705
706    #[test]
707    fn bit_buffer_unconstrained_whole_number_16777215() -> Result<(), Error> {
708        const INT: i64 = 16_777_215; // u24::MAX as u64
709        let mut buffer = BitBuffer::default();
710        buffer.write_unconstrained_whole_number(INT)?;
711        assert_eq!(buffer.content(), &[0x04, 0x00, 0xFF, 0xFF, 0xFF]);
712        check_unconstrained_whole_number(&mut buffer, INT)?;
713        Ok(())
714    }
715
716    #[test]
717    fn bit_buffer_unconstrained_whole_number_16777216() -> Result<(), Error> {
718        const INT: i64 = 16_777_216; // u24::MAX as u64 + 1
719        let mut buffer = BitBuffer::default();
720        buffer.write_unconstrained_whole_number(INT)?;
721        // Can be represented in 4 bytes,
722        // therefore the first byte is written
723        // with 0x00 (header) | 4 (byte len).
724        // The second byte is then the actual value
725        assert_eq!(
726            buffer.content(),
727            &[
728                0x00 | 4,
729                ((INT & 0xFF_00_00_00) >> 24) as u8,
730                ((INT & 0x00_FF_00_00) >> 16) as u8,
731                ((INT & 0x00_00_FF_00) >> 8) as u8,
732                ((INT & 0x00_00_00_FF) >> 0) as u8,
733            ]
734        );
735        check_unconstrained_whole_number(&mut buffer, INT)?;
736        Ok(())
737    }
738
739    #[test]
740    fn bit_buffer_unconstrained_whole_number_4294967295() -> Result<(), Error> {
741        const INT: i64 = 4_294_967_295; // u32::MAX as u64
742        let mut buffer = BitBuffer::default();
743        buffer.write_unconstrained_whole_number(INT)?;
744        assert_eq!(buffer.content(), &[0x05, 0x00, 0xFF, 0xFF, 0xFF, 0xFF]);
745        check_unconstrained_whole_number(&mut buffer, INT)?;
746        Ok(())
747    }
748
749    #[test]
750    fn bit_buffer_unconstrained_whole_number_4294967296() -> Result<(), Error> {
751        const INT: i64 = 4_294_967_296; // u32::MAX as u64 + 1
752        let mut buffer = BitBuffer::default();
753        buffer.write_unconstrained_whole_number(INT)?;
754        assert_eq!(buffer.content(), &[0x05, 0x01, 0x00, 0x00, 0x00, 0x00]);
755        check_unconstrained_whole_number(&mut buffer, INT)?;
756        Ok(())
757    }
758
759    #[test]
760    fn bit_buffer_unconstrained_whole_number_i64_max() -> Result<(), Error> {
761        const INT: i64 = i64::MAX;
762        let mut buffer = BitBuffer::default();
763        buffer.write_unconstrained_whole_number(INT)?;
764        // Can be represented in 8 bytes,
765        // therefore the first byte is written
766        // with 0x00 (header) | 8 (byte len).
767        // The second byte is then the actual value
768        assert_eq!(
769            buffer.content(),
770            &[
771                0x00 | 8,
772                ((INT as u64 & 0xFF_00_00_00_00_00_00_00_u64) >> 56) as u8,
773                ((INT as u64 & 0x00_FF_00_00_00_00_00_00_u64) >> 48) as u8,
774                ((INT as u64 & 0x00_00_FF_00_00_00_00_00_u64) >> 40) as u8,
775                ((INT as u64 & 0x00_00_00_FF_00_00_00_00_u64) >> 32) as u8,
776                ((INT as u64 & 0x00_00_00_00_FF_00_00_00_u64) >> 24) as u8,
777                ((INT as u64 & 0x00_00_00_00_00_FF_00_00_u64) >> 16) as u8,
778                ((INT as u64 & 0x00_00_00_00_00_00_FF_00_u64) >> 8) as u8,
779                ((INT as u64 & 0x00_00_00_00_00_00_00_FF_u64) >> 0) as u8,
780            ]
781        );
782        check_unconstrained_whole_number(&mut buffer, INT)?;
783        Ok(())
784    }
785
786    #[test]
787    fn bit_buffer_write_constrained_whole_number_detects_not_in_range_positive_only() {
788        let mut buffer = BitBuffer::default();
789        // lower check
790        assert_eq!(
791            buffer.write_constrained_whole_number(10, 127, 0),
792            Err(ErrorKind::ValueNotInRange(0, 10, 127).into())
793        );
794        // upper check
795        assert_eq!(
796            buffer.write_constrained_whole_number(10, 127, 128),
797            Err(ErrorKind::ValueNotInRange(128, 10, 127).into())
798        );
799    }
800
801    #[test]
802    fn bit_buffer_write_constrained_whole_number_detects_not_in_range_negative() {
803        let mut buffer = BitBuffer::default();
804        // lower check
805        assert_eq!(
806            buffer.write_constrained_whole_number(-10, -1, -11),
807            Err(ErrorKind::ValueNotInRange(-11, -10, -1).into())
808        );
809        // upper check
810        assert_eq!(
811            buffer.write_constrained_whole_number(-10, -1, 0),
812            Err(ErrorKind::ValueNotInRange(0, -10, -1).into())
813        );
814    }
815
816    #[test]
817    fn bit_buffer_write_constrained_whole_number_detects_not_in_range_with_negative() {
818        let mut buffer = BitBuffer::default();
819        // lower check
820        assert_eq!(
821            buffer.write_constrained_whole_number(-10, 1, -11),
822            Err(ErrorKind::ValueNotInRange(-11, -10, 1).into())
823        );
824        // upper check
825        assert_eq!(
826            buffer.write_constrained_whole_number(-10, 1, 2),
827            Err(ErrorKind::ValueNotInRange(2, -10, 1).into())
828        );
829    }
830
831    fn check_constrained_whole_number(
832        buffer: &mut BitBuffer,
833        int: i64,
834        range: (i64, i64),
835    ) -> Result<(), Error> {
836        {
837            let mut buffer2 = BitBuffer::from_bits(buffer.content().into(), buffer.bit_len());
838            assert_eq!(
839                int,
840                buffer2.read_constrained_whole_number(range.0, range.1)?
841            );
842        }
843        assert_eq!(int, buffer.read_constrained_whole_number(range.0, range.1)?);
844        Ok(())
845    }
846
847    #[test]
848    fn bit_buffer_constrained_whole_number_7bits() -> Result<(), Error> {
849        const INT: i64 = 10;
850        const RANGE: (i64, i64) = (0, 127);
851        let mut buffer = BitBuffer::default();
852        buffer.write_constrained_whole_number(RANGE.0, RANGE.1, INT)?;
853        // [0; 127] are 128 numbers, so they
854        // have to fit in 7 bit
855        assert_eq!(buffer.content(), &[(INT as u8) << 1]);
856        check_constrained_whole_number(&mut buffer, INT, RANGE)?;
857        // be sure write_bit writes at the 8th bit
858        buffer.write_bit(true)?;
859        assert_eq!(buffer.content(), &[(INT as u8) << 1 | 0b0000_0001]);
860        Ok(())
861    }
862
863    #[test]
864    fn bit_buffer_constrained_whole_number_neg() -> Result<(), Error> {
865        const INT: i64 = -10;
866        const RANGE: (i64, i64) = (-128, 127);
867        let mut buffer = BitBuffer::default();
868        buffer.write_constrained_whole_number(RANGE.0, RANGE.1, INT)?;
869        // [-128; 127] are 255 numbers, so they
870        // have to fit in one byte
871        assert_eq!(buffer.content(), &[(INT - RANGE.0) as u8]);
872        check_constrained_whole_number(&mut buffer, INT, RANGE)?;
873        Ok(())
874    }
875
876    #[test]
877    fn bit_buffer_constrained_whole_number_neg_extended_range() -> Result<(), Error> {
878        const INT: i64 = -10;
879        const RANGE: (i64, i64) = (-128, 128);
880        let mut buffer = BitBuffer::default();
881        buffer.write_constrained_whole_number(RANGE.0, RANGE.1, INT)?;
882        // [-128; 127] are 256 numbers, so they
883        // don't fit in one byte but in 9 bits
884        assert_eq!(
885            buffer.content(),
886            &[
887                ((INT - RANGE.0) as u8) >> 1,
888                (((INT - RANGE.0) as u8) << 7) | 0b0000_0000
889            ]
890        );
891        // be sure write_bit writes at the 10th bit
892        buffer.write_bit(true)?;
893        assert_eq!(
894            buffer.content(),
895            &[
896                ((INT - RANGE.0) as u8) >> 1,
897                ((INT - RANGE.0) as u8) << 7 | 0b0100_0000
898            ]
899        );
900        check_constrained_whole_number(&mut buffer, INT, RANGE)?;
901        Ok(())
902    }
903
904    #[test]
905    fn bit_buffer_octet_string_with_range() -> Result<(), Error> {
906        // test scenario from https://github.com/alexvoronov/geonetworking/blob/57a43113aeabc25f005ea17f76409aed148e67b5/camdenm/src/test/java/net/gcdc/camdenm/UperEncoderDecodeTest.java#L169
907        const BYTES: &[u8] = &[0x2A, 0x2B, 0x96, 0xFF];
908        const RANGE: (u64, u64) = (1, 20);
909        let mut buffer = BitBuffer::default();
910        buffer.write_octetstring(Some(RANGE.0), Some(RANGE.1), false, BYTES)?;
911        assert_eq!(&[0x19, 0x51, 0x5c, 0xb7, 0xf8], &buffer.content());
912        Ok(())
913    }
914
915    #[test]
916    fn bit_buffer_octet_string_without_range() -> Result<(), Error> {
917        const BYTES: &[u8] = &[0x2A, 0x2B, 0x96, 0xFF];
918        let mut buffer = BitBuffer::default();
919        buffer.write_octetstring(None, None, false, BYTES)?;
920        assert_eq!(&[0x04, 0x2a, 0x2b, 0x96, 0xff], &buffer.content());
921        Ok(())
922    }
923
924    #[test]
925    fn bit_buffer_octet_string_empty() -> Result<(), Error> {
926        const BYTES: &[u8] = &[];
927        let mut buffer = BitBuffer::default();
928        buffer.write_octetstring(None, None, false, BYTES)?;
929        assert_eq!(&[0x00], &buffer.content());
930        Ok(())
931    }
932
933    #[test]
934    fn bit_buffer_normally_small_non_negative_whole_number_5() -> Result<(), Error> {
935        // example from larmouth-asn1-book, p.296, Figure III-25
936        let mut buffer = BitBuffer::default();
937        buffer.write_normally_small_non_negative_whole_number(5)?;
938        // first 7 bits are relevant
939        assert_eq!(&[0b0000_101_0], &buffer.content());
940        assert_eq!(5, buffer.read_normally_small_non_negative_whole_number()?);
941        Ok(())
942    }
943
944    #[test]
945    fn bit_buffer_normally_small_non_negative_whole_number_60() -> Result<(), Error> {
946        // example from larmouth-asn1-book, p.296, Figure III-25
947        let mut buffer = BitBuffer::default();
948        buffer.write_normally_small_non_negative_whole_number(60)?;
949        // first 7 bits
950        assert_eq!(&[0b0111_100_0], &buffer.content());
951        assert_eq!(60, buffer.read_normally_small_non_negative_whole_number()?);
952        Ok(())
953    }
954
955    #[test]
956    fn bit_buffer_normally_small_non_negative_whole_number_254() -> Result<(), Error> {
957        // example from larmouth-asn1-book, p.296, Figure III-25
958        let mut buffer = BitBuffer::default();
959        buffer.write_normally_small_non_negative_whole_number(254)?;
960        // first 17 bits are relevant
961        // assert_eq!(&[0x1, 0b0000_0001, 0b1111_1110], &buffer.content());
962        assert_eq!(
963            //  Bit for greater 63
964            //  |
965            //  V |-len 1 byte-| |-value 254-| |-rest-|
966            &[0b1_000_0000, 0b1__111_1111, 0b0_000_0000],
967            &buffer.content()
968        );
969        Ok(())
970    }
971
972    #[test]
973    fn bit_buffer_write_choice_index_extensible() -> Result<(), Error> {
974        fn write_once(index: u64, no_of_default_variants: u64) -> Result<(usize, Vec<u8>), Error> {
975            let mut buffer = BitBuffer::default();
976            buffer.write_choice_index(no_of_default_variants, true, index)?;
977            let bits = buffer.bit_len();
978            Ok((bits, buffer.into()))
979        }
980        assert_eq!((2, vec![0x00]), write_once(0, 2)?);
981        assert_eq!((2, vec![0x40]), write_once(1, 2)?);
982        assert_eq!((8, vec![0x80]), write_once(2, 2)?);
983        assert_eq!((8, vec![0x81]), write_once(3, 2)?);
984        Ok(())
985    }
986
987    #[test]
988    fn bit_buffer_read_choice_index_extensible() -> Result<(), Error> {
989        fn read_once(data: &[u8], bits: usize, no_of_variants: u64) -> Result<u64, Error> {
990            let mut buffer = BitBuffer::default();
991            buffer.write_bits_with_len(data, bits)?;
992            buffer.read_choice_index(no_of_variants, true)
993        }
994        assert_eq!(0, read_once(&[0x00], 2, 2)?);
995        assert_eq!(1, read_once(&[0x40], 2, 2)?);
996        assert_eq!(2, read_once(&[0x80], 8, 2)?);
997        assert_eq!(3, read_once(&[0x81], 8, 2)?);
998        Ok(())
999    }
1000}
asn1rs/io/per/unaligned/buffer.rs

asn1rs/io/per/unaligned/
buffer.rs
