dlt_parse/verbose/values/
array_i128.rs

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

dlt_parse/verbose/values/
array_i128.rs
