use std::{fmt::Debug, io::Cursor};
use cdr::{
BigEndian, Bounded, CdrBe, CdrLe, Error, Infinite, LittleEndian, PlCdrBe, PlCdrLe, Result,
};
use serde_derive::{Deserialize, Serialize};
const ENCAPSULATION_HEADER_SIZE: u64 = 4;
fn check<'de, T>(element: T, maybe_size: Option<u64>)
where
T: serde::Serialize + serde::Deserialize<'de> + PartialEq + Debug,
{
check_serialized_size(&element, maybe_size);
check_round_trip(&element, maybe_size);
check_capacity_shortage(&element, maybe_size);
check_size_limit(&element, maybe_size);
}
fn check_serialized_size<'de, T>(element: &T, maybe_size: Option<u64>)
where
T: serde::Serialize + serde::Deserialize<'de> + PartialEq + Debug,
{
if let Some(serialized_size) = maybe_size {
{
let size = cdr::size::calc_serialized_data_size(&element);
assert_eq!(serialized_size, size);
}
{
let size = cdr::calc_serialized_size(&element);
assert_eq!(serialized_size + ENCAPSULATION_HEADER_SIZE, size);
}
}
}
fn check_round_trip<'de, T>(element: &T, maybe_size: Option<u64>)
where
T: serde::Serialize + serde::Deserialize<'de> + PartialEq + Debug,
{
let size = match maybe_size {
Some(v) => v as u64,
None => cdr::calc_serialized_size(&element),
};
{
let encoded = cdr::ser::serialize_data::<_, _, BigEndian>(element, Infinite).unwrap();
let decoded = cdr::de::deserialize_data::<T, BigEndian>(&encoded).unwrap();
assert_eq!(*element, decoded);
assert_eq!(size, encoded.len() as u64);
}
{
let encoded = cdr::ser::serialize_data::<_, _, LittleEndian>(element, Infinite).unwrap();
let decoded = cdr::de::deserialize_data::<T, LittleEndian>(&encoded).unwrap();
assert_eq!(*element, decoded);
assert_eq!(size, encoded.len() as u64);
}
{
let encoded = cdr::serialize::<_, _, CdrBe>(element, Infinite).unwrap();
let decoded = cdr::deserialize(&encoded).unwrap();
assert_eq!(*element, decoded);
assert_eq!(size + ENCAPSULATION_HEADER_SIZE, encoded.len() as u64);
}
{
let encoded = cdr::serialize::<_, _, CdrLe>(element, Infinite).unwrap();
let decoded = cdr::deserialize(&encoded).unwrap();
assert_eq!(*element, decoded);
assert_eq!(size + ENCAPSULATION_HEADER_SIZE, encoded.len() as u64);
}
{
let encoded = cdr::serialize::<_, _, PlCdrBe>(element, Infinite).unwrap();
let decoded = cdr::deserialize(&encoded).unwrap();
assert_eq!(*element, decoded);
assert_eq!(size + ENCAPSULATION_HEADER_SIZE, encoded.len() as u64);
}
{
let encoded = cdr::serialize::<_, _, PlCdrLe>(element, Infinite).unwrap();
let decoded = cdr::deserialize(&encoded).unwrap();
assert_eq!(*element, decoded);
assert_eq!(size + ENCAPSULATION_HEADER_SIZE, encoded.len() as u64);
}
}
fn check_capacity_shortage<'de, T>(element: &T, maybe_size: Option<u64>)
where
T: serde::Serialize + serde::Deserialize<'de> + PartialEq + Debug,
{
let mut buf = [0u8; 2000];
if let Some(bound) = calc_invalid_size(element, maybe_size) {
{
let mut buf = Cursor::new(&mut buf[0..bound as usize]);
assert!(cdr::ser::serialize_data_into::<_, _, _, BigEndian>(
&mut buf, &element, Infinite
)
.is_err());
}
{
let mut buf = Cursor::new(&mut buf[0..bound as usize]);
assert!(cdr::ser::serialize_data_into::<_, _, _, LittleEndian>(
&mut buf, &element, Infinite
)
.is_err());
}
{
let mut buf = Cursor::new(&mut buf[0..bound as usize]);
assert!(cdr::serialize_into::<_, _, _, CdrBe>(&mut buf, &element, Infinite).is_err());
}
{
let mut buf = Cursor::new(&mut buf[0..bound as usize]);
assert!(cdr::serialize_into::<_, _, _, CdrLe>(&mut buf, &element, Infinite).is_err());
}
{
let mut buf = Cursor::new(&mut buf[0..bound as usize]);
assert!(cdr::serialize_into::<_, _, _, PlCdrBe>(&mut buf, &element, Infinite).is_err());
}
{
let mut buf = Cursor::new(&mut buf[0..bound as usize]);
assert!(cdr::serialize_into::<_, _, _, PlCdrLe>(&mut buf, &element, Infinite).is_err());
}
} else {
{
let mut buf = Cursor::new(&mut buf[0..0]);
assert!(cdr::ser::serialize_data_into::<_, _, _, BigEndian>(
&mut buf, &element, Infinite
)
.is_ok());
}
{
let mut buf = Cursor::new(&mut buf[0..0]);
assert!(cdr::ser::serialize_data_into::<_, _, _, LittleEndian>(
&mut buf, &element, Infinite
)
.is_ok());
}
{
let mut buf = Cursor::new(&mut buf[0..ENCAPSULATION_HEADER_SIZE as usize]);
assert!(cdr::serialize_into::<_, _, _, CdrBe>(&mut buf, &element, Infinite).is_ok());
}
{
let mut buf = Cursor::new(&mut buf[0..ENCAPSULATION_HEADER_SIZE as usize]);
assert!(cdr::serialize_into::<_, _, _, CdrLe>(&mut buf, &element, Infinite).is_ok());
}
{
let mut buf = Cursor::new(&mut buf[0..ENCAPSULATION_HEADER_SIZE as usize]);
assert!(cdr::serialize_into::<_, _, _, PlCdrBe>(&mut buf, &element, Infinite).is_ok());
}
{
let mut buf = Cursor::new(&mut buf[0..ENCAPSULATION_HEADER_SIZE as usize]);
assert!(cdr::serialize_into::<_, _, _, PlCdrLe>(&mut buf, &element, Infinite).is_ok());
}
}
}
fn check_size_limit<'de, T>(element: &T, maybe_size: Option<u64>)
where
T: serde::Serialize + serde::Deserialize<'de> + PartialEq + Debug,
{
if let Some(bound) = calc_invalid_size(element, maybe_size) {
assert!(
cdr::ser::serialize_data::<_, _, BigEndian>(&element, Bounded(bound as u64)).is_err()
);
assert!(
cdr::ser::serialize_data::<_, _, LittleEndian>(&element, Bounded(bound as u64))
.is_err()
);
assert!(cdr::serialize::<_, _, CdrBe>(&element, Bounded(bound as u64)).is_err());
assert!(cdr::serialize::<_, _, CdrLe>(&element, Bounded(bound as u64)).is_err());
assert!(cdr::serialize::<_, _, PlCdrBe>(&element, Bounded(bound as u64)).is_err());
assert!(cdr::serialize::<_, _, PlCdrLe>(&element, Bounded(bound as u64)).is_err());
{
let encoded = cdr::ser::serialize_data::<_, _, BigEndian>(&element, Infinite).unwrap();
let mut encoded = encoded.as_slice();
assert!(cdr::de::deserialize_data_from::<_, T, _, BigEndian>(
&mut encoded,
Bounded(bound as u64)
)
.is_err());
}
{
let encoded =
cdr::ser::serialize_data::<_, _, LittleEndian>(&element, Infinite).unwrap();
let mut encoded = encoded.as_slice();
assert!(cdr::de::deserialize_data_from::<_, T, _, LittleEndian>(
&mut encoded,
Bounded(bound as u64)
)
.is_err());
}
{
let encoded = cdr::serialize::<_, _, CdrBe>(&element, Infinite).unwrap();
let mut encoded = encoded.as_slice();
assert!(cdr::deserialize_from::<_, T, _>(&mut encoded, Bounded(bound as u64)).is_err());
}
{
let encoded = cdr::serialize::<_, _, CdrLe>(&element, Infinite).unwrap();
let mut encoded = encoded.as_slice();
assert!(cdr::deserialize_from::<_, T, _>(&mut encoded, Bounded(bound as u64)).is_err());
}
{
let encoded = cdr::serialize::<_, _, PlCdrBe>(&element, Infinite).unwrap();
let mut encoded = encoded.as_slice();
assert!(cdr::deserialize_from::<_, T, _>(&mut encoded, Bounded(bound as u64)).is_err());
}
{
let encoded = cdr::serialize::<_, _, PlCdrLe>(&element, Infinite).unwrap();
let mut encoded = encoded.as_slice();
assert!(cdr::deserialize_from::<_, T, _>(&mut encoded, Bounded(bound as u64)).is_err());
}
} else {
{
let encoded =
cdr::ser::serialize_data::<_, _, BigEndian>(&element, Bounded(0)).unwrap();
let mut encoded = encoded.as_slice();
let decoded =
cdr::de::deserialize_data_from::<_, T, _, BigEndian>(&mut encoded, Bounded(0))
.unwrap();
assert_eq!(*element, decoded);
}
{
let encoded =
cdr::ser::serialize_data::<_, _, LittleEndian>(&element, Bounded(0)).unwrap();
let mut encoded = encoded.as_slice();
let decoded =
cdr::de::deserialize_data_from::<_, T, _, LittleEndian>(&mut encoded, Bounded(0))
.unwrap();
assert_eq!(*element, decoded);
}
{
let encoded =
cdr::serialize::<_, _, CdrBe>(&element, Bounded(ENCAPSULATION_HEADER_SIZE))
.unwrap();
let mut encoded = encoded.as_slice();
let decoded =
cdr::deserialize_from::<_, T, _>(&mut encoded, Bounded(ENCAPSULATION_HEADER_SIZE))
.unwrap();
assert_eq!(*element, decoded);
}
{
let encoded =
cdr::serialize::<_, _, CdrLe>(&element, Bounded(ENCAPSULATION_HEADER_SIZE))
.unwrap();
let mut encoded = encoded.as_slice();
let decoded =
cdr::deserialize_from::<_, T, _>(&mut encoded, Bounded(ENCAPSULATION_HEADER_SIZE))
.unwrap();
assert_eq!(*element, decoded);
}
{
let encoded =
cdr::serialize::<_, _, PlCdrBe>(&element, Bounded(ENCAPSULATION_HEADER_SIZE))
.unwrap();
let mut encoded = encoded.as_slice();
let decoded =
cdr::deserialize_from::<_, T, _>(&mut encoded, Bounded(ENCAPSULATION_HEADER_SIZE))
.unwrap();
assert_eq!(*element, decoded);
}
{
let encoded =
cdr::serialize::<_, _, PlCdrLe>(&element, Bounded(ENCAPSULATION_HEADER_SIZE))
.unwrap();
let mut encoded = encoded.as_slice();
let decoded =
cdr::deserialize_from::<_, T, _>(&mut encoded, Bounded(ENCAPSULATION_HEADER_SIZE))
.unwrap();
assert_eq!(*element, decoded);
}
}
}
fn calc_invalid_size<'de, T>(element: &T, maybe_size: Option<u64>) -> Option<u64>
where
T: serde::Serialize + serde::Deserialize<'de> + PartialEq + Debug,
{
match maybe_size {
Some(v) if v > 0 => Some(v - 1),
Some(_) => None,
None => {
let size = cdr::size::calc_serialized_data_size(&element);
if size > 0 {
Some(size - 1)
} else {
None
}
}
}
}
#[test]
fn test_octet() {
check(std::u8::MIN, Some(1));
check(std::u8::MAX, Some(1));
}
#[test]
fn test_char() {
check('a', Some(1));
check('Z', Some(1));
}
#[test]
fn test_unsigned_short() {
check(std::u16::MIN, Some(2));
check(std::u16::MAX, Some(2));
}
#[test]
fn test_short() {
check(std::i16::MIN, Some(2));
check(std::i16::MAX, Some(2));
}
#[test]
fn test_unsigned_long() {
check(std::u32::MIN, Some(4));
check(std::u32::MAX, Some(4));
}
#[test]
fn test_long() {
check(std::i32::MIN, Some(4));
check(std::i32::MAX, Some(4));
}
#[test]
fn test_unsigned_long_long() {
check(std::u64::MIN, Some(8));
check(std::u64::MAX, Some(8));
}
#[test]
fn test_long_long() {
check(std::i64::MIN, Some(8));
check(std::i64::MAX, Some(8));
}
#[test]
fn test_float() {
check(std::f32::MIN, Some(4));
check(std::f32::MAX, Some(4));
}
#[test]
fn test_double() {
check(std::f64::MIN, Some(8));
check(std::f64::MAX, Some(8));
}
#[test]
fn test_bool() {
check(false, Some(1));
check(true, Some(1));
}
#[test]
fn test_string() {
check("".to_string(), Some(5));
check("a".to_string(), Some(6));
}
#[test]
fn test_unsigned_short_alignment() {
check(('a', 1u16), Some(1 + 1 + 2));
check((1u8, 1u16), Some(1 + 1 + 2));
check((1i8, 1u16), Some(1 + 1 + 2));
check((1u16, 1u16), Some(2 + 2));
check((1i16, 1u16), Some(2 + 2));
check((1u32, 1u16), Some(4 + 2));
check((1i32, 1u16), Some(4 + 2));
check((1f32, 1u16), Some(4 + 2));
check((1f64, 1u16), Some(8 + 2));
check((true, 1u16), Some(1 + 1 + 2));
check(("a".to_string(), 1u16), Some(6 + 2));
}
#[test]
fn test_short_alignment() {
check(('a', 1i16), Some(1 + 1 + 2));
check((1u8, 1i16), Some(1 + 1 + 2));
check((1i8, 1i16), Some(1 + 1 + 2));
check((1u16, 1i16), Some(2 + 2));
check((1i16, 1i16), Some(2 + 2));
check((1u32, 1i16), Some(4 + 2));
check((1i32, 1i16), Some(4 + 2));
check((1f32, 1i16), Some(4 + 2));
check((1f64, 1i16), Some(8 + 2));
check((true, 1i16), Some(1 + 1 + 2));
check(("a".to_string(), 1i16), Some(6 + 2));
}
#[test]
fn test_unsigned_long_alignment() {
check(('a', 1u32), Some(1 + 3 + 4));
check((1u8, 1u32), Some(1 + 3 + 4));
check((1i8, 1u32), Some(1 + 3 + 4));
check((1u16, 1u32), Some(2 + 2 + 4));
check((1i16, 1u32), Some(2 + 2 + 4));
check((1u32, 1u32), Some(4 + 4));
check((1i32, 1u32), Some(4 + 4));
check((1f32, 1u32), Some(4 + 4));
check((1f64, 1u32), Some(8 + 4));
check((true, 1u32), Some(1 + 3 + 4));
check(("a".to_string(), 1u32), Some(6 + 2 + 4));
}
#[test]
fn test_long_alignment() {
check(('a', 1i32), Some(1 + 3 + 4));
check((1u8, 1i32), Some(1 + 3 + 4));
check((1i8, 1i32), Some(1 + 3 + 4));
check((1u16, 1i32), Some(2 + 2 + 4));
check((1i16, 1i32), Some(2 + 2 + 4));
check((1u32, 1i32), Some(4 + 4));
check((1i32, 1i32), Some(4 + 4));
check((1f32, 1i32), Some(4 + 4));
check((1f64, 1i32), Some(8 + 4));
check((true, 1i32), Some(1 + 3 + 4));
check(("a".to_string(), 1i32), Some(6 + 2 + 4));
}
#[test]
fn test_unsigned_long_long_alignment() {
check(('a', 1u64), Some(1 + 7 + 8));
check((1u8, 1u64), Some(1 + 7 + 8));
check((1i8, 1u64), Some(1 + 7 + 8));
check((1u16, 1u64), Some(2 + 6 + 8));
check((1i16, 1u64), Some(2 + 6 + 8));
check((1u32, 1u64), Some(4 + 4 + 8));
check((1i32, 1u64), Some(4 + 4 + 8));
check((1f32, 1u64), Some(4 + 4 + 8));
check((1f64, 1u64), Some(8 + 8));
check((true, 1u64), Some(1 + 7 + 8));
check(("a".to_string(), 1u64), Some(6 + 2 + 8));
}
#[test]
fn test_long_long_alignment() {
check(('a', 1i64), Some(1 + 7 + 8));
check((1u8, 1i64), Some(1 + 7 + 8));
check((1i8, 1i64), Some(1 + 7 + 8));
check((1u16, 1i64), Some(2 + 6 + 8));
check((1i16, 1i64), Some(2 + 6 + 8));
check((1u32, 1i64), Some(4 + 4 + 8));
check((1i32, 1i64), Some(4 + 4 + 8));
check((1f32, 1i64), Some(4 + 4 + 8));
check((1f64, 1i64), Some(8 + 8));
check((true, 1i64), Some(1 + 7 + 8));
check(("a".to_string(), 1i64), Some(6 + 2 + 8));
}
#[test]
fn test_float_alignment() {
check(('a', 1f32), Some(1 + 3 + 4));
check((1u8, 1f32), Some(1 + 3 + 4));
check((1i8, 1f32), Some(1 + 3 + 4));
check((1u16, 1f32), Some(2 + 2 + 4));
check((1i16, 1f32), Some(2 + 2 + 4));
check((1u32, 1f32), Some(4 + 4));
check((1f32, 1f32), Some(4 + 4));
check((1f32, 1f32), Some(4 + 4));
check((1f64, 1f32), Some(8 + 4));
check((true, 1f32), Some(1 + 3 + 4));
check(("a".to_string(), 1f32), Some(6 + 2 + 4));
}
#[test]
fn test_double_alignment() {
check(('a', 1f64), Some(1 + 7 + 8));
check((1u8, 1f64), Some(1 + 7 + 8));
check((1i8, 1f64), Some(1 + 7 + 8));
check((1u16, 1f64), Some(2 + 6 + 8));
check((1i16, 1f64), Some(2 + 6 + 8));
check((1u32, 1f64), Some(4 + 4 + 8));
check((1i32, 1f64), Some(4 + 4 + 8));
check((1f32, 1f64), Some(4 + 4 + 8));
check((1f64, 1f64), Some(8 + 8));
check((true, 1f64), Some(1 + 7 + 8));
check(("a".to_string(), 1f64), Some(6 + 2 + 8));
}
#[test]
fn test_seq_octet() {
check(Vec::<u8>::new(), Some(4));
check(vec![0u8, 1, 2], Some(4 + 1 * 3));
}
#[test]
fn test_seq_char() {
check(Vec::<char>::new(), Some(4));
check(vec!['a', 'b', 'c'], Some(4 + 1 * 3));
}
#[test]
fn test_seq_unsigned_short() {
check(Vec::<u16>::new(), Some(4));
check(vec![0u16, 1, 2], Some(4 + 2 * 3));
}
#[test]
fn test_seq_short() {
check(Vec::<i16>::new(), Some(4));
check(vec![0i16, 1, 2], Some(4 + 2 * 3));
}
#[test]
fn test_seq_unsigned_long() {
check(Vec::<u32>::new(), Some(4));
check(vec![0u32, 1, 2], Some(4 + 4 * 3));
}
#[test]
fn test_seq_long() {
check(Vec::<i32>::new(), Some(4));
check(vec![0i32, 1, 2], Some(4 + 4 * 3));
}
#[test]
fn test_seq_unsigned_long_long() {
check(Vec::<u64>::new(), Some(4));
check(vec![0u64, 1, 2], Some(4 + 4 + 8 * 3));
}
#[test]
fn test_seq_long_long() {
check(Vec::<i64>::new(), Some(4));
check(vec![0i64, 1, 2], Some(4 + 4 + 8 * 3));
}
#[test]
fn test_seq_float() {
check(Vec::<f32>::new(), Some(4));
check(vec![0f32, 1., 2.], Some(4 + 4 * 3));
}
#[test]
fn test_seq_double() {
check(Vec::<f64>::new(), Some(4));
check(vec![0f64, 1., 2.], Some(4 + 4 + 8 * 3));
}
#[test]
fn test_seq_bool() {
check(Vec::<bool>::new(), Some(4));
check(vec![false, true, false], Some(4 + 1 * 3));
}
#[test]
fn test_seq_string() {
check(Vec::<String>::new(), Some(4));
check(
vec!["".to_string(), "a".to_string(), "b".to_string()],
Some(4 + 4 + 1 + 3 + 4 + 2 + 2 + 4 + 2),
);
}
#[test]
fn test_seq_in_seq() {
check(vec![Vec::<usize>::new()], Some(8));
check(vec![vec![1i64, 3, 5], vec![-1, -3, -5]], Some(64));
}
#[test]
#[allow(const_err)]
fn test_array_octet() {
check([] as [u8; 0], Some(0));
check([0u8, 1, 2], Some(3));
}
#[test]
#[allow(const_err)]
fn test_array_char() {
check([] as [char; 0], Some(0));
check(['a', 'b', 'c'], Some(3));
}
#[test]
#[allow(const_err)]
fn test_array_unsigned_short() {
check([] as [u16; 0], Some(0));
check([0u16, 1, 2], Some(6));
}
#[test]
#[allow(const_err)]
fn test_array_short() {
check([] as [i16; 0], Some(0));
check([0i16, 1, 2], Some(6));
}
#[test]
#[allow(const_err)]
fn test_array_unsigned_long() {
check([] as [u32; 0], Some(0));
check([0u32, 1, 2], Some(12));
}
#[test]
#[allow(const_err)]
fn test_array_long() {
check([] as [i32; 0], Some(0));
check([0i32, 1, 2], Some(12));
}
#[test]
#[allow(const_err)]
fn test_array_unsigned_long_long() {
check([] as [u64; 0], Some(0));
check([0u64, 1, 2], Some(24));
}
#[test]
#[allow(const_err)]
fn test_array_long_long() {
check([] as [i64; 0], Some(0));
check([0i64, 1, 2], Some(24));
}
#[test]
#[allow(const_err)]
fn test_array_float() {
check([] as [f32; 0], Some(0));
check([0f32, 1., 2.], Some(12));
}
#[test]
#[allow(const_err)]
fn test_array_double() {
check([] as [f64; 0], Some(0));
check([0f64, 1., 2.], Some(24));
}
#[test]
#[allow(const_err)]
fn test_array_bool() {
check([] as [bool; 0], Some(0));
check([false, true, false], Some(3));
}
#[test]
#[allow(const_err)]
fn test_array_string() {
check([] as [String; 0], Some(0));
check(
["".to_string(), "a".to_string(), "b".to_string()],
Some(5 + 3 + 6 + 2 + 6),
);
}
#[test]
#[allow(const_err)]
fn test_array_in_array() {
check([[]] as [[usize; 0]; 1], Some(0));
check([[3.14f64, 2.71, 1.41], [1.73, 2.23, 2.44]], Some(48));
}
#[test]
fn test_tuple() {
check((1u32,), Some(4));
check((1u32, 2i32), Some(4 + 4));
check((1u16, 2i16, 3.14f32, "hi".to_string()), Some(2 + 2 + 4 + 7));
}
#[test]
fn test_tuple_containing_padding() {
check((true, 1u64, 'z', 2.71f32), Some(24));
}
#[test]
fn test_struct() {
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct S {
c: char,
n: i32,
b: bool,
m: u64,
s: String,
}
check(
S {
c: 'x',
n: -7,
b: true,
m: 17,
s: "hello".to_string(),
},
Some(34),
);
}
#[test]
fn test_struct_in_struct() {
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Outer {
i: Inner1,
ii: Inner2,
iii: Inner3,
}
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Inner1 {
a: i32,
b: u64,
}
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Inner2 {
a: bool,
b: f64,
}
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Inner3 {
a: char,
b: f32,
}
check(
Outer {
i: Inner1 { a: -3, b: 5 },
ii: Inner2 { a: false, b: 1.414 },
iii: Inner3 { a: 'a', b: 1.732 },
},
Some(40),
);
}
#[test]
fn test_enum() {
#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum E {
One = 0,
Two,
Three,
}
check(vec![E::One, E::Two, E::Three], Some(4 + 4 * 3));
check(
vec![E::One as u32, E::Two as u32, E::Three as u32],
Some(4 + 4 * 3),
);
}
#[test]
fn test_union() {
#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum U {
A(u32),
B(i16, u32, u64),
C {
c: char,
n: u32,
b: bool,
v: Vec<u8>,
},
D,
}
check(U::A(3), Some(4 + 4));
check(U::B(1, 2, 3), Some(4 + 2 + 2 + 4 + 4 + 8));
check(
U::C {
c: 'a',
n: 5,
b: true,
v: vec![1, 1, 2, 3, 5],
},
Some(4 + 1 + 3 + 4 + 1 + 3 + 4 + 5),
);
check(U::D, Some(4));
}
#[test]
fn test_unsupported() {
use std::collections::{BTreeMap, HashMap};
fn check_error_kind<T: Debug>(res: Result<T>) {
match res {
Err(e) => match e {
Error::TypeNotSupported => (),
e => panic!("unexpected error kind: {}", e),
},
_ => panic!("should be error"),
}
}
check_error_kind(cdr::ser::serialize_data::<_, _, BigEndian>(
&Some(1usize),
Infinite,
));
check_error_kind(cdr::ser::serialize_data::<_, _, BigEndian>(
&None::<usize>,
Infinite,
));
check_error_kind(cdr::ser::serialize_data::<_, _, BigEndian>(
&HashMap::<usize, usize>::new(),
Infinite,
));
check_error_kind(cdr::ser::serialize_data::<_, _, BigEndian>(
&BTreeMap::<usize, usize>::new(),
Infinite,
));
check_error_kind(cdr::de::deserialize_data::<Option<usize>, BigEndian>(
&Vec::new().as_slice(),
));
check_error_kind(
cdr::de::deserialize_data::<HashMap<usize, usize>, BigEndian>(&Vec::new().as_slice()),
);
check_error_kind(
cdr::de::deserialize_data::<BTreeMap<usize, usize>, BigEndian>(&Vec::new().as_slice()),
);
}