use crate::verbose::{ArrayDimensions, VariableInfoUnit};
#[cfg(feature = "serde")]
use super::ArrayItDimension;
use arrayvec::{ArrayVec, CapacityError};
#[cfg(feature = "serde")]
use serde::ser::{Serialize, SerializeSeq, SerializeStruct, Serializer};
#[derive(Debug, PartialEq, Clone)]
pub struct ArrayF32<'a> {
pub is_big_endian: bool,
pub dimensions: ArrayDimensions<'a>,
pub variable_info: Option<VariableInfoUnit<'a>>,
pub(crate) data: &'a [u8],
}
impl<'a> ArrayF32<'a> {
pub fn data(&self) -> &'a [u8] {
self.data
}
pub fn iter(&'a self) -> ArrayF32Iterator<'a> {
ArrayF32Iterator {
is_big_endian: self.is_big_endian,
rest: self.data,
}
}
/// Adds the verbose value to the given dlt mesage buffer.
pub fn add_to_msg<const CAP: usize>(
&self,
buf: &mut ArrayVec<u8, CAP>,
is_big_endian: bool,
) -> Result<(), CapacityError> {
if let Some(var_info) = &self.variable_info {
let (name_len, unit_len, number_of_dimensions) = if is_big_endian {
(
(var_info.name.len() as u16 + 1).to_be_bytes(),
(var_info.unit.len() as u16 + 1).to_be_bytes(),
(self.dimensions.dimensions.len() as u16 / 2).to_be_bytes(),
)
} else {
(
(var_info.name.len() as u16 + 1).to_le_bytes(),
(var_info.unit.len() as u16 + 1).to_le_bytes(),
(self.dimensions.dimensions.len() as u16 / 2).to_le_bytes(),
)
};
let type_info: [u8; 4] = [0b1000_0011, 0b0000_1001, 0b0000_0000, 0b0000_0000];
buf.try_extend_from_slice(&type_info)?;
buf.try_extend_from_slice(&number_of_dimensions)?;
buf.try_extend_from_slice(self.dimensions.dimensions)?;
buf.try_extend_from_slice(&[name_len[0], name_len[1], unit_len[0], unit_len[1]])?;
buf.try_extend_from_slice(var_info.name.as_bytes())?;
if buf.remaining_capacity() > var_info.unit.len() + 2 {
// Safe as capacity is checked earlier
unsafe { buf.push_unchecked(0) };
let _ = buf.try_extend_from_slice(var_info.unit.as_bytes());
unsafe { buf.push_unchecked(0) };
} else {
return Err(CapacityError::new(()));
}
buf.try_extend_from_slice(self.data)?;
} else {
let number_of_dimensions = if is_big_endian {
(self.dimensions.dimensions.len() as u16 / 2).to_be_bytes()
} else {
(self.dimensions.dimensions.len() as u16 / 2).to_le_bytes()
};
let type_info: [u8; 4] = [0b1000_0011, 0b0000_0001, 0b0000_0000, 0b0000_0000];
buf.try_extend_from_slice(&type_info)?;
buf.try_extend_from_slice(&number_of_dimensions)?;
buf.try_extend_from_slice(self.dimensions.dimensions)?;
buf.try_extend_from_slice(self.data)?;
}
Ok(())
}
}
#[cfg(feature = "serde")]
impl<'a> Serialize for ArrayF32<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut state = serializer.serialize_struct("ArrayF32", 2)?;
state.serialize_field("variable_info", &self.variable_info)?;
let iter = ArrayItDimension::<f32> {
is_big_endian: self.is_big_endian,
dimensions: self.dimensions.dimensions,
data: self.data,
phantom: Default::default(),
};
state.serialize_field("data", &iter)?;
state.end()
}
}
#[derive(Debug, Clone)]
pub struct ArrayF32Iterator<'a> {
pub(crate) is_big_endian: bool,
pub(crate) rest: &'a [u8],
}
impl Iterator for ArrayF32Iterator<'_> {
type Item = f32;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
if self.rest.len() < 4 {
None
} else {
let result = if self.is_big_endian {
f32::from_be_bytes([self.rest[0], self.rest[1], self.rest[2], self.rest[3]])
} else {
f32::from_le_bytes([self.rest[0], self.rest[1], self.rest[2], self.rest[3]])
};
self.rest = &self.rest[4..];
Some(result)
}
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
(self.rest.len() / 4, Some(self.rest.len() / 4))
}
#[inline]
fn count(self) -> usize {
self.rest.len() / 4
}
#[inline]
fn last(self) -> Option<Self::Item> {
if self.rest.len() < 4 {
None
} else {
let last_index = ((self.rest.len() / 4) - 1) * 4;
let bytes = unsafe {
// SAFETY: Safe as len checked to be at least 4.
[
*self.rest.get_unchecked(last_index),
*self.rest.get_unchecked(last_index + 1),
*self.rest.get_unchecked(last_index + 2),
*self.rest.get_unchecked(last_index + 3),
]
};
Some(if self.is_big_endian {
f32::from_be_bytes(bytes)
} else {
f32::from_le_bytes(bytes)
})
}
}
#[inline]
fn nth(&mut self, n: usize) -> Option<Self::Item> {
// Formula converted to ensure no overflow occurs:
// n*4 + 4 <= self.rest.len()
// n*4 <= self.rest.len() - 4
// n <= (self.rest.len() - 4) / 4
if self.rest.len() >= 4 && n <= (self.rest.len() - 4) / 4 {
let index = n * 4;
let bytes = unsafe {
[
// SAFETY: Safe as the length is checked beforehand to be at least n*4 + 4
*self.rest.get_unchecked(index),
*self.rest.get_unchecked(index + 1),
*self.rest.get_unchecked(index + 2),
*self.rest.get_unchecked(index + 3),
]
};
let result = if self.is_big_endian {
f32::from_be_bytes(bytes)
} else {
f32::from_le_bytes(bytes)
};
self.rest = unsafe {
// SAFETY: Safe as the length is checked beforehand to be at least n*4 + 4
core::slice::from_raw_parts(
self.rest.as_ptr().add(index + 4),
self.rest.len() - index - 4,
)
};
Some(result)
} else {
self.rest = unsafe {
// SAFETY: Safe as the slice gets moved to its end with len 0.
core::slice::from_raw_parts(self.rest.as_ptr().add(self.rest.len()), 0)
};
None
}
}
}
impl ExactSizeIterator for ArrayF32Iterator<'_> {
#[inline]
fn len(&self) -> usize {
self.rest.len() / 4
}
}
impl<'a> IntoIterator for &'a ArrayF32<'a> {
type Item = f32;
type IntoIter = ArrayF32Iterator<'a>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
#[cfg(feature = "serde")]
impl<'a> Serialize for ArrayF32Iterator<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut seq = serializer.serialize_seq(Some(self.rest.len() / 4))?;
for e in self.clone() {
seq.serialize_element(&e)?;
}
seq.end()
}
}
#[cfg(test)]
mod test {
use super::*;
use crate::error::UnexpectedEndOfSliceError;
use crate::error::VerboseDecodeError::UnexpectedEndOfSlice;
use crate::verbose::VerboseValue;
use crate::verbose::VerboseValue::ArrF32;
use alloc::vec::Vec;
use proptest::prelude::*;
use std::format;
use std::mem::size_of;
type TestType<'a> = ArrayF32<'a>;
type InternalTypes = f32;
proptest! {
#[test]
fn write_read(ref name in "\\pc{0,20}", ref unit in "\\pc{0,20}", dim_count in 0u16..5) {
const TYPE_INFO_RAW: [u8; 4] = [0b1000_0011, 0b0000_0001, 0b0000_0000, 0b0000_0000];
const VAR_INFO_FLAG: u8 = 0b0000_1000;
const BUFFER_SIZE: usize = 400;
// test big endian with name
{
let mut msg_buff: ArrayVec<u8, BUFFER_SIZE> = ArrayVec::new();
let is_big_endian = true;
let variable_info = Some(VariableInfoUnit { name , unit });
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
for i in 0..dim_count {
dimensions.extend_from_slice(&(i+1).to_be_bytes());
for x in 0..=i as i16 {
if x % 2 == 1 {
content.extend_from_slice(&(InternalTypes::from(x)).to_be_bytes());
}
else {
content.extend_from_slice(&(InternalTypes::from(-1* x)).to_be_bytes());
}
}
}
let arr_dim = ArrayDimensions { is_big_endian, dimensions: &dimensions };
let arr = TestType {is_big_endian, variable_info,dimensions:arr_dim,data: &content };
arr.add_to_msg(&mut msg_buff, is_big_endian)?;
let len_name = (name.len() as u16 + 1).to_be_bytes();
let len_unit = (unit.len() as u16 + 1).to_be_bytes();
let mut content_buff = Vec::new();
content_buff.extend_from_slice(&[TYPE_INFO_RAW[0], TYPE_INFO_RAW[1] | VAR_INFO_FLAG, TYPE_INFO_RAW[2], TYPE_INFO_RAW[3]]);
content_buff.extend_from_slice(&dim_count.to_be_bytes());
content_buff.extend_from_slice(&dimensions);
content_buff.extend_from_slice(&[len_name[0], len_name[1], len_unit[0], len_unit[1]]);
content_buff.extend_from_slice(name.as_bytes());
content_buff.push(0);
content_buff.extend_from_slice(unit.as_bytes());
content_buff.push(0);
content_buff.extend_from_slice(&content);
prop_assert_eq!(&msg_buff[..], &content_buff[..]);
// Now wrap back
let parsed_back = VerboseValue::from_slice(&msg_buff, is_big_endian);
prop_assert_eq!(parsed_back, Ok((ArrF32(arr),&[] as &[u8])));
}
// test little endian with name
{
let mut msg_buff: ArrayVec<u8, BUFFER_SIZE> = ArrayVec::new();
let is_big_endian = false;
let variable_info = Some(VariableInfoUnit { name , unit });
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
for i in 0..dim_count {
dimensions.extend_from_slice(&(i+1).to_le_bytes());
for x in 0..=i as i16 {
if x % 2 == 1 {
content.extend_from_slice(&(InternalTypes::from(x)).to_le_bytes());
}
else {
content.extend_from_slice(&(InternalTypes::from(-1 * x)).to_le_bytes());
}
}
}
let arr_dim = ArrayDimensions { is_big_endian, dimensions: &dimensions };
let arr = TestType {is_big_endian, variable_info,dimensions:arr_dim,data: &content };
arr.add_to_msg(&mut msg_buff, is_big_endian)?;
let len_name = (name.len() as u16 + 1).to_le_bytes();
let len_unit = (unit.len() as u16 + 1).to_le_bytes();
let mut content_buff = Vec::new();
content_buff.extend_from_slice(&[TYPE_INFO_RAW[0], TYPE_INFO_RAW[1] | VAR_INFO_FLAG, TYPE_INFO_RAW[2], TYPE_INFO_RAW[3]]);
content_buff.extend_from_slice(&dim_count.to_le_bytes());
content_buff.extend_from_slice(&dimensions);
content_buff.extend_from_slice(&[len_name[0], len_name[1], len_unit[0], len_unit[1]]);
content_buff.extend_from_slice(name.as_bytes());
content_buff.push(0);
content_buff.extend_from_slice(unit.as_bytes());
content_buff.push(0);
content_buff.extend_from_slice(&content);
prop_assert_eq!(&msg_buff[..], &content_buff[..]);
// Now wrap back
let parsed_back = VerboseValue::from_slice(&msg_buff, is_big_endian);
prop_assert_eq!(parsed_back, Ok((ArrF32(arr),&[] as &[u8])));
}
// test big endian without name
{
let mut msg_buff: ArrayVec<u8, BUFFER_SIZE> = ArrayVec::new();
let is_big_endian = true;
let variable_info = None;
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
for i in 0..dim_count {
dimensions.extend_from_slice(&(i+1).to_be_bytes());
for x in 0..=i as i16 {
if x % 2 == 1 {
content.extend_from_slice(&(InternalTypes::from(x)).to_be_bytes());
}
else {
content.extend_from_slice(&(InternalTypes::from(-1 * x)).to_be_bytes());
}
}
}
let arr_dim = ArrayDimensions { is_big_endian, dimensions: &dimensions };
let arr = TestType {is_big_endian, variable_info,dimensions:arr_dim,data: &content };
arr.add_to_msg(&mut msg_buff, is_big_endian)?;
let mut content_buff = Vec::new();
content_buff.extend_from_slice(&[TYPE_INFO_RAW[0], TYPE_INFO_RAW[1], TYPE_INFO_RAW[2], TYPE_INFO_RAW[3]]);
content_buff.extend_from_slice(&dim_count.to_be_bytes());
content_buff.extend_from_slice(&dimensions);
content_buff.extend_from_slice(&content);
prop_assert_eq!(&msg_buff[..], &content_buff[..]);
// Now wrap back
let parsed_back = VerboseValue::from_slice(&msg_buff, is_big_endian);
prop_assert_eq!(parsed_back, Ok((ArrF32(arr),&[] as &[u8])));
}
// test little endian without name
{
let mut msg_buff: ArrayVec<u8, BUFFER_SIZE> = ArrayVec::new();
let is_big_endian = false;
let variable_info = None;
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
for i in 0..dim_count {
dimensions.extend_from_slice(&(i+1).to_le_bytes());
for x in 0..=i as i16 {
if x % 2 == 1 {
content.extend_from_slice(&(InternalTypes::from(x)).to_le_bytes());
}
else {
content.extend_from_slice(&(InternalTypes::from(-1 * x)).to_le_bytes());
}
}
}
let arr_dim = ArrayDimensions { is_big_endian, dimensions: &dimensions };
let arr = TestType {is_big_endian, variable_info,dimensions:arr_dim,data: &content };
arr.add_to_msg(&mut msg_buff, is_big_endian)?;
let mut content_buff = Vec::new();
content_buff.extend_from_slice(&[TYPE_INFO_RAW[0], TYPE_INFO_RAW[1], TYPE_INFO_RAW[2], TYPE_INFO_RAW[3]]);
content_buff.extend_from_slice(&dim_count.to_le_bytes());
content_buff.extend_from_slice(&dimensions);
content_buff.extend_from_slice(&content);
prop_assert_eq!(&msg_buff[..], &content_buff[..]);
// Now wrap back
let parsed_back = VerboseValue::from_slice(&msg_buff, is_big_endian);
prop_assert_eq!(parsed_back, Ok((ArrF32(arr),&[] as &[u8])));
}
// Capacity error big endian with name
{
let dim_count = dim_count + 1;
let mut msg_buff: ArrayVec<u8, BUFFER_SIZE> = ArrayVec::new();
let is_big_endian = true;
let variable_info = Some(VariableInfoUnit { name , unit });
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
for i in 1u16..=dim_count {
dimensions.extend_from_slice(&(i as u16).to_be_bytes());
for x in 0..(i-1) as i16 {
if x % 2 == 1 {
content.extend_from_slice(&(InternalTypes::from(x)).to_be_bytes());
}
else {
content.extend_from_slice(&(InternalTypes::from(-1* x)).to_be_bytes());
}
}
}
let arr_dim = ArrayDimensions { is_big_endian, dimensions: &dimensions };
let arr = TestType {is_big_endian, variable_info,dimensions:arr_dim,data: &content };
arr.add_to_msg(&mut msg_buff, is_big_endian)?;
// Now wrap back
let parsed_back = VerboseValue::from_slice(&msg_buff, is_big_endian);
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() })));
}
// Capacity error little endian with name
{
let dim_count = dim_count + 1;
let mut msg_buff: ArrayVec<u8, BUFFER_SIZE> = ArrayVec::new();
let is_big_endian = false;
let variable_info = Some(VariableInfoUnit { name , unit });
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
for i in 1u16..=dim_count {
dimensions.extend_from_slice(&(i as u16).to_le_bytes());
for x in 0..(i-1) as i16 {
if x % 2 == 1 {
content.extend_from_slice(&(InternalTypes::from(x)).to_le_bytes());
}
else {
content.extend_from_slice(&(InternalTypes::from(-1 * x)).to_le_bytes());
}
}
}
let arr_dim = ArrayDimensions { is_big_endian, dimensions: &dimensions };
let arr = TestType {is_big_endian, variable_info,dimensions:arr_dim,data: &content };
arr.add_to_msg(&mut msg_buff, is_big_endian)?;
// Now wrap back
let parsed_back = VerboseValue::from_slice(&msg_buff, is_big_endian);
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() })));
}
// Capacity error big endian without name
{
let dim_count = dim_count + 1;
let mut msg_buff: ArrayVec<u8, BUFFER_SIZE> = ArrayVec::new();
let is_big_endian = true;
let variable_info = None;
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
for i in 1u16..=dim_count {
dimensions.extend_from_slice(&(i as u16).to_be_bytes());
for x in 0..(i-1) as i16 {
if x % 2 == 1 {
content.extend_from_slice(&(InternalTypes::from(x)).to_be_bytes());
}
else {
content.extend_from_slice(&(InternalTypes::from(-1 * x)).to_be_bytes());
}
}
}
let arr_dim = ArrayDimensions { is_big_endian, dimensions: &dimensions };
let arr = TestType {is_big_endian, variable_info,dimensions:arr_dim,data: &content };
arr.add_to_msg(&mut msg_buff, is_big_endian)?;
// Now wrap back
let parsed_back = VerboseValue::from_slice(&msg_buff, is_big_endian);
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() })));
}
// Capacity error little endian without name
{
let dim_count = dim_count + 1;
let mut msg_buff: ArrayVec<u8, BUFFER_SIZE> = ArrayVec::new();
let is_big_endian = false;
let variable_info = None;
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
for i in 1u16..=dim_count {
dimensions.extend_from_slice(&(i as u16).to_le_bytes());
for x in 0..(i-1) as i16 {
if x % 2 == 1 {
content.extend_from_slice(&(InternalTypes::from(x)).to_le_bytes());
}
else {
content.extend_from_slice(&(InternalTypes::from(-1 * x)).to_le_bytes());
}
}
}
let arr_dim = ArrayDimensions { is_big_endian, dimensions: &dimensions };
let arr = TestType {is_big_endian, variable_info,dimensions:arr_dim,data: &content };
arr.add_to_msg(&mut msg_buff, is_big_endian)?;
// Now wrap back
let parsed_back = VerboseValue::from_slice(&msg_buff, is_big_endian);
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() })));
}
// capacity error big endian with name 2
{
let name = "Abc";
let unit = "Xyz";
const DIM_COUNT: u16 = 5;
const BUFFER_SIZE: usize = DIM_COUNT as usize * 2 + 14;
let mut msg_buff: ArrayVec<u8, BUFFER_SIZE> = ArrayVec::new();
let is_big_endian = true;
let variable_info = Some(VariableInfoUnit { name , unit });
let mut dimensions = Vec::with_capacity(DIM_COUNT as usize);
let mut content = Vec::with_capacity(DIM_COUNT as usize);
for i in 0..DIM_COUNT as i16 {
dimensions.extend_from_slice(&(1 as InternalTypes).to_be_bytes());
if i % 2 == 1 {
content.extend_from_slice(&i.to_be_bytes());
}
else {
content.extend_from_slice(&(-1* i).to_be_bytes());
}
}
let arr_dim = ArrayDimensions { is_big_endian, dimensions: &dimensions };
let arr = TestType {is_big_endian, variable_info,dimensions:arr_dim,data: &content };
let err = arr.add_to_msg(&mut msg_buff, is_big_endian);
prop_assert_eq!(err, Err(CapacityError::new(())));
}
// capacity error little endian with name
{
let name = "Abc";
let unit = "Xyz";
const DIM_COUNT: u16 = 5;
const BUFFER_SIZE: usize = DIM_COUNT as usize * 2 + 15;
let mut msg_buff: ArrayVec<u8, BUFFER_SIZE> = ArrayVec::new();
let is_big_endian = true;
let variable_info = Some(VariableInfoUnit { name , unit });
let mut dimensions = Vec::with_capacity(DIM_COUNT as usize);
let mut content = Vec::with_capacity(DIM_COUNT as usize);
for i in 0..DIM_COUNT as i16 {
dimensions.extend_from_slice(&(1 as u16).to_le_bytes());
if i % 2 == 1 {
content.extend_from_slice(&(InternalTypes::from(i)).to_le_bytes());
}
else {
content.extend_from_slice(&(InternalTypes::from(-1 * i)).to_le_bytes());
}
}
let arr_dim = ArrayDimensions { is_big_endian, dimensions: &dimensions };
let arr = TestType {is_big_endian, variable_info,dimensions:arr_dim,data: &content };
let err = arr.add_to_msg(&mut msg_buff, is_big_endian);
prop_assert_eq!(err, Err(CapacityError::new(())));
}
}
}
proptest! {
#[test]
fn data(ref data in "\\pc{0,100}", ref dimensions in "\\pc{0,100}") {
let arr_dim = ArrayDimensions {dimensions: dimensions.as_bytes(), is_big_endian: true };
let arr = TestType {is_big_endian: true, dimensions:arr_dim,variable_info:None,data:data.as_bytes() };
prop_assert_eq!(arr.data(), data.as_bytes());
}
}
fn two_values_bytes_for(is_big_endian: bool, value0: f32, value1: f32) -> [u8; 8 + 3] {
let v0_bytes = if is_big_endian {
value0.to_be_bytes()
} else {
value0.to_le_bytes()
};
let v1_bytes = if is_big_endian {
value1.to_be_bytes()
} else {
value1.to_le_bytes()
};
[
v0_bytes[0],
v0_bytes[1],
v0_bytes[2],
v0_bytes[3],
v1_bytes[0],
v1_bytes[1],
v1_bytes[2],
v1_bytes[3],
0,
0,
0,
]
}
proptest! {
#[test]
fn next(
value0 in any::<f32>(),
value1 in any::<f32>()
) {
// empty
{
let mut iter = ArrayF32Iterator{
is_big_endian: false,
rest: &[],
};
assert!(iter.next().is_none());
}
// run through the different variants
for is_big_endian in [false, true] {
let bytes = two_values_bytes_for(is_big_endian, value0, value1);
for padding_offset in 0..=3 {
let mut iter = ArrayF32Iterator{
is_big_endian,
rest: &bytes[.. bytes.len() - padding_offset],
};
assert_eq!(
Some(value0),
iter.next()
);
assert_eq!(
Some(value1),
iter.next()
);
assert_eq!(
None,
iter.next()
);
}
}
}
}
proptest! {
#[test]
fn size_hint_count_len(
value0 in any::<f32>(),
value1 in any::<f32>()
) {
// empty
{
let iter = ArrayF32Iterator{
is_big_endian: false,
rest: &[],
};
assert_eq!(0, iter.len());
assert_eq!(0, iter.clone().count());
assert_eq!((0, Some(0)), iter.size_hint());
}
// run through the different variants
for is_big_endian in [false, true] {
let bytes = two_values_bytes_for(is_big_endian, value0, value1);
for padding_offset in 0..=3 {
let mut iter = ArrayF32Iterator{
is_big_endian,
rest: &bytes[.. bytes.len() - padding_offset],
};
assert_eq!((2, Some(2)), iter.size_hint());
assert_eq!(2, iter.clone().count());
assert_eq!(2, iter.len());
assert_eq!(
Some(value0),
iter.next()
);
assert_eq!((1, Some(1)), iter.size_hint());
assert_eq!(1, iter.clone().count());
assert_eq!(1, iter.len());
assert_eq!(
Some(value1),
iter.next()
);
assert_eq!((0, Some(0)), iter.size_hint());
assert_eq!(0, iter.clone().count());
assert_eq!(0, iter.len());
assert_eq!(
None,
iter.next()
);
}
}
}
}
proptest! {
#[test]
fn last(
value0 in any::<f32>(),
value1 in any::<f32>()
) {
// empty
{
let iter = ArrayF32Iterator{
is_big_endian: false,
rest: &[],
};
assert!(iter.last().is_none());
}
for is_big_endian in [false, true] {
let bytes = two_values_bytes_for(is_big_endian, value0, value1);
for padding_offset in 0..=3 {
let mut iter = ArrayF32Iterator{
is_big_endian,
rest: &bytes[.. bytes.len() - padding_offset],
};
assert_eq!(Some(value1), iter.clone().last());
assert_eq!(
Some(value0),
iter.next()
);
assert_eq!(Some(value1), iter.clone().last());
assert_eq!(
Some(value1),
iter.next()
);
assert_eq!(None, iter.clone().last());
assert_eq!(
None,
iter.next()
);
}
}
}
}
proptest! {
#[test]
fn nth(
value0 in any::<f32>(),
value1 in any::<f32>()
) {
// empty
{
let mut iter = ArrayF32Iterator{
is_big_endian: false,
rest: &[],
};
assert!(iter.nth(0).is_none());
assert!(iter.nth(1).is_none());
}
for is_big_endian in [false, true] {
let bytes = two_values_bytes_for(is_big_endian, value0, value1);
for padding_offset in 0..=3 {
let iter = ArrayF32Iterator{
is_big_endian,
rest: &bytes[.. bytes.len() - padding_offset],
};
{
let mut iter = iter.clone();
assert_eq!(
Some(value0),
iter.nth(0)
);
assert_eq!(
Some(value1),
iter.nth(0)
);
assert_eq!(
None,
iter.nth(0)
);
}
{
let mut iter = iter.clone();
assert_eq!(
Some(value1),
iter.nth(1)
);
assert_eq!(
None,
iter.nth(0)
);
}
{
let mut iter = iter.clone();
assert_eq!(
None,
iter.nth(2)
);
}
}
}
}
}
#[cfg(feature = "serde")]
#[test]
fn serialization() {
// test dim_count 0
use alloc::string::ToString;
{
let dim_count: u16 = 0;
let is_big_endian = true;
let variable_info = None;
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
let mut elems: u8 = 1;
for i in 0..dim_count {
dimensions.extend_from_slice(&(i + 1).to_be_bytes());
elems *= (i + 1) as u8;
}
for x in 0u8..elems as u8 {
if x % 2 == 1 {
content.extend_from_slice(&(-0.5 * x as InternalTypes).to_be_bytes());
} else {
content.extend_from_slice(&(x as InternalTypes).to_be_bytes());
}
}
let arr_dim = ArrayDimensions {
is_big_endian,
dimensions: &dimensions,
};
let arr = TestType {
variable_info,
dimensions: arr_dim,
data: &content,
is_big_endian,
};
let convert_content = "{\"variable_info\":null,\"data\":[]}".to_string();
assert_eq!(convert_content, serde_json::to_string(&arr).unwrap());
}
// test dim_count 1
{
let dim_count: u16 = 1;
let is_big_endian = true;
let variable_info = None;
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
let mut elems: u8 = 1;
for i in 0..dim_count {
dimensions.extend_from_slice(&(i + 1).to_be_bytes());
elems *= (i + 1) as u8;
}
for x in 0u8..elems as u8 {
if x % 2 == 1 {
content.extend_from_slice(&(-0.5 * x as InternalTypes).to_be_bytes());
} else {
content.extend_from_slice(&(x as InternalTypes).to_be_bytes());
}
}
let arr_dim = ArrayDimensions {
is_big_endian,
dimensions: &dimensions,
};
let arr = TestType {
variable_info,
dimensions: arr_dim,
data: &content,
is_big_endian,
};
let convert_content = "{\"variable_info\":null,\"data\":[0.0]}".to_string();
assert_eq!(convert_content, serde_json::to_string(&arr).unwrap());
}
// test dim_count 2
{
let dim_count: u16 = 2;
let is_big_endian = true;
let variable_info = None;
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
let mut elems: u8 = 1;
for i in 0..dim_count {
dimensions.extend_from_slice(&(i + 1).to_be_bytes());
elems *= (i + 1) as u8;
}
for x in 0u8..elems as u8 {
if x % 2 == 1 {
content.extend_from_slice(&(-0.5 * x as InternalTypes).to_be_bytes());
} else {
content.extend_from_slice(&(x as InternalTypes).to_be_bytes());
}
}
let arr_dim = ArrayDimensions {
is_big_endian,
dimensions: &dimensions,
};
let arr = TestType {
variable_info,
dimensions: arr_dim,
data: &content,
is_big_endian,
};
let convert_content = "{\"variable_info\":null,\"data\":[[0.0,-0.5]]}".to_string();
assert_eq!(convert_content, serde_json::to_string(&arr).unwrap());
}
// test dim_count 3
{
let dim_count: u16 = 3;
let is_big_endian = true;
let variable_info = None;
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
let mut elems: u8 = 1;
for i in 0..dim_count {
dimensions.extend_from_slice(&(i + 1).to_be_bytes());
elems *= (i + 1) as u8;
}
for x in 0u8..elems as u8 {
if x % 2 == 1 {
content.extend_from_slice(&(-0.5 * x as InternalTypes).to_be_bytes());
} else {
content.extend_from_slice(&(x as InternalTypes).to_be_bytes());
}
}
let arr_dim = ArrayDimensions {
is_big_endian,
dimensions: &dimensions,
};
let arr = TestType {
variable_info,
dimensions: arr_dim,
data: &content,
is_big_endian,
};
let convert_content =
"{\"variable_info\":null,\"data\":[[[0.0,-0.5,2.0],[-1.5,4.0,-2.5]]]}".to_string();
assert_eq!(convert_content, serde_json::to_string(&arr).unwrap());
}
// test dim_count 4
{
let dim_count: u16 = 4;
let is_big_endian = true;
let variable_info = None;
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
let mut elems: u8 = 1;
for i in 0..dim_count {
dimensions.extend_from_slice(&(i + 1).to_be_bytes());
elems *= (i + 1) as u8;
}
for x in 0u8..elems as u8 {
if x % 2 == 1 {
content.extend_from_slice(&(-0.5 * x as InternalTypes).to_be_bytes());
} else {
content.extend_from_slice(&(x as InternalTypes).to_be_bytes());
}
}
let arr_dim = ArrayDimensions {
is_big_endian,
dimensions: &dimensions,
};
let arr = TestType {
variable_info,
dimensions: arr_dim,
data: &content,
is_big_endian,
};
let convert_content = "{\"variable_info\":null,\"data\":[[[[0.0,-0.5,2.0,-1.5],[4.0,-2.5,6.0,-3.5],[8.0,-4.5,10.0,-5.5]],[[12.0,-6.5,14.0,-7.5],[16.0,-8.5,18.0,-9.5],[20.0,-10.5,22.0,-11.5]]]]}".to_string();
assert_eq!(convert_content, serde_json::to_string(&arr).unwrap());
}
// test dim_count 5
{
let dim_count: u16 = 5;
let is_big_endian = true;
let variable_info = None;
let mut dimensions = Vec::with_capacity(dim_count as usize);
let mut content = Vec::with_capacity(dim_count as usize);
let mut elems: u8 = 1;
for i in 0..dim_count {
dimensions.extend_from_slice(&(i + 1).to_be_bytes());
elems *= (i + 1) as u8;
}
for x in 0u8..elems as u8 {
if x % 2 == 1 {
content.extend_from_slice(&(-0.5 * x as InternalTypes).to_be_bytes());
} else {
content.extend_from_slice(&(x as InternalTypes).to_be_bytes());
}
}
let arr_dim = ArrayDimensions {
is_big_endian,
dimensions: &dimensions,
};
let arr = TestType {
variable_info,
dimensions: arr_dim,
data: &content,
is_big_endian,
};
let convert_content = "{\"variable_info\":null,\"data\":[[[[[0.0,-0.5,2.0,-1.5,4.0],[-2.5,6.0,-3.5,8.0,-4.5],[10.0,-5.5,12.0,-6.5,14.0],[-7.5,16.0,-8.5,18.0,-9.5]],[[20.0,-10.5,22.0,-11.5,24.0],[-12.5,26.0,-13.5,28.0,-14.5],[30.0,-15.5,32.0,-16.5,34.0],[-17.5,36.0,-18.5,38.0,-19.5]],[[40.0,-20.5,42.0,-21.5,44.0],[-22.5,46.0,-23.5,48.0,-24.5],[50.0,-25.5,52.0,-26.5,54.0],[-27.5,56.0,-28.5,58.0,-29.5]]],[[[60.0,-30.5,62.0,-31.5,64.0],[-32.5,66.0,-33.5,68.0,-34.5],[70.0,-35.5,72.0,-36.5,74.0],[-37.5,76.0,-38.5,78.0,-39.5]],[[80.0,-40.5,82.0,-41.5,84.0],[-42.5,86.0,-43.5,88.0,-44.5],[90.0,-45.5,92.0,-46.5,94.0],[-47.5,96.0,-48.5,98.0,-49.5]],[[100.0,-50.5,102.0,-51.5,104.0],[-52.5,106.0,-53.5,108.0,-54.5],[110.0,-55.5,112.0,-56.5,114.0],[-57.5,116.0,-58.5,118.0,-59.5]]]]]}".to_string();
assert_eq!(convert_content, serde_json::to_string(&arr).unwrap());
}
}
}