dlt_parse/verbose/
field_slicer.rs

1use crate::error::{Layer, UnexpectedEndOfSliceError, VerboseDecodeError};
2
3use super::{ArrayDimensions, RawF128, RawF16, Scaling};
4
5/// Helper for parsing verbose messages.
6pub(crate) struct FieldSlicer<'a> {
7    /// Unparsed part of the verbose message.
8    rest: &'a [u8],
9
10    /// Offset since the parsing has started.
11    offset: usize,
12}
13
14impl<'a> FieldSlicer<'a> {
15    #[inline]
16    pub fn new(data: &'a [u8], offset: usize) -> FieldSlicer<'a> {
17        FieldSlicer { rest: data, offset }
18    }
19
20    #[inline]
21    pub fn rest(&self) -> &'a [u8] {
22        self.rest
23    }
24
25    pub fn read_u8(&mut self) -> Result<u8, VerboseDecodeError> {
26        use VerboseDecodeError::*;
27
28        // check length
29        if self.rest.is_empty() {
30            return Err(UnexpectedEndOfSlice(UnexpectedEndOfSliceError {
31                layer: Layer::VerboseValue,
32                minimum_size: self.offset + 1,
33                actual_size: self.offset + self.rest.len(),
34            }));
35        }
36
37        // SAFETY: Length of at least 1 verified in the previous if.
38        let result = unsafe { *self.rest.get_unchecked(0) };
39
40        // move slice
41        // SAFETY: Length of at least 1 verified in the previous if.
42        self.rest =
43            unsafe { core::slice::from_raw_parts(self.rest.as_ptr().add(1), self.rest.len() - 1) };
44        self.offset += 1;
45
46        Ok(result)
47    }
48
49    pub fn read_i8(&mut self) -> Result<i8, VerboseDecodeError> {
50        Ok(i8::from_ne_bytes([self.read_u8()?]))
51    }
52
53    pub fn read_2bytes(&mut self) -> Result<[u8; 2], VerboseDecodeError> {
54        use VerboseDecodeError::*;
55
56        // check length
57        if self.rest.len() < 2 {
58            return Err(UnexpectedEndOfSlice(UnexpectedEndOfSliceError {
59                layer: Layer::VerboseValue,
60                minimum_size: self.offset + 2,
61                actual_size: self.offset + self.rest.len(),
62            }));
63        }
64
65        // read value
66        // SAFETY: Length of at least 2 verified in the previous if.
67        let result = unsafe { [*self.rest.get_unchecked(0), *self.rest.get_unchecked(1)] };
68
69        // move slice
70        // SAFETY: Length of at least 2 verified in the previous if.
71        self.rest =
72            unsafe { core::slice::from_raw_parts(self.rest.as_ptr().add(2), self.rest.len() - 2) };
73        self.offset += 2;
74
75        Ok(result)
76    }
77
78    pub fn read_4bytes(&mut self) -> Result<[u8; 4], VerboseDecodeError> {
79        use VerboseDecodeError::*;
80
81        // check length
82        if self.rest.len() < 4 {
83            return Err(UnexpectedEndOfSlice(UnexpectedEndOfSliceError {
84                layer: Layer::VerboseValue,
85                minimum_size: self.offset + 4,
86                actual_size: self.offset + self.rest.len(),
87            }));
88        }
89
90        // read value
91        // SAFETY: Length of at least 4 verified in the previous if.
92        let result = unsafe {
93            [
94                *self.rest.get_unchecked(0),
95                *self.rest.get_unchecked(1),
96                *self.rest.get_unchecked(2),
97                *self.rest.get_unchecked(3),
98            ]
99        };
100
101        // move slice
102        // SAFETY: Length of at least 4 verified in the previous if.
103        self.rest =
104            unsafe { core::slice::from_raw_parts(self.rest.as_ptr().add(4), self.rest.len() - 4) };
105        self.offset += 4;
106
107        Ok(result)
108    }
109
110    pub fn read_8bytes(&mut self) -> Result<[u8; 8], VerboseDecodeError> {
111        use VerboseDecodeError::*;
112
113        // check length
114        if self.rest.len() < 8 {
115            return Err(UnexpectedEndOfSlice(UnexpectedEndOfSliceError {
116                layer: Layer::VerboseValue,
117                minimum_size: self.offset + 8,
118                actual_size: self.offset + self.rest.len(),
119            }));
120        }
121
122        // read value
123        // SAFETY: Length of at least 8 verified in the previous if.
124        let result = unsafe {
125            [
126                *self.rest.get_unchecked(0),
127                *self.rest.get_unchecked(1),
128                *self.rest.get_unchecked(2),
129                *self.rest.get_unchecked(3),
130                *self.rest.get_unchecked(4),
131                *self.rest.get_unchecked(5),
132                *self.rest.get_unchecked(6),
133                *self.rest.get_unchecked(7),
134            ]
135        };
136
137        // move slice
138        // SAFETY: Length of at least 8 verified in the previous if.
139        self.rest =
140            unsafe { core::slice::from_raw_parts(self.rest.as_ptr().add(8), self.rest.len() - 8) };
141        self.offset += 8;
142
143        Ok(result)
144    }
145
146    pub fn read_16bytes(&mut self) -> Result<[u8; 16], VerboseDecodeError> {
147        use VerboseDecodeError::*;
148
149        // check length
150        if self.rest.len() < 16 {
151            return Err(UnexpectedEndOfSlice(UnexpectedEndOfSliceError {
152                layer: Layer::VerboseValue,
153                minimum_size: self.offset + 16,
154                actual_size: self.offset + self.rest.len(),
155            }));
156        }
157
158        // read value
159        // SAFETY: Length of at least 16 verified in the previous if.
160        let result = unsafe {
161            [
162                *self.rest.get_unchecked(0),
163                *self.rest.get_unchecked(1),
164                *self.rest.get_unchecked(2),
165                *self.rest.get_unchecked(3),
166                *self.rest.get_unchecked(4),
167                *self.rest.get_unchecked(5),
168                *self.rest.get_unchecked(6),
169                *self.rest.get_unchecked(7),
170                *self.rest.get_unchecked(8),
171                *self.rest.get_unchecked(9),
172                *self.rest.get_unchecked(10),
173                *self.rest.get_unchecked(11),
174                *self.rest.get_unchecked(12),
175                *self.rest.get_unchecked(13),
176                *self.rest.get_unchecked(14),
177                *self.rest.get_unchecked(15),
178            ]
179        };
180
181        // move slice
182        // SAFETY: Length of at least 8 verified in the previous if.
183        self.rest = unsafe {
184            core::slice::from_raw_parts(self.rest.as_ptr().add(16), self.rest.len() - 16)
185        };
186        self.offset += 16;
187
188        Ok(result)
189    }
190
191    pub fn read_u16(&mut self, is_big_endian: bool) -> Result<u16, VerboseDecodeError> {
192        self.read_2bytes().map(|bytes| {
193            if is_big_endian {
194                u16::from_be_bytes(bytes)
195            } else {
196                u16::from_le_bytes(bytes)
197            }
198        })
199    }
200
201    pub fn read_i16(&mut self, is_big_endian: bool) -> Result<i16, VerboseDecodeError> {
202        self.read_2bytes().map(|bytes| {
203            if is_big_endian {
204                i16::from_be_bytes(bytes)
205            } else {
206                i16::from_le_bytes(bytes)
207            }
208        })
209    }
210
211    pub fn read_u32(&mut self, is_big_endian: bool) -> Result<u32, VerboseDecodeError> {
212        self.read_4bytes().map(|bytes| {
213            if is_big_endian {
214                u32::from_be_bytes(bytes)
215            } else {
216                u32::from_le_bytes(bytes)
217            }
218        })
219    }
220
221    pub fn read_i32(&mut self, is_big_endian: bool) -> Result<i32, VerboseDecodeError> {
222        self.read_4bytes().map(|bytes| {
223            if is_big_endian {
224                i32::from_be_bytes(bytes)
225            } else {
226                i32::from_le_bytes(bytes)
227            }
228        })
229    }
230
231    pub fn read_u64(&mut self, is_big_endian: bool) -> Result<u64, VerboseDecodeError> {
232        self.read_8bytes().map(|bytes| {
233            if is_big_endian {
234                u64::from_be_bytes(bytes)
235            } else {
236                u64::from_le_bytes(bytes)
237            }
238        })
239    }
240
241    pub fn read_i64(&mut self, is_big_endian: bool) -> Result<i64, VerboseDecodeError> {
242        self.read_8bytes().map(|bytes| {
243            if is_big_endian {
244                i64::from_be_bytes(bytes)
245            } else {
246                i64::from_le_bytes(bytes)
247            }
248        })
249    }
250
251    pub fn read_u128(&mut self, is_big_endian: bool) -> Result<u128, VerboseDecodeError> {
252        self.read_16bytes().map(|bytes| {
253            if is_big_endian {
254                u128::from_be_bytes(bytes)
255            } else {
256                u128::from_le_bytes(bytes)
257            }
258        })
259    }
260
261    pub fn read_i128(&mut self, is_big_endian: bool) -> Result<i128, VerboseDecodeError> {
262        self.read_16bytes().map(|bytes| {
263            if is_big_endian {
264                i128::from_be_bytes(bytes)
265            } else {
266                i128::from_le_bytes(bytes)
267            }
268        })
269    }
270
271    pub fn read_f16(&mut self, is_big_endian: bool) -> Result<RawF16, VerboseDecodeError> {
272        self.read_u16(is_big_endian).map(RawF16::from_bits)
273    }
274
275    pub fn read_f128(&mut self, is_big_endian: bool) -> Result<RawF128, VerboseDecodeError> {
276        self.read_u128(is_big_endian).map(RawF128::from_bits)
277    }
278
279    pub fn read_f32(&mut self, is_big_endian: bool) -> Result<f32, VerboseDecodeError> {
280        self.read_4bytes().map(|bytes| {
281            if is_big_endian {
282                f32::from_be_bytes(bytes)
283            } else {
284                f32::from_le_bytes(bytes)
285            }
286        })
287    }
288
289    pub fn read_f64(&mut self, is_big_endian: bool) -> Result<f64, VerboseDecodeError> {
290        self.read_8bytes().map(|bytes| {
291            if is_big_endian {
292                f64::from_be_bytes(bytes)
293            } else {
294                f64::from_le_bytes(bytes)
295            }
296        })
297    }
298
299    pub fn read_var_name(&mut self, is_big_endian: bool) -> Result<&'a str, VerboseDecodeError> {
300        use VerboseDecodeError::*;
301
302        // check length
303        if self.rest.len() < 2 {
304            return Err(UnexpectedEndOfSlice(UnexpectedEndOfSliceError {
305                layer: Layer::VerboseValue,
306                minimum_size: self.offset + 2,
307                actual_size: self.offset + self.rest.len(),
308            }));
309        }
310
311        // read lengths
312        let name_length = {
313            // SAFETY: Length of at least 2 verified in the previous if.
314            let bytes = unsafe { [*self.rest.get_unchecked(0), *self.rest.get_unchecked(1)] };
315            if is_big_endian {
316                u16::from_be_bytes(bytes) as usize
317            } else {
318                u16::from_le_bytes(bytes) as usize
319            }
320        };
321
322        // check length of slice
323        let total_size = 2 + name_length;
324        if self.rest.len() < total_size {
325            return Err(UnexpectedEndOfSlice(UnexpectedEndOfSliceError {
326                layer: Layer::VerboseValue,
327                minimum_size: self.offset + total_size,
328                actual_size: self.offset + self.rest.len(),
329            }));
330        }
331
332        // read name
333        let name = if name_length > 0 {
334            // SAFETY: Length of at least 2 + name_length verified in the previous if.
335            //         Additionally name_length is guranteed to be at least 1.
336            let name_raw = unsafe {
337                core::slice::from_raw_parts(
338                    self.rest.as_ptr().add(2),
339                    // substract 1 to skip the zero termination
340                    name_length - 1,
341                )
342            };
343            // SAFETY: Length of at least 2 + name_length verified in the previous if.
344            //         Additionally name_length is guranteed to be at least 1.
345            let last = unsafe { *self.rest.as_ptr().add(2 + name_length - 1) };
346
347            // check for zero termination
348            if last != 0 {
349                return Err(VariableNameStringMissingNullTermination);
350            }
351
352            core::str::from_utf8(name_raw)?
353        } else {
354            ""
355        };
356
357        // move slice
358        // SAFETY: Length of at least total_size verfied in previous if.
359        self.rest = unsafe {
360            core::slice::from_raw_parts(
361                self.rest.as_ptr().add(total_size),
362                self.rest.len() - total_size,
363            )
364        };
365        self.offset += total_size;
366
367        Ok(name)
368    }
369
370    pub fn read_var_name_and_unit(
371        &mut self,
372        is_big_endian: bool,
373    ) -> Result<(&'a str, &'a str), VerboseDecodeError> {
374        use VerboseDecodeError::*;
375
376        // check length
377        if self.rest.len() < 4 {
378            return Err(UnexpectedEndOfSlice(UnexpectedEndOfSliceError {
379                layer: Layer::VerboseValue,
380                minimum_size: self.offset + 4,
381                actual_size: self.offset + self.rest.len(),
382            }));
383        }
384
385        // read lengths
386        let name_length = {
387            // SAFETY: Length of at least 4 verified in the previous if.
388            let bytes = unsafe { [*self.rest.get_unchecked(0), *self.rest.get_unchecked(1)] };
389            if is_big_endian {
390                u16::from_be_bytes(bytes) as usize
391            } else {
392                u16::from_le_bytes(bytes) as usize
393            }
394        };
395        let unit_length = {
396            // SAFETY: Length of at least 4 verified in the previous if.
397            let bytes = unsafe { [*self.rest.get_unchecked(2), *self.rest.get_unchecked(3)] };
398            if is_big_endian {
399                u16::from_be_bytes(bytes) as usize
400            } else {
401                u16::from_le_bytes(bytes) as usize
402            }
403        };
404
405        // check length of slice
406        let total_size = 4 + name_length + unit_length;
407        if self.rest.len() < total_size {
408            return Err(UnexpectedEndOfSlice(UnexpectedEndOfSliceError {
409                layer: Layer::VerboseValue,
410                minimum_size: self.offset + total_size,
411                actual_size: self.offset + self.rest.len(),
412            }));
413        }
414
415        // read name
416        let name = if name_length > 0 {
417            // SAFETY: Length of at least 4 + name_length verified in the previous if.
418            //         Additionally name_length is guranteed to be at least 1.
419            let name_raw = unsafe {
420                core::slice::from_raw_parts(
421                    self.rest.as_ptr().add(4),
422                    // substract 1 to skip the zero termination
423                    name_length - 1,
424                )
425            };
426            // SAFETY: Length of at least 4 + name_length verified in the previous if.
427            //         Additionally name_length is guranteed to be at least 1.
428            let last = unsafe { *self.rest.as_ptr().add(4 + name_length - 1) };
429
430            // check for zero termination
431            if last != 0 {
432                return Err(VariableNameStringMissingNullTermination);
433            }
434
435            core::str::from_utf8(name_raw)?
436        } else {
437            ""
438        };
439
440        // read unit
441        let unit = if unit_length > 0 {
442            // SAFETY: Length of at least 4 + name_length + unit_length verified in the previous if.
443            //         Additionally unit_length is guranteed to be at least 1.
444            let unit_raw = unsafe {
445                core::slice::from_raw_parts(
446                    self.rest.as_ptr().add(4 + name_length),
447                    // substract 1 to skip the zero termination
448                    unit_length - 1,
449                )
450            };
451            // SAFETY: Length of at least 4 + name_length + unit_length verified in the previous if.
452            //         Additionally unit_length is guranteed to be at least 1.
453            let last = unsafe { *self.rest.as_ptr().add(4 + name_length + unit_length - 1) };
454
455            // check for zero termination
456            if last != 0 {
457                return Err(VariableUnitStringMissingNullTermination);
458            }
459
460            core::str::from_utf8(unit_raw)?
461        } else {
462            ""
463        };
464
465        // move slice
466        // SAFETY: Length of at least total_size verfied in previous if.
467        self.rest = unsafe {
468            core::slice::from_raw_parts(
469                self.rest.as_ptr().add(total_size),
470                self.rest.len() - total_size,
471            )
472        };
473        self.offset += total_size;
474
475        // done
476        Ok((name, unit))
477    }
478
479    pub fn read_raw(&mut self, len: usize) -> Result<&'a [u8], VerboseDecodeError> {
480        use VerboseDecodeError::*;
481
482        // check that the string length is present
483        if self.rest.len() < len {
484            return Err(UnexpectedEndOfSlice(UnexpectedEndOfSliceError {
485                layer: Layer::VerboseValue,
486                minimum_size: self.offset + len,
487                actual_size: self.offset + self.rest.len(),
488            }));
489        }
490
491        // SAFETY: Slice length checked above to be at least len
492        let result = unsafe { core::slice::from_raw_parts(self.rest.as_ptr(), len) };
493
494        // move rest & offset
495        self.rest = unsafe {
496            core::slice::from_raw_parts(self.rest.as_ptr().add(len), self.rest.len() - len)
497        };
498        self.offset += len;
499
500        Ok(result)
501    }
502
503    const FIXED_POINT_FLAG_1: u8 = 0b0001_0000;
504
505    pub fn read_i32_scaling(
506        &mut self,
507        is_big_endian: bool,
508        type_info: [u8; 4],
509    ) -> Result<Option<Scaling<i32>>, VerboseDecodeError> {
510        if 0 != type_info[1] & Self::FIXED_POINT_FLAG_1 {
511            Ok(Some(Scaling {
512                quantization: self.read_f32(is_big_endian)?,
513                offset: self.read_i32(is_big_endian)?,
514            }))
515        } else {
516            Ok(None)
517        }
518    }
519
520    pub fn read_i64_scaling(
521        &mut self,
522        is_big_endian: bool,
523        type_info: [u8; 4],
524    ) -> Result<Option<Scaling<i64>>, VerboseDecodeError> {
525        if 0 != type_info[1] & Self::FIXED_POINT_FLAG_1 {
526            Ok(Some(Scaling {
527                quantization: self.read_f32(is_big_endian)?,
528                offset: self.read_i64(is_big_endian)?,
529            }))
530        } else {
531            Ok(None)
532        }
533    }
534
535    pub fn read_i128_scaling(
536        &mut self,
537        is_big_endian: bool,
538        type_info: [u8; 4],
539    ) -> Result<Option<Scaling<i128>>, VerboseDecodeError> {
540        if 0 != type_info[1] & Self::FIXED_POINT_FLAG_1 {
541            Ok(Some(Scaling {
542                quantization: self.read_f32(is_big_endian)?,
543                offset: self.read_i128(is_big_endian)?,
544            }))
545        } else {
546            Ok(None)
547        }
548    }
549
550    pub fn read_array_dimesions(
551        &mut self,
552        is_big_endian: bool,
553    ) -> Result<ArrayDimensions<'a>, VerboseDecodeError> {
554        use VerboseDecodeError::*;
555
556        // first read the number of dimensions
557        let num_dims = self.read_u16(is_big_endian)?;
558
559        // check if enough data is present for the dimensions
560        let len = usize::from(num_dims) * 2;
561        if self.rest.len() < len {
562            return Err(UnexpectedEndOfSlice(UnexpectedEndOfSliceError {
563                layer: Layer::VerboseTypeInfo,
564                minimum_size: self.offset + len,
565                actual_size: self.offset + self.rest.len(),
566            }));
567        }
568
569        // safe array dimensions slice
570        let result = ArrayDimensions {
571            is_big_endian,
572            dimensions: unsafe { core::slice::from_raw_parts(self.rest.as_ptr(), len) },
573        };
574
575        // move rest and offset
576        self.rest = unsafe {
577            core::slice::from_raw_parts(self.rest.as_ptr().add(len), self.rest.len() - len)
578        };
579        self.offset += len;
580
581        Ok(result)
582    }
583}
584
585#[cfg(test)]
586mod test_field_slicer {
587    use super::*;
588    use alloc::vec::Vec;
589    use proptest::collection::vec;
590    use proptest::prelude::*;
591    use std::format;
592
593    proptest! {
594        #[test]
595        fn new(
596            data in prop::collection::vec(any::<u8>(), 0..10),
597            offset in any::<usize>()
598        ) {
599            let s = FieldSlicer::new(
600                &data,
601                offset
602            );
603            prop_assert_eq!(s.rest(), &data);
604            prop_assert_eq!(s.offset, offset);
605        }
606    }
607
608    proptest! {
609        #[test]
610        fn read_2bytes(
611            value in any::<[u8;2]>(),
612            slice_len in 2usize..4,
613            offset in 0usize..usize::MAX-1,
614            bad_len in 0usize..2,
615        ) {
616            // ok
617            {
618                let data = [value[0], value[1], 1, 2];
619                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
620                prop_assert_eq!(
621                    slicer.read_2bytes(),
622                    Ok(value)
623                );
624                prop_assert_eq!(slicer.offset, offset + 2);
625                prop_assert_eq!(slicer.rest, &[1,2][..slice_len - 2]);
626            }
627
628            // length error
629            {
630                let mut slicer = FieldSlicer::new(&value[..bad_len], offset);
631                prop_assert_eq!(
632                    slicer.read_2bytes(),
633                    Err(VerboseDecodeError::UnexpectedEndOfSlice(
634                        UnexpectedEndOfSliceError{
635                            layer: Layer::VerboseValue,
636                            actual_size: offset + bad_len,
637                            minimum_size: offset + 2,
638                        }
639                    ))
640                );
641                prop_assert_eq!(slicer.offset, offset);
642                prop_assert_eq!(slicer.rest, &value[..bad_len]);
643            }
644        }
645    }
646
647    proptest! {
648        #[test]
649        fn read_4bytes(
650            value in any::<[u8;4]>(),
651            slice_len in 4usize..8,
652            offset in 0usize..usize::MAX-3,
653            bad_len in 0usize..4,
654        ) {
655            // ok
656            {
657                let data = [value[0], value[1], value[2], value[3], 1, 2, 3, 4];
658                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
659                prop_assert_eq!(
660                    slicer.read_4bytes(),
661                    Ok(value)
662                );
663                prop_assert_eq!(slicer.offset, offset + 4);
664                prop_assert_eq!(slicer.rest, &[1,2,3,4][..slice_len - 4]);
665            }
666
667            // length error
668            {
669                let mut slicer = FieldSlicer::new(&value[..bad_len], offset);
670                prop_assert_eq!(
671                    slicer.read_4bytes(),
672                    Err(VerboseDecodeError::UnexpectedEndOfSlice(
673                        UnexpectedEndOfSliceError{
674                            layer: Layer::VerboseValue,
675                            actual_size: offset + bad_len,
676                            minimum_size: offset + 4,
677                        }
678                    ))
679                );
680                prop_assert_eq!(slicer.offset, offset);
681                prop_assert_eq!(slicer.rest, &value[..bad_len]);
682            }
683        }
684    }
685
686    proptest! {
687        #[test]
688        fn read_8bytes(
689            value in any::<[u8;8]>(),
690            slice_len in 8usize..16,
691            offset in 0usize..usize::MAX-7,
692            bad_len in 0usize..8,
693        ) {
694            // ok
695            {
696                let data = [value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], 1, 2, 3, 4, 5, 6, 7, 8];
697                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
698                prop_assert_eq!(
699                    slicer.read_8bytes(),
700                    Ok(value)
701                );
702                prop_assert_eq!(slicer.offset, offset + 8);
703                prop_assert_eq!(slicer.rest, &[1,2,3,4,5,6,7,8][..slice_len - 8]);
704            }
705
706            // length error
707            {
708                let mut slicer = FieldSlicer::new(&value[..bad_len], offset);
709                prop_assert_eq!(
710                    slicer.read_8bytes(),
711                    Err(VerboseDecodeError::UnexpectedEndOfSlice(
712                        UnexpectedEndOfSliceError{
713                            layer: Layer::VerboseValue,
714                            actual_size: offset + bad_len,
715                            minimum_size: offset + 8,
716                        }
717                    ))
718                );
719                prop_assert_eq!(slicer.offset, offset);
720                prop_assert_eq!(slicer.rest, &value[..bad_len]);
721            }
722        }
723    }
724
725    proptest! {
726        #[test]
727        fn read_16bytes(
728            value in any::<[u8;16]>(),
729            slice_len in 16usize..32,
730            offset in 0usize..usize::MAX-15,
731            bad_len in 0usize..16,
732        ) {
733            // ok
734            {
735                let data = [value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8], value[9], value[10], value[11], value[12], value[13], value[14], value[15], 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
736                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
737                prop_assert_eq!(
738                    slicer.read_16bytes(),
739                    Ok(value)
740                );
741                prop_assert_eq!(slicer.offset, offset + 16);
742                prop_assert_eq!(slicer.rest, &[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16][..slice_len - 16]);
743            }
744
745            // length error
746            {
747                let mut slicer = FieldSlicer::new(&value[..bad_len], offset);
748                prop_assert_eq!(
749                    slicer.read_16bytes(),
750                    Err(VerboseDecodeError::UnexpectedEndOfSlice(
751                        UnexpectedEndOfSliceError{
752                            layer: Layer::VerboseValue,
753                            actual_size: offset + bad_len,
754                            minimum_size: offset + 16,
755                        }
756                    ))
757                );
758                prop_assert_eq!(slicer.offset, offset);
759                prop_assert_eq!(slicer.rest, &value[..bad_len]);
760            }
761        }
762    }
763
764    proptest! {
765        #[test]
766        fn read_u8(
767            value in any::<u8>(),
768            slice_len in 1usize..3,
769            offset in 0usize..usize::MAX,
770        ) {
771            // ok
772            {
773                let data = [value, 123, 234];
774                let mut slicer = FieldSlicer{
775                    rest: &data[..slice_len],
776                    offset,
777                };
778                prop_assert_eq!(
779                    slicer.read_u8(),
780                    Ok(value)
781                );
782                prop_assert_eq!(slicer.rest, &data[1..slice_len]);
783                prop_assert_eq!(slicer.offset, offset + 1);
784            }
785            // length error
786            {
787                let mut slicer = FieldSlicer{
788                    rest: &[],
789                    offset,
790                };
791                prop_assert_eq!(
792                    slicer.read_u8(),
793                    Err(VerboseDecodeError::UnexpectedEndOfSlice(
794                        UnexpectedEndOfSliceError{
795                            layer: Layer::VerboseValue,
796                            actual_size: offset,
797                            minimum_size: offset + 1,
798                        }
799                    ))
800                );
801            }
802        }
803    }
804
805    proptest! {
806        #[test]
807        fn read_i8(
808            value in any::<i8>(),
809            slice_len in 1usize..3,
810            offset in 0usize..usize::MAX,
811        ) {
812            // ok
813            {
814                let data = [value as u8, i8::MIN as u8, i8::MAX as u8];
815                let mut slicer = FieldSlicer{
816                    rest: &data[..slice_len],
817                    offset,
818                };
819                prop_assert_eq!(
820                    slicer.read_i8(),
821                    Ok(value)
822                );
823                prop_assert_eq!(slicer.rest, &data[1..slice_len]);
824                prop_assert_eq!(slicer.offset, offset + 1);
825            }
826            // length error
827            {
828                let mut slicer = FieldSlicer{
829                    rest: &[],
830                    offset,
831                };
832                prop_assert_eq!(
833                    slicer.read_i8(),
834                    Err(VerboseDecodeError::UnexpectedEndOfSlice(
835                        UnexpectedEndOfSliceError{
836                            layer: Layer::VerboseValue,
837                            actual_size: offset,
838                            minimum_size: offset + 1,
839                        }
840                    ))
841                );
842            }
843        }
844    }
845
846    proptest! {
847        #[test]
848        fn read_u16(
849            value in any::<u16>(),
850            slice_len in 2usize..4,
851            offset in 0usize..usize::MAX-1,
852            bad_len in 0usize..2
853        ) {
854
855            // ok big endian
856            {
857                let value_be = value.to_be_bytes();
858                let data = [value_be[0], value_be[1], 1, 2,];
859                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
860                prop_assert_eq!(
861                    slicer.read_u16(true),
862                    Ok(value)
863                );
864                prop_assert_eq!(slicer.offset, offset + 2);
865                prop_assert_eq!(slicer.rest, &[1,2][..slice_len - 2]);
866            }
867            // ok little endian
868            {
869                let value_le = value.to_le_bytes();
870                let data = [
871                    value_le[0], value_le[1], 1, 2,
872                ];
873                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
874                prop_assert_eq!(
875                    slicer.read_u16(false),
876                    Ok(value)
877                );
878                prop_assert_eq!(slicer.offset, offset + 2);
879                prop_assert_eq!(slicer.rest, &[1,2][..slice_len - 2]);
880            }
881
882            // length error
883            {
884                let expected = Err(VerboseDecodeError::UnexpectedEndOfSlice(
885                    UnexpectedEndOfSliceError{
886                        layer: Layer::VerboseValue,
887                        actual_size: offset + bad_len,
888                        minimum_size: offset + 2,
889                    }
890                ));
891                let data = value.to_le_bytes();
892                let mut slicer = FieldSlicer::new(&data[..bad_len], offset);
893
894                // little endian
895                prop_assert_eq!(slicer.read_u16(false), expected.clone());
896                prop_assert_eq!(slicer.offset, offset);
897                prop_assert_eq!(slicer.rest, &data[..bad_len]);
898
899                // big endian
900                prop_assert_eq!(slicer.read_u16(true), expected);
901                prop_assert_eq!(slicer.offset, offset);
902                prop_assert_eq!(slicer.rest, &data[..bad_len]);
903            }
904        }
905    }
906
907    proptest! {
908        #[test]
909        fn read_i16(
910            value in any::<i16>(),
911            slice_len in 2usize..4,
912            offset in 0usize..usize::MAX-1,
913            bad_len in 0usize..2
914        ) {
915
916            // ok big endian
917            {
918                let value_be = value.to_be_bytes();
919                let data = [value_be[0], value_be[1], 1, 2];
920                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
921                prop_assert_eq!(
922                    slicer.read_i16(true),
923                    Ok(value)
924                );
925                prop_assert_eq!(slicer.offset, offset + 2);
926                prop_assert_eq!(slicer.rest, &[1,2][..slice_len - 2]);
927            }
928            // ok little endian
929            {
930                let value_le = value.to_le_bytes();
931                let data = [
932                    value_le[0], value_le[1], 1, 2,
933                ];
934                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
935                prop_assert_eq!(
936                    slicer.read_i16(false),
937                    Ok(value)
938                );
939                prop_assert_eq!(slicer.offset, offset + 2);
940                prop_assert_eq!(slicer.rest, &[1,2][..slice_len - 2]);
941            }
942
943            // length error
944            {
945                let expected = Err(VerboseDecodeError::UnexpectedEndOfSlice(
946                    UnexpectedEndOfSliceError{
947                        layer: Layer::VerboseValue,
948                        actual_size: offset + bad_len,
949                        minimum_size: offset + 2,
950                    }
951                ));
952                let data = value.to_le_bytes();
953                let mut slicer = FieldSlicer::new(&data[..bad_len], offset);
954
955                // little endian
956                prop_assert_eq!(slicer.read_i16(false), expected.clone());
957                prop_assert_eq!(slicer.offset, offset);
958                prop_assert_eq!(slicer.rest, &data[..bad_len]);
959
960                // big endian
961                prop_assert_eq!(slicer.read_i16(true), expected);
962                prop_assert_eq!(slicer.offset, offset);
963                prop_assert_eq!(slicer.rest, &data[..bad_len]);
964            }
965        }
966    }
967
968    proptest! {
969        #[test]
970        fn read_u32(
971            value in any::<u32>(),
972            slice_len in 4usize..8,
973            offset in 0usize..usize::MAX-3,
974            bad_len in 0usize..4
975        ) {
976
977            // ok big endian
978            {
979                let value_be = value.to_be_bytes();
980                let data = [value_be[0], value_be[1], value_be[2], value_be[3], 1, 2, 3, 4];
981                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
982                prop_assert_eq!(
983                    slicer.read_u32(true),
984                    Ok(value)
985                );
986                prop_assert_eq!(slicer.offset, offset + 4);
987                prop_assert_eq!(slicer.rest, &[1,2,3,4][..slice_len - 4]);
988            }
989            // ok little endian
990            {
991                let value_le = value.to_le_bytes();
992                let data = [
993                    value_le[0], value_le[1], value_le[2], value_le[3], 1, 2, 3, 4
994                ];
995                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
996                prop_assert_eq!(
997                    slicer.read_u32(false),
998                    Ok(value)
999                );
1000                prop_assert_eq!(slicer.offset, offset + 4);
1001                prop_assert_eq!(slicer.rest, &[1,2,3,4][..slice_len - 4]);
1002            }
1003
1004            // length error
1005            {
1006                let expected = Err(VerboseDecodeError::UnexpectedEndOfSlice(
1007                    UnexpectedEndOfSliceError{
1008                        layer: Layer::VerboseValue,
1009                        actual_size: offset + bad_len,
1010                        minimum_size: offset + 4,
1011                    }
1012                ));
1013                let data = value.to_le_bytes();
1014                let mut slicer = FieldSlicer::new(&data[..bad_len], offset);
1015
1016                // little endian
1017                prop_assert_eq!(slicer.read_u32(false), expected.clone());
1018                prop_assert_eq!(slicer.offset, offset);
1019                prop_assert_eq!(slicer.rest, &data[..bad_len]);
1020
1021                // big endian
1022                prop_assert_eq!(slicer.read_u32(true), expected);
1023                prop_assert_eq!(slicer.offset, offset);
1024                prop_assert_eq!(slicer.rest, &data[..bad_len]);
1025            }
1026        }
1027    }
1028
1029    proptest! {
1030        #[test]
1031        fn read_i32(
1032            value in any::<i32>(),
1033            slice_len in 4usize..8,
1034            offset in 0usize..usize::MAX-3,
1035            bad_len in 0usize..4
1036        ) {
1037
1038            // ok big endian
1039            {
1040                let value_be = value.to_be_bytes();
1041                let data = [value_be[0], value_be[1], value_be[2], value_be[3], 1, 2, 3, 4];
1042                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
1043                prop_assert_eq!(
1044                    slicer.read_i32(true),
1045                    Ok(value)
1046                );
1047                prop_assert_eq!(slicer.offset, offset + 4);
1048                prop_assert_eq!(slicer.rest, &[1,2,3,4][..slice_len - 4]);
1049            }
1050            // ok little endian
1051            {
1052                let value_le = value.to_le_bytes();
1053                let data = [
1054                    value_le[0], value_le[1], value_le[2], value_le[3], 1, 2, 3, 4
1055                ];
1056                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
1057                prop_assert_eq!(
1058                    slicer.read_i32(false),
1059                    Ok(value)
1060                );
1061                prop_assert_eq!(slicer.offset, offset + 4);
1062                prop_assert_eq!(slicer.rest, &[1,2,3,4][..slice_len - 4]);
1063            }
1064
1065            // length error
1066            {
1067                let expected = Err(VerboseDecodeError::UnexpectedEndOfSlice(
1068                    UnexpectedEndOfSliceError{
1069                        layer: Layer::VerboseValue,
1070                        actual_size: offset + bad_len,
1071                        minimum_size: offset + 4,
1072                    }
1073                ));
1074                let data = value.to_le_bytes();
1075                let mut slicer = FieldSlicer::new(&data[..bad_len], offset);
1076
1077                // little endian
1078                prop_assert_eq!(slicer.read_i32(false), expected.clone());
1079                prop_assert_eq!(slicer.offset, offset);
1080                prop_assert_eq!(slicer.rest, &data[..bad_len]);
1081
1082                // big endian
1083                prop_assert_eq!(slicer.read_i32(true), expected);
1084                prop_assert_eq!(slicer.offset, offset);
1085                prop_assert_eq!(slicer.rest, &data[..bad_len]);
1086            }
1087        }
1088    }
1089
1090    proptest! {
1091        #[test]
1092        fn read_u64(
1093            value in any::<u64>(),
1094            slice_len in 8usize..16,
1095            offset in 0usize..usize::MAX-7,
1096            bad_len in 0usize..8
1097        ) {
1098
1099            // ok big endian
1100            {
1101                let value_be = value.to_be_bytes();
1102                let data = [value_be[0], value_be[1], value_be[2], value_be[3], value_be[4], value_be[5], value_be[6], value_be[7], 1, 2, 3, 4, 5, 6, 7, 8];
1103                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
1104                prop_assert_eq!(
1105                    slicer.read_u64(true),
1106                    Ok(value)
1107                );
1108                prop_assert_eq!(slicer.offset, offset + 8);
1109                prop_assert_eq!(slicer.rest, &[1,2,3,4,5,6,7,8][..slice_len - 8]);
1110            }
1111            // ok little endian
1112            {
1113                let value_le = value.to_le_bytes();
1114                let data = [
1115                    value_le[0], value_le[1], value_le[2], value_le[3], value_le[4], value_le[5], value_le[6], value_le[7], 1, 2, 3, 4, 5, 6, 7, 8
1116                ];
1117                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
1118                prop_assert_eq!(
1119                    slicer.read_u64(false),
1120                    Ok(value)
1121                );
1122                prop_assert_eq!(slicer.offset, offset + 8);
1123                prop_assert_eq!(slicer.rest, &[1,2,3,4,5,6,7,8][..slice_len - 8]);
1124            }
1125
1126            // length error
1127            {
1128                let expected = Err(VerboseDecodeError::UnexpectedEndOfSlice(
1129                    UnexpectedEndOfSliceError{
1130                        layer: Layer::VerboseValue,
1131                        actual_size: offset + bad_len,
1132                        minimum_size: offset + 8,
1133                    }
1134                ));
1135                let data = value.to_le_bytes();
1136                let mut slicer = FieldSlicer::new(&data[..bad_len], offset);
1137
1138                // little endian
1139                prop_assert_eq!(slicer.read_u64(false), expected.clone());
1140                prop_assert_eq!(slicer.offset, offset);
1141                prop_assert_eq!(slicer.rest, &data[..bad_len]);
1142
1143                // big endian
1144                prop_assert_eq!(slicer.read_u64(true), expected);
1145                prop_assert_eq!(slicer.offset, offset);
1146                prop_assert_eq!(slicer.rest, &data[..bad_len]);
1147            }
1148        }
1149    }
1150
1151    proptest! {
1152        #[test]
1153        fn read_i64(
1154            value in any::<i64>(),
1155            slice_len in 8usize..16,
1156            offset in 0usize..usize::MAX-7,
1157            bad_len in 0usize..8
1158        ) {
1159
1160            // ok big endian
1161            {
1162                let value_be = value.to_be_bytes();
1163                let data = [value_be[0], value_be[1], value_be[2], value_be[3], value_be[4], value_be[5], value_be[6], value_be[7], 1, 2, 3, 4, 5, 6, 7, 8];
1164                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
1165                prop_assert_eq!(
1166                    slicer.read_i64(true),
1167                    Ok(value)
1168                );
1169                prop_assert_eq!(slicer.offset, offset + 8);
1170                prop_assert_eq!(slicer.rest, &[1,2,3,4,5,6,7,8][..slice_len - 8]);
1171            }
1172            // ok little endian
1173            {
1174                let value_le = value.to_le_bytes();
1175                let data = [
1176                    value_le[0], value_le[1], value_le[2], value_le[3], value_le[4], value_le[5], value_le[6], value_le[7], 1, 2, 3, 4, 5, 6, 7, 8
1177                ];
1178                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
1179                prop_assert_eq!(
1180                    slicer.read_i64(false),
1181                    Ok(value)
1182                );
1183                prop_assert_eq!(slicer.offset, offset + 8);
1184                prop_assert_eq!(slicer.rest, &[1,2,3,4,5,6,7,8][..slice_len - 8]);
1185            }
1186
1187            // length error
1188            {
1189                let expected = Err(VerboseDecodeError::UnexpectedEndOfSlice(
1190                    UnexpectedEndOfSliceError{
1191                        layer: Layer::VerboseValue,
1192                        actual_size: offset + bad_len,
1193                        minimum_size: offset + 8,
1194                    }
1195                ));
1196                let data = value.to_le_bytes();
1197                let mut slicer = FieldSlicer::new(&data[..bad_len], offset);
1198
1199                // little endian
1200                prop_assert_eq!(slicer.read_i64(false), expected.clone());
1201                prop_assert_eq!(slicer.offset, offset);
1202                prop_assert_eq!(slicer.rest, &data[..bad_len]);
1203
1204                // big endian
1205                prop_assert_eq!(slicer.read_i64(true), expected);
1206                prop_assert_eq!(slicer.offset, offset);
1207                prop_assert_eq!(slicer.rest, &data[..bad_len]);
1208            }
1209        }
1210    }
1211
1212    proptest! {
1213        #[test]
1214        fn read_u128(
1215            value in any::<u128>(),
1216            slice_len in 16usize..32,
1217            offset in 0usize..usize::MAX-15,
1218            bad_len in 0usize..16
1219        ) {
1220
1221            // ok big endian
1222            {
1223                let value_be = value.to_be_bytes();
1224                let data = [value_be[0], value_be[1], value_be[2], value_be[3], value_be[4], value_be[5], value_be[6], value_be[7], value_be[8], value_be[9], value_be[10], value_be[11], value_be[12], value_be[13], value_be[14], value_be[15], 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
1225                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
1226                prop_assert_eq!(
1227                    slicer.read_u128(true),
1228                    Ok(value)
1229                );
1230                prop_assert_eq!(slicer.offset, offset + 16);
1231                prop_assert_eq!(slicer.rest, &[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15][..slice_len - 16]);
1232            }
1233            // ok little endian
1234            {
1235                let value_le = value.to_le_bytes();
1236                let data = [
1237                    value_le[0], value_le[1], value_le[2], value_le[3], value_le[4], value_le[5], value_le[6], value_le[7], value_le[8], value_le[9], value_le[10], value_le[11], value_le[12], value_le[13], value_le[14], value_le[15], 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
1238                ];
1239                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
1240                prop_assert_eq!(
1241                    slicer.read_u128(false),
1242                    Ok(value)
1243                );
1244                prop_assert_eq!(slicer.offset, offset + 16);
1245                prop_assert_eq!(slicer.rest, &[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15][..slice_len - 16]);
1246            }
1247
1248            // length error
1249            {
1250                let expected = Err(VerboseDecodeError::UnexpectedEndOfSlice(
1251                    UnexpectedEndOfSliceError{
1252                        layer: Layer::VerboseValue,
1253                        actual_size: offset + bad_len,
1254                        minimum_size: offset + 16,
1255                    }
1256                ));
1257                let data = value.to_le_bytes();
1258                let mut slicer = FieldSlicer::new(&data[..bad_len], offset);
1259
1260                // little endian
1261                prop_assert_eq!(slicer.read_u128(false), expected.clone());
1262                prop_assert_eq!(slicer.offset, offset);
1263                prop_assert_eq!(slicer.rest, &data[..bad_len]);
1264
1265                // big endian
1266                prop_assert_eq!(slicer.read_u128(true), expected);
1267                prop_assert_eq!(slicer.offset, offset);
1268                prop_assert_eq!(slicer.rest, &data[..bad_len]);
1269            }
1270        }
1271    }
1272
1273    proptest! {
1274        #[test]
1275        fn read_i128(
1276            value in any::<i128>(),
1277            slice_len in 16usize..32,
1278            offset in 0usize..usize::MAX-15,
1279            bad_len in 0usize..16
1280        ) {
1281
1282            // ok big endian
1283            {
1284                let value_be = value.to_be_bytes();
1285                let data = [value_be[0], value_be[1], value_be[2], value_be[3], value_be[4], value_be[5], value_be[6], value_be[7], value_be[8], value_be[9], value_be[10], value_be[11], value_be[12], value_be[13], value_be[14], value_be[15], 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
1286                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
1287                prop_assert_eq!(
1288                    slicer.read_i128(true),
1289                    Ok(value)
1290                );
1291                prop_assert_eq!(slicer.offset, offset + 16);
1292                prop_assert_eq!(slicer.rest, &[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15][..slice_len - 16]);
1293            }
1294            // ok little endian
1295            {
1296                let value_le = value.to_le_bytes();
1297                let data = [
1298                    value_le[0], value_le[1], value_le[2], value_le[3], value_le[4], value_le[5], value_le[6], value_le[7], value_le[8], value_le[9], value_le[10], value_le[11], value_le[12], value_le[13], value_le[14], value_le[15], 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
1299                ];
1300                let mut slicer = FieldSlicer::new(&data[..slice_len], offset);
1301                prop_assert_eq!(
1302                    slicer.read_i128(false),
1303                    Ok(value)
1304                );
1305                prop_assert_eq!(slicer.offset, offset + 16);
1306                prop_assert_eq!(slicer.rest, &[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15][..slice_len - 16]);
1307            }
1308
1309            // length error
1310            {
1311                let expected = Err(VerboseDecodeError::UnexpectedEndOfSlice(
1312                    UnexpectedEndOfSliceError{
1313                        layer: Layer::VerboseValue,
1314                        actual_size: offset + bad_len,
1315                        minimum_size: offset + 16,
1316                    }
1317                ));
1318                let data = value.to_le_bytes();
1319                let mut slicer = FieldSlicer::new(&data[..bad_len], offset);
1320
1321                // little endian
1322                prop_assert_eq!(slicer.read_i128(false), expected.clone());
1323                prop_assert_eq!(slicer.offset, offset);
1324                prop_assert_eq!(slicer.rest, &data[..bad_len]);
1325
1326                // big endian
1327                prop_assert_eq!(slicer.read_i128(true), expected);
1328                prop_assert_eq!(slicer.offset, offset);
1329                prop_assert_eq!(slicer.rest, &data[..bad_len]);
1330            }
1331        }
1332    }
1333
1334    proptest! {
1335        #[test]
1336        fn read_var_name(
1337            ref value in "\\PC*",
1338            offset in 0usize..1024,
1339            bad_len in 0usize..1024,
1340            rest in vec(any::<u8>(), 0..4)
1341        ) {
1342            use VerboseDecodeError::*;
1343            // big endian version
1344            {
1345                let mut buffer = Vec::with_capacity(2 + value.len() + 1);
1346                buffer.extend_from_slice(&((value.len() + 1) as u16).to_be_bytes());
1347                buffer.extend_from_slice(value.as_bytes());
1348                buffer.push(0);
1349                buffer.extend_from_slice(&rest);
1350
1351                let mut slicer = FieldSlicer::new(&buffer, offset);
1352                prop_assert_eq!(slicer.read_var_name(true), Ok(value.as_str()));
1353                prop_assert_eq!(slicer.offset, offset + 2 + value.len() + 1);
1354                prop_assert_eq!(slicer.rest, &rest);
1355            }
1356
1357            // little endian version
1358            {
1359                let mut buffer = Vec::with_capacity(2 + value.len() + 1);
1360                buffer.extend_from_slice(&((value.len() + 1) as u16).to_le_bytes());
1361                buffer.extend_from_slice(value.as_bytes());
1362                buffer.push(0);
1363                buffer.extend_from_slice(&rest);
1364
1365                let mut slicer = FieldSlicer::new(&buffer, offset);
1366                prop_assert_eq!(slicer.read_var_name(false), Ok(value.as_str()));
1367                prop_assert_eq!(slicer.offset, offset + 2 + value.len() + 1);
1368                prop_assert_eq!(slicer.rest, &rest);
1369            }
1370
1371            // length error (length field)
1372            for len in 0..2 {
1373                let expected = Err(UnexpectedEndOfSlice(
1374                    UnexpectedEndOfSliceError{
1375                        layer: Layer::VerboseValue,
1376                        actual_size: offset + len,
1377                        minimum_size: offset + 2,
1378                    }
1379                ));
1380                {
1381                    let data = 2u16.to_le_bytes();
1382                    let mut slicer = FieldSlicer::new(&data[..len], offset);
1383                    prop_assert_eq!(slicer.read_var_name(false), expected.clone());
1384                    prop_assert_eq!(slicer.offset, offset);
1385                    prop_assert_eq!(slicer.rest, &data[..len]);
1386                }
1387                {
1388                    let data = 2u16.to_be_bytes();
1389                    let mut slicer = FieldSlicer::new(&data[..len], offset);
1390                    prop_assert_eq!(slicer.read_var_name(true), expected);
1391                    prop_assert_eq!(slicer.offset, offset);
1392                    prop_assert_eq!(slicer.rest, &data[..len]);
1393                }
1394            }
1395
1396            // length error (string value)
1397            if value.len() > 0 {
1398
1399                // make sure the len is actually smaller
1400                let bad_len = if bad_len >= value.len() {
1401                    value.len() - 1
1402                } else {
1403                    bad_len
1404                };
1405
1406                let expected = Err(UnexpectedEndOfSlice(
1407                    UnexpectedEndOfSliceError{
1408                        layer: Layer::VerboseValue,
1409                        actual_size: offset + 2 + bad_len,
1410                        minimum_size: offset + 2 + value.len(),
1411                    }
1412                ));
1413
1414                // little endian
1415                {
1416                    let mut buffer = Vec::with_capacity(2 + value.len());
1417                    buffer.extend_from_slice(&(value.len() as u16).to_le_bytes());
1418                    buffer.extend_from_slice(&value.as_bytes()[..bad_len]);
1419
1420                    let mut slicer = FieldSlicer::new(&buffer, offset);
1421                    prop_assert_eq!(slicer.read_var_name(false), expected.clone());
1422                    prop_assert_eq!(slicer.offset, offset);
1423                    prop_assert_eq!(slicer.rest, &buffer[..]);
1424                }
1425                // big endian
1426                {
1427                    let mut buffer = Vec::with_capacity(2 + value.len());
1428                    buffer.extend_from_slice(&(value.len() as u16).to_be_bytes());
1429                    buffer.extend_from_slice(&value.as_bytes()[..bad_len]);
1430
1431                    let mut slicer = FieldSlicer::new(&buffer, offset);
1432                    prop_assert_eq!(slicer.read_var_name(true), expected);
1433                    prop_assert_eq!(slicer.offset, offset);
1434                    prop_assert_eq!(slicer.rest, &buffer[..]);
1435                }
1436            }
1437
1438            // zero termination missing
1439            if value.len() > 0 {
1440                let mut buffer = Vec::with_capacity(2 + value.len() + rest.len());
1441                buffer.extend_from_slice(&((value.len()) as u16).to_be_bytes());
1442                buffer.extend_from_slice(value.as_bytes());
1443
1444                let mut slicer = FieldSlicer::new(&buffer, offset);
1445                prop_assert_eq!(slicer.read_var_name(true), Err(VariableNameStringMissingNullTermination));
1446
1447                prop_assert_eq!(slicer.offset, offset);
1448                prop_assert_eq!(slicer.rest, &buffer);
1449            } else {
1450                let mut buffer = Vec::with_capacity(2 + value.len() + rest.len());
1451                buffer.extend_from_slice(&0u16.to_be_bytes());
1452                buffer.extend_from_slice(&rest);
1453
1454                let mut slicer = FieldSlicer::new(&buffer, offset);
1455                prop_assert_eq!(slicer.read_var_name(true), Ok(""));
1456
1457                prop_assert_eq!(slicer.offset, offset + 2);
1458                prop_assert_eq!(slicer.rest, &rest);
1459            }
1460
1461            // utf8 error
1462            {
1463                let mut buffer = Vec::with_capacity(2 + value.len() + 4 + 1 + rest.len());
1464                buffer.extend_from_slice(&((value.len() + 4 + 1) as u16).to_be_bytes());
1465                buffer.extend_from_slice(value.as_bytes());
1466                // some invalid utf8 data
1467                buffer.extend_from_slice(&[0, 159, 146, 150]);
1468                buffer.push(0);
1469                let mut slicer = FieldSlicer::new(&buffer, offset);
1470                prop_assert_eq!(
1471                    slicer.read_var_name(true),
1472                    Err(Utf8(core::str::from_utf8(&buffer[2..(2 + value.len() + 4)]).unwrap_err()))
1473                );
1474            }
1475        }
1476    }
1477
1478    proptest! {
1479        #[test]
1480        fn read_var_name_and_unit(
1481            ref name in "\\PC*",
1482            ref unit in "\\PC*",
1483            offset in 0usize..1024,
1484            bad_len in 0usize..1024,
1485            rest in vec(any::<u8>(), 0..4)
1486        ) {
1487            use VerboseDecodeError::*;
1488
1489            // big endian version
1490            {
1491                let mut buffer = Vec::with_capacity(4 + name.len() + unit.len() + 2);
1492                buffer.extend_from_slice(&((name.len() + 1) as u16).to_be_bytes());
1493                buffer.extend_from_slice(&((unit.len() + 1) as u16).to_be_bytes());
1494                buffer.extend_from_slice(name.as_bytes());
1495                buffer.push(0);
1496                buffer.extend_from_slice(unit.as_bytes());
1497                buffer.push(0);
1498                buffer.extend_from_slice(&rest);
1499
1500                let mut slicer = FieldSlicer::new(&buffer, offset);
1501                prop_assert_eq!(
1502                    slicer.read_var_name_and_unit(true),
1503                    Ok((name.as_str(), unit.as_str()))
1504                );
1505                prop_assert_eq!(slicer.offset, offset + 4 + name.len() + unit.len() + 2);
1506                prop_assert_eq!(slicer.rest, &rest);
1507            }
1508
1509            // little endian version
1510            {
1511                let mut buffer = Vec::with_capacity(4 + name.len() + unit.len() + 2);
1512                buffer.extend_from_slice(&((name.len() + 1) as u16).to_le_bytes());
1513                buffer.extend_from_slice(&((unit.len() + 1) as u16).to_le_bytes());
1514                buffer.extend_from_slice(name.as_bytes());
1515                buffer.push(0);
1516                buffer.extend_from_slice(unit.as_bytes());
1517                buffer.push(0);
1518                buffer.extend_from_slice(&rest);
1519
1520                let mut slicer = FieldSlicer::new(&buffer, offset);
1521                prop_assert_eq!(
1522                    slicer.read_var_name_and_unit(false),
1523                    Ok((name.as_str(), unit.as_str()))
1524                );
1525                prop_assert_eq!(slicer.offset, offset + 4 + name.len() + unit.len() + 2);
1526                prop_assert_eq!(slicer.rest, &rest);
1527            }
1528
1529            // length error (length values)
1530            for len in 0..4 {
1531                let expected = Err(UnexpectedEndOfSlice(
1532                    UnexpectedEndOfSliceError{
1533                        layer: Layer::VerboseValue,
1534                        actual_size: offset + len,
1535                        minimum_size: offset + 4,
1536                    }
1537                ));
1538                {
1539                    let data = [0, 0, 0, 0];
1540                    let mut slicer = FieldSlicer::new(&data[..len], offset);
1541                    prop_assert_eq!(slicer.read_var_name_and_unit(false), expected.clone());
1542                    prop_assert_eq!(slicer.offset, offset);
1543                    prop_assert_eq!(slicer.rest, &data[..len]);
1544                }
1545                {
1546                    let data = [0, 0, 0, 0];
1547                    let mut slicer = FieldSlicer::new(&data[..len], offset);
1548                    prop_assert_eq!(slicer.read_var_name_and_unit(true), expected);
1549                    prop_assert_eq!(slicer.offset, offset);
1550                    prop_assert_eq!(slicer.rest, &data[..len]);
1551                }
1552            }
1553
1554            // length error (string name)
1555            {
1556                // make sure the len is actually smaller
1557                let bad_len = if bad_len > name.len() {
1558                    name.len()
1559                } else {
1560                    bad_len
1561                };
1562
1563                let expected = Err(UnexpectedEndOfSlice(
1564                    UnexpectedEndOfSliceError{
1565                        layer: Layer::VerboseValue,
1566                        actual_size: offset + 4 + bad_len,
1567                        minimum_size: offset + 4 + name.len() + 1 + unit.len() + 1,
1568                    }
1569                ));
1570
1571                // little endian
1572                {
1573                    let mut buffer = Vec::with_capacity(4 + name.len() + unit.len());
1574                    buffer.extend_from_slice(&((name.len() + 1) as u16).to_le_bytes());
1575                    buffer.extend_from_slice(&((unit.len() + 1) as u16).to_le_bytes());
1576                    buffer.extend_from_slice(&name.as_bytes()[..bad_len]);
1577
1578                    let mut slicer = FieldSlicer::new(&buffer, offset);
1579                    prop_assert_eq!(slicer.read_var_name_and_unit(false), expected.clone());
1580                    prop_assert_eq!(slicer.offset, offset);
1581                    prop_assert_eq!(slicer.rest, &buffer[..]);
1582                }
1583                // big endian
1584                {
1585                    let mut buffer = Vec::with_capacity(4 + name.len() + unit.len());
1586                    buffer.extend_from_slice(&((name.len() + 1) as u16).to_be_bytes());
1587                    buffer.extend_from_slice(&((unit.len() + 1) as u16).to_be_bytes());
1588                    buffer.extend_from_slice(&name.as_bytes()[..bad_len]);
1589
1590                    let mut slicer = FieldSlicer::new(&buffer, offset);
1591                    prop_assert_eq!(slicer.read_var_name_and_unit(true), expected);
1592                    prop_assert_eq!(slicer.offset, offset);
1593                    prop_assert_eq!(slicer.rest, &buffer[..]);
1594                }
1595            }
1596
1597            // length error (string unit)
1598            {
1599                // make sure the len is actually smaller
1600                let bad_len = if bad_len > unit.len() {
1601                    unit.len()
1602                } else {
1603                    bad_len
1604                };
1605
1606                let expected = Err(UnexpectedEndOfSlice(
1607                    UnexpectedEndOfSliceError{
1608                        layer: Layer::VerboseValue,
1609                        actual_size: offset + 4 + name.len() + 1 + bad_len,
1610                        minimum_size: offset + 4 + name.len() + 1 + unit.len() + 1,
1611                    }
1612                ));
1613
1614                // little endian
1615                {
1616                    let mut buffer = Vec::with_capacity(4 + name.len() + unit.len());
1617                    buffer.extend_from_slice(&((name.len() + 1) as u16).to_le_bytes());
1618                    buffer.extend_from_slice(&((unit.len() + 1) as u16).to_le_bytes());
1619                    buffer.extend_from_slice(&name.as_bytes());
1620                    buffer.push(0);
1621                    buffer.extend_from_slice(&unit.as_bytes()[..bad_len]);
1622
1623                    let mut slicer = FieldSlicer::new(&buffer, offset);
1624                    prop_assert_eq!(slicer.read_var_name_and_unit(false), expected.clone());
1625                    prop_assert_eq!(slicer.offset, offset);
1626                    prop_assert_eq!(slicer.rest, &buffer[..]);
1627                }
1628                // big endian
1629                {
1630                    let mut buffer = Vec::with_capacity(4 + name.len() + unit.len());
1631                    buffer.extend_from_slice(&((name.len() + 1) as u16).to_be_bytes());
1632                    buffer.extend_from_slice(&((unit.len() + 1) as u16).to_be_bytes());
1633                    buffer.extend_from_slice(&name.as_bytes());
1634                    buffer.push(0);
1635                    buffer.extend_from_slice(&unit.as_bytes()[..bad_len]);
1636
1637                    let mut slicer = FieldSlicer::new(&buffer, offset);
1638                    prop_assert_eq!(slicer.read_var_name_and_unit(true), expected);
1639                    prop_assert_eq!(slicer.offset, offset);
1640                    prop_assert_eq!(slicer.rest, &buffer[..]);
1641                }
1642            }
1643
1644            // zero termination error (name)
1645            if name.len() > 0 {
1646                let mut buffer = Vec::with_capacity(4 + name.len() + unit.len() + 1 + rest.len());
1647                buffer.extend_from_slice(&(name.len() as u16).to_be_bytes());
1648                buffer.extend_from_slice(&((unit.len() + 1) as u16).to_be_bytes());
1649                buffer.extend_from_slice(name.as_bytes());
1650                // skip zero termination
1651                buffer.extend_from_slice(unit.as_bytes());
1652                buffer.push(0);
1653
1654                let mut slicer = FieldSlicer::new(&buffer, offset);
1655                prop_assert_eq!(slicer.read_var_name_and_unit(true), Err(VariableNameStringMissingNullTermination));
1656
1657                prop_assert_eq!(slicer.offset, offset);
1658                prop_assert_eq!(slicer.rest, &buffer);
1659            } else {
1660                // strings with length 0 are allowed to have no zero termination
1661                let mut buffer = Vec::with_capacity(4 + unit.len() + 0 + rest.len());
1662                buffer.extend_from_slice(&(0 as u16).to_be_bytes());
1663                buffer.extend_from_slice(&((unit.len() + 1) as u16).to_be_bytes());
1664                // skip name as it has len 0,
1665                buffer.extend_from_slice(unit.as_bytes());
1666                buffer.push(0);
1667                buffer.extend_from_slice(&rest);
1668
1669                let mut slicer = FieldSlicer::new(&buffer, offset);
1670                prop_assert_eq!(slicer.read_var_name_and_unit(true), Ok(("", unit.as_str())));
1671
1672                prop_assert_eq!(slicer.offset, offset + 4 + unit.len() + 1);
1673                prop_assert_eq!(slicer.rest, &rest);
1674            }
1675
1676            // zero termination error (unit)
1677            if unit.len() > 0 {
1678                let mut buffer = Vec::with_capacity(4 + name.len() + 1 + unit.len() + rest.len());
1679                buffer.extend_from_slice(&((name.len() + 1) as u16).to_be_bytes());
1680                buffer.extend_from_slice(&(unit.len() as u16).to_be_bytes());
1681                buffer.extend_from_slice(name.as_bytes());
1682                buffer.push(0);
1683                buffer.extend_from_slice(unit.as_bytes());
1684                // skip zero termination
1685
1686                let mut slicer = FieldSlicer::new(&buffer, offset);
1687                prop_assert_eq!(slicer.read_var_name_and_unit(true), Err(VariableUnitStringMissingNullTermination));
1688
1689                prop_assert_eq!(slicer.offset, offset);
1690                prop_assert_eq!(slicer.rest, &buffer);
1691            } else {
1692                // strings with length 0 are allowed to have no zero termination
1693                let mut buffer = Vec::with_capacity(4 + name.len() + 1 + rest.len());
1694                buffer.extend_from_slice(&((name.len() + 1) as u16).to_be_bytes());
1695                buffer.extend_from_slice(&(0 as u16).to_be_bytes());
1696                buffer.extend_from_slice(name.as_bytes());
1697                buffer.push(0);
1698                // skip unit as it has len 0,
1699                buffer.extend_from_slice(&rest);
1700
1701                let mut slicer = FieldSlicer::new(&buffer, offset);
1702                prop_assert_eq!(slicer.read_var_name_and_unit(true), Ok((name.as_str(), "")));
1703
1704                prop_assert_eq!(slicer.offset, offset + 4 + name.len() + 1);
1705                prop_assert_eq!(slicer.rest, &rest);
1706            }
1707
1708            // utf8 error (name)
1709            {
1710                let mut buffer = Vec::with_capacity(4 + name.len() + 4 + 1 + unit.len() + 1 + rest.len());
1711                buffer.extend_from_slice(&((name.len() + 4 + 1) as u16).to_be_bytes());
1712                buffer.extend_from_slice(&((unit.len() + 1) as u16).to_be_bytes());
1713                buffer.extend_from_slice(name.as_bytes());
1714                // some invalid utf8 data
1715                buffer.extend_from_slice(&[0, 159, 146, 150]);
1716                buffer.push(0);
1717                buffer.extend_from_slice(unit.as_bytes());
1718                buffer.push(0);
1719                let mut slicer = FieldSlicer::new(&buffer, offset);
1720                prop_assert_eq!(
1721                    slicer.read_var_name_and_unit(true),
1722                    Err(Utf8(core::str::from_utf8(&buffer[4..(4 + name.len() + 4)]).unwrap_err()))
1723                );
1724            }
1725
1726            // utf8 error (name)
1727            {
1728                let mut buffer = Vec::with_capacity(4 + name.len() + 1 + unit.len() + 4 + 1 + rest.len());
1729                buffer.extend_from_slice(&((name.len() + 1) as u16).to_be_bytes());
1730                buffer.extend_from_slice(&((unit.len() + 4 + 1) as u16).to_be_bytes());
1731                buffer.extend_from_slice(name.as_bytes());
1732                buffer.push(0);
1733                buffer.extend_from_slice(unit.as_bytes());
1734                // some invalid utf8 data
1735                buffer.extend_from_slice(&[0, 159, 146, 150]);
1736                buffer.push(0);
1737                let mut slicer = FieldSlicer::new(&buffer, offset);
1738                prop_assert_eq!(
1739                    slicer.read_var_name_and_unit(true),
1740                    Err(Utf8(core::str::from_utf8(&buffer[(4 + name.len() + 1)..(4 + name.len() + 1 + unit.len() + 4)]).unwrap_err()))
1741                );
1742            }
1743        }
1744    }
1745
1746    proptest! {
1747        #[test]
1748        fn read_raw(
1749            data in prop::collection::vec(any::<u8>(), 0..1024),
1750            offset in 0usize..1024,
1751            rest in prop::collection::vec(any::<u8>(), 0..10),
1752            bad_len in 0usize..1024,
1753        ) {
1754            // ok case
1755            {
1756                let mut buffer = Vec::with_capacity(data.len() + rest.len());
1757                buffer.extend_from_slice(&data);
1758                buffer.extend_from_slice(&rest);
1759
1760                let mut slicer = FieldSlicer::new(&buffer, offset);
1761                prop_assert_eq!(slicer.read_raw(data.len()), Ok(&data[..]));
1762                prop_assert_eq!(slicer.offset, offset + data.len());
1763                prop_assert_eq!(slicer.rest, &rest);
1764            }
1765
1766            // length error
1767            if data.len() > 0 {
1768
1769                // make sure the len is actually smaller
1770                let bad_len = if bad_len >= data.len() {
1771                    data.len() - 1
1772                } else {
1773                    bad_len
1774                };
1775
1776                let mut buffer = Vec::with_capacity(data.len());
1777                buffer.extend_from_slice(&data[..bad_len]);
1778
1779                let mut slicer = FieldSlicer::new(&buffer, offset);
1780                prop_assert_eq!(
1781                    slicer.read_raw(data.len()),
1782                    Err(VerboseDecodeError::UnexpectedEndOfSlice(UnexpectedEndOfSliceError{
1783                        layer: Layer::VerboseValue,
1784                        actual_size: offset + bad_len,
1785                        minimum_size: offset + data.len(),
1786                    }))
1787                );
1788                prop_assert_eq!(slicer.offset, offset);
1789                prop_assert_eq!(slicer.rest, &buffer[..]);
1790            }
1791        }
1792    }
1793}
dlt_parse/verbose/field_slicer.rs

dlt_parse/verbose/
field_slicer.rs
