From 8d14c56c12256d3872c22cd680236554ebdbaba1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sosth=C3=A8ne=20Gu=C3=A9don?= Date: Mon, 27 Nov 2023 11:07:58 +0100 Subject: [PATCH] Fix #2 This patch adds tests based on `serde_test`. These tests helped showcase the bug that leads to https://github.com/trussed-dev/serde-indexed/issues/2 --- Cargo.toml | 1 + src/lib.rs | 3 +- tests/basics.rs | 174 +++++++++++++++++++++++++++++++++++++++--------- 3 files changed, 143 insertions(+), 35 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index db52308..b2d4684 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -25,3 +25,4 @@ serde = { version = "1" } serde-byte-array = "0.1.2" serde_bytes = { version = "0.11.12", default-features = false } serde_cbor = { version = "0.11.0" } +serde_test = "1.0.176" diff --git a/src/lib.rs b/src/lib.rs index 1909fe4..d0575b9 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -157,9 +157,8 @@ fn unwrap_expected_fields(fields: &[parse::Field]) -> Vec( @@ -134,6 +135,96 @@ mod some_keys { (serialized, an_example) } + #[test] + fn tokens() { + assert_tokens( + &an_example().1, + &[ + Token::Map { len: Some(4) }, + Token::U64(1), + Token::I32(-7), + Token::U64(2), + Token::Tuple { len: 7 }, + Token::U8(37), + Token::U8(37), + Token::U8(37), + Token::U8(37), + Token::U8(37), + Token::U8(37), + Token::U8(37), + Token::TupleEnd, + Token::U64(3), + Token::Str("so serde"), + Token::U64(5), + Token::Seq { len: Some(1) }, + Token::U8(42), + Token::SeqEnd, + Token::MapEnd, + ], + ); + assert_tokens( + &another_example().1, + &[ + Token::Map { len: Some(5) }, + Token::U64(1), + Token::I32(-7), + Token::U64(2), + Token::Tuple { len: 7 }, + Token::U8(37), + Token::U8(37), + Token::U8(37), + Token::U8(37), + Token::U8(37), + Token::U8(37), + Token::U8(37), + Token::TupleEnd, + Token::U64(3), + Token::Str("so serde"), + Token::U64(4), + Token::Some, + Token::U8(0xFF), + Token::U64(5), + Token::Seq { len: Some(1) }, + Token::U8(42), + Token::SeqEnd, + Token::MapEnd, + ], + ); + assert_tokens( + &a_ref_example().1, + &[ + Token::Map { len: Some(4) }, + Token::U64(1), + Token::I32(-7), + Token::U64(2), + Token::BorrowedBytes(&[37; 7]), + Token::U64(3), + Token::BorrowedStr("so serde"), + Token::U64(5), + Token::BorrowedBytes(&[42]), + Token::MapEnd, + ], + ); + assert_tokens( + &another_ref_example().1, + &[ + Token::Map { len: Some(5) }, + Token::U64(1), + Token::I32(-7), + Token::U64(2), + Token::BorrowedBytes(&[37; 7]), + Token::U64(3), + Token::BorrowedStr("so serde"), + Token::U64(4), + Token::Some, + Token::U8(0xFF), + Token::U64(5), + Token::BorrowedBytes(&[42]), + Token::MapEnd, + ], + ) + } + #[test] fn serialize() { let (serialized_value, example) = an_example(); @@ -242,6 +333,23 @@ mod cow { const SERIALIZED_LIFETIME_EXAMPLE: &[u8] = b"\xa1\x01\x83\x01\x02\x03"; + #[test] + fn tokens() { + assert_tokens( + &lifetime_example(), + &[ + Token::Map { len: Some(1) }, + Token::U64(1), + Token::Seq { len: Some(3) }, + Token::U8(1), + Token::U8(2), + Token::U8(3), + Token::SeqEnd, + Token::MapEnd, + ], + ); + } + #[test] fn serialize() { let data = lifetime_example(); @@ -272,8 +380,6 @@ mod generics { use serde_byte_array::ByteArray; use serde_bytes::Bytes; - const SERIALIZED_GENERIC_EXAMPLE: &'static [u8] = b"\xa1\x01\x43\x01\x02\x03"; - #[derive(PartialEq, Debug, SerializeIndexed, DeserializeIndexed)] #[serde_indexed(offset = 1)] struct WithGeneric { @@ -305,35 +411,37 @@ mod generics { } #[test] - fn serialize() { - let data = generics_example(); - let mut buf = [0u8; 64]; - let size = cbor_serialize(&data, &mut buf).unwrap(); - - assert_eq!(&buf[..size], SERIALIZED_GENERIC_EXAMPLE); - - let data = const_generics_example(); - let mut buf = [0u8; 64]; - let size = cbor_serialize(&data, &mut buf).unwrap(); - - assert_eq!(&buf[..size], SERIALIZED_GENERIC_EXAMPLE); - } - - #[test] - fn deserialize() { - let example = generics_example(); - - let deserialized: WithGeneric<&'_ Bytes> = - cbor_deserialize_with_scratch(SERIALIZED_GENERIC_EXAMPLE, &mut []).unwrap(); - - assert_eq!(deserialized, example); - - let example = const_generics_example(); - - let deserialized: WithConstGeneric<3> = - cbor_deserialize_with_scratch(SERIALIZED_GENERIC_EXAMPLE, &mut []).unwrap(); - - assert_eq!(deserialized, example); + fn tokens() { + let tokens = &[ + Token::Map { len: Some(1) }, + Token::U64(1), + Token::BorrowedBytes(&[1, 2, 3]), + Token::MapEnd, + ]; + assert_tokens(&generics_example(), tokens); + assert_tokens(&const_generics_example(), tokens); + assert_tokens( + &all_generics_example(), + &[ + Token::Map { len: Some(4) }, + Token::U64(1), + Token::Seq { len: Some(2) }, + Token::Str("abc"), + Token::Str("acdef"), + Token::SeqEnd, + Token::U64(2), + Token::Seq { len: Some(3) }, + Token::U8(1), + Token::U8(2), + Token::U8(3), + Token::SeqEnd, + Token::U64(3), + Token::BorrowedBytes(b"bytes"), + Token::U64(4), + Token::BorrowedBytes(b"123"), + Token::MapEnd, + ], + ); } #[derive(PartialEq, Debug, SerializeIndexed, DeserializeIndexed)] @@ -347,7 +455,7 @@ mod generics { fn all_generics_example<'a, 'b>() -> WithAllGenerics<'a, 'b, String<5>, u8, 10, 3> { let data1 = heapless::Vec::from_slice(&["abc".into(), "acdef".into()]).unwrap(); - let data2 = heapless::Vec::from_slice(&[1, 2]).unwrap(); + let data2 = heapless::Vec::from_slice(&[1, 2, 3]).unwrap(); const BYTES: ByteArray<3> = ByteArray::new(*b"123"); WithAllGenerics { @@ -360,7 +468,7 @@ mod generics { #[test] fn all_generics() { - const SERIALIZED_ALL_GENERIC_EXAMPLE: &'static [u8] = b"\xa4\x01\x82\x63\x61\x62\x63\x65\x61\x63\x64\x65\x66\x02\x82\x01\x02\x03\x45\x62\x79\x74\x65\x73\x04\x43\x31\x32\x33"; + const SERIALIZED_ALL_GENERIC_EXAMPLE: &'static [u8] = b"\xa4\x01\x82\x63\x61\x62\x63\x65\x61\x63\x64\x65\x66\x02\x83\x01\x02\x03\x03\x45\x62\x79\x74\x65\x73\x04\x43\x31\x32\x33"; let data = all_generics_example(); let mut buf = [0u8; 64]; let size = cbor_serialize(&data, &mut buf).unwrap();