From 3fb0832820561ac87828afa4dde99f1e4d61ffef Mon Sep 17 00:00:00 2001 From: Anders429 Date: Mon, 16 Jan 2023 21:51:55 -0800 Subject: [PATCH] Switch from serde_test to serde_assert. --- Cargo.toml | 2 +- src/archetype/identifier/impl_serde.rs | 59 ++- src/archetype/impl_serde.rs | 411 +++++++++++------ src/archetypes/impl_serde.rs | 167 +++---- src/entity/allocator/impl_serde.rs | 604 +++++++++++-------------- src/entity/identifier/impl_serde.rs | 175 ++++--- src/hlist.rs | 50 +- src/world/impl_serde.rs | 117 +++-- 8 files changed, 885 insertions(+), 700 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 85eb2b77..efc4bfc1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -28,8 +28,8 @@ serde = {version = "1.0.148", default-features = false, features = ["alloc"], op [dev-dependencies] claims = "0.7.1" rustversion = "1.0.9" +serde_assert = "0.2.0" serde_derive = "1.0.148" -serde_test = "1.0.148" trybuild = "1.0.72" [features] diff --git a/src/archetype/identifier/impl_serde.rs b/src/archetype/identifier/impl_serde.rs index c91a480c..406cb11d 100644 --- a/src/archetype/identifier/impl_serde.rs +++ b/src/archetype/identifier/impl_serde.rs @@ -121,10 +121,20 @@ mod tests { use super::*; use crate::Registry; use alloc::vec; - use serde_test::{ - assert_de_tokens_error, - assert_tokens, + use claims::{ + assert_err_eq, + assert_ok_eq, + }; + use serde::de::{ + Error as _, + Unexpected, + }; + use serde_assert::{ + de::Error, + Deserializer, + Serializer, Token, + Tokens, }; macro_rules! create_components { @@ -146,16 +156,17 @@ mod tests { fn serialize_deserialize() { let identifier = unsafe { Identifier::::new(vec![1, 2, 3, 0]) }; - assert_tokens( - &identifier, - &[ + let serializer = Serializer::builder().build(); + assert_ok_eq!( + identifier.serialize(&serializer), + Tokens(vec![ Token::Tuple { len: 4 }, Token::U8(1), Token::U8(2), Token::U8(3), Token::U8(0), - Token::TupleEnd, - ], + Token::TupleEnd + ]) ); } @@ -163,35 +174,43 @@ mod tests { fn serialize_deserialize_empty() { let identifier = unsafe { Identifier::::new(vec![]) }; - assert_tokens(&identifier, &[Token::Tuple { len: 0 }, Token::TupleEnd]); + let serializer = Serializer::builder().build(); + assert_ok_eq!( + identifier.serialize(&serializer), + Tokens(vec![Token::Tuple { len: 0 }, Token::TupleEnd]) + ); } #[test] fn deserialize_from_too_many_bits() { - assert_de_tokens_error::>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Tuple { len: 4 }, Token::U8(1), Token::U8(2), Token::U8(3), Token::U8(255), Token::TupleEnd, - ], - "invalid value: byte array [1, 2, 3, 255], expected 26 bits corresponding to components, with prefixed 0s padded on the last byte to round up to 4 bytes" - ); + ])) + .self_describing(false) + .build(); + + assert_err_eq!(Identifier::::deserialize(&mut deserializer), Error::invalid_value(Unexpected::Other("byte array [1, 2, 3, 255]"), &"26 bits corresponding to components, with prefixed 0s padded on the last byte to round up to 4 bytes")); } #[test] fn deserialize_from_too_few_bytes() { - assert_de_tokens_error::>( - &[ - Token::Tuple { len: 3 }, + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ + Token::Tuple { len: 4 }, Token::U8(1), Token::U8(2), Token::U8(3), Token::TupleEnd, - ], - "invalid length 3, expected 26 bits corresponding to components, with prefixed 0s padded on the last byte to round up to 4 bytes" - ); + ])) + .self_describing(false) + .build(); + + assert_err_eq!(Identifier::::deserialize(&mut deserializer), Error::invalid_length(3, &"26 bits corresponding to components, with prefixed 0s padded on the last byte to round up to 4 bytes")); } } diff --git a/src/archetype/impl_serde.rs b/src/archetype/impl_serde.rs index 248b1c39..ffc3f4cd 100644 --- a/src/archetype/impl_serde.rs +++ b/src/archetype/impl_serde.rs @@ -842,19 +842,23 @@ mod tests { format, vec, }; + use claims::{ + assert_err_eq, + assert_ok_eq, + }; use core::any::type_name; + use serde::de::Error as _; + use serde_assert::{ + de::Error, + Deserializer, + Serializer, + Token, + Tokens, + }; use serde_derive::{ Deserialize, Serialize, }; - use serde_test::{ - assert_de_tokens_error, - assert_tokens, - Compact, - Configure, - Readable, - Token, - }; #[derive(Debug, Deserialize, Eq, PartialEq, Serialize)] struct A(u32); @@ -874,9 +878,11 @@ mod tests { archetype.push(entity!(A(3), B('c')), &mut entity_allocator); } - assert_tokens( - &archetype.compact(), - &[ + let serializer = Serializer::builder().is_human_readable(false).build(); + + let tokens = assert_ok_eq!( + archetype.serialize(&serializer), + Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 3 }, // Identifier @@ -893,27 +899,27 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(1), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(2), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::TupleEnd, @@ -937,48 +943,65 @@ mod tests { Token::TupleEnd, Token::TupleEnd, Token::TupleEnd, - ], + ]) + ); + let mut deserializer = Deserializer::builder() + .tokens(tokens) + .is_human_readable(false) + .self_describing(false) + .build(); + assert_ok_eq!( + Archetype::::deserialize(&mut deserializer), + archetype ); } #[test] fn deserialize_by_column_missing_entity_identifiers() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 3 }, // Identifier Token::Tuple { len: 1 }, - Token::U8(3), + Token::U8(0), Token::TupleEnd, // Length Token::U64(3), // Columns - Token::Tuple { len: 3 }, + Token::Tuple { len: 1 }, // Entity identifiers Token::Tuple { len: 1 }, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::TupleEnd, - ], - &format!( - "invalid length 1, expected column of 3 `{}`s", - type_name::() - ), + Token::TupleEnd, + Token::TupleEnd, + ])) + .is_human_readable(false) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length( + 1, + &format!("column of 3 `{}`s", type_name::()).as_str() + ) ); } #[test] fn deserialize_by_column_missing_components() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 3 }, // Identifier @@ -995,27 +1018,27 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(1), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(2), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::TupleEnd, @@ -1026,18 +1049,32 @@ mod tests { Token::NewtypeStruct { name: "A" }, Token::U32(2), Token::TupleEnd, - ], - &format!( - "invalid length 2, expected column of 3 `{}`s", - type_name::() - ), + // B column + Token::Tuple { len: 3 }, + Token::NewtypeStruct { name: "B" }, + Token::Char('a'), + Token::NewtypeStruct { name: "B" }, + Token::Char('b'), + Token::NewtypeStruct { name: "B" }, + Token::Char('c'), + Token::TupleEnd, + Token::TupleEnd, + Token::TupleEnd, + ])) + .is_human_readable(false) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length(2, &format!("column of 3 `{}`s", type_name::()).as_str()) ); } #[test] fn deserialize_by_column_missing_entity_identifier_column() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 3 }, // Identifier @@ -1049,19 +1086,30 @@ mod tests { // Columns Token::Tuple { len: 0 }, Token::TupleEnd, - ], - &format!( - "invalid length 0, expected columns for each of (entity::Identifier, {}, {})", - type_name::(), - type_name::() - ), + Token::TupleEnd, + ])) + .is_human_readable(false) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length( + 0, + &format!( + "columns for each of (entity::Identifier, {}, {})", + type_name::(), + type_name::() + ) + .as_str() + ) ); } #[test] fn deserialize_by_column_missing_component_column() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 3 }, // Identifier @@ -1078,27 +1126,27 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(1), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(2), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::TupleEnd, @@ -1112,31 +1160,48 @@ mod tests { Token::U32(3), Token::TupleEnd, Token::TupleEnd, - ], - &format!( - "invalid length 2, expected columns for each of (entity::Identifier, {}, {})", - type_name::(), - type_name::() - ), + Token::TupleEnd, + ])) + .is_human_readable(false) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length( + 2, + &format!( + "columns for each of (entity::Identifier, {}, {})", + type_name::(), + type_name::() + ) + .as_str() + ) ); } #[test] fn deserialize_by_column_missing_identifier() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 0 }, Token::TupleEnd, - ], - "invalid length 0, expected column-serialized Archetype", + ])) + .is_human_readable(false) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length(0, &"column-serialized Archetype") ); } #[test] fn deserialize_by_column_missing_length() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 1 }, // Identifier @@ -1144,15 +1209,21 @@ mod tests { Token::U8(3), Token::TupleEnd, Token::TupleEnd, - ], - "invalid length 1, expected column-serialized Archetype", + ])) + .is_human_readable(false) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length(1, &"column-serialized Archetype") ); } #[test] fn deserialize_by_column_missing_columns() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 2 }, // Identifier @@ -1162,8 +1233,14 @@ mod tests { // Length Token::U64(3), Token::TupleEnd, - ], - "invalid length 2, expected column-serialized Archetype", + ])) + .is_human_readable(false) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length(2, &"column-serialized Archetype") ); } @@ -1177,9 +1254,10 @@ mod tests { archetype.push(entity!(A(3), B('c')), &mut entity_allocator); } - assert_tokens( - &archetype.readable(), - &[ + let serializer = Serializer::builder().build(); + let tokens = assert_ok_eq!( + archetype.serialize(&serializer), + Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 3 }, // Identifier @@ -1196,9 +1274,9 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::NewtypeStruct { name: "A" }, @@ -1212,9 +1290,9 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(1), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::NewtypeStruct { name: "A" }, @@ -1228,9 +1306,9 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(2), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::NewtypeStruct { name: "A" }, @@ -1240,14 +1318,22 @@ mod tests { Token::TupleEnd, Token::TupleEnd, Token::TupleEnd, - ], + ]) + ); + let mut deserializer = Deserializer::builder() + .tokens(tokens) + .self_describing(false) + .build(); + assert_ok_eq!( + Archetype::::deserialize(&mut deserializer), + archetype ); } #[test] fn deserialize_by_row_no_entity_identifier() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 3 }, // Identifier @@ -1261,19 +1347,30 @@ mod tests { // Row 1 Token::Tuple { len: 0 }, Token::TupleEnd, - ], - &format!( - "invalid length 0, expected (entity::Identifier, {}, {})", - type_name::(), - type_name::() - ), + Token::TupleEnd, + Token::TupleEnd, + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length( + 0, + &format!( + "(entity::Identifier, {}, {})", + type_name::(), + type_name::() + ) + .as_str() + ) ); } #[test] fn deserialize_by_row_missing_component() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 3 }, // Identifier @@ -1290,27 +1387,38 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::NewtypeStruct { name: "A" }, Token::U32(1), Token::TupleEnd, - ], - &format!( - "invalid length 2, expected (entity::Identifier, {}, {})", - type_name::(), - type_name::() - ), + Token::TupleEnd, + Token::TupleEnd, + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length( + 2, + &format!( + "(entity::Identifier, {}, {})", + type_name::(), + type_name::() + ) + .as_str() + ) ); } #[test] fn deserialize_by_row_no_rows() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 3 }, // Identifier @@ -1322,19 +1430,29 @@ mod tests { // Rows Token::Tuple { len: 0 }, Token::TupleEnd, - ], - &format!( - "invalid length 0, expected 1 rows of (entity::Identifier, {}, {})", - type_name::(), - type_name::() - ), + Token::TupleEnd, + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length( + 0, + &format!( + "1 rows of (entity::Identifier, {}, {})", + type_name::(), + type_name::() + ) + .as_str() + ) ); } #[test] fn deserialize_by_row_missing_rows() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 3 }, // Identifier @@ -1351,9 +1469,9 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::NewtypeStruct { name: "A" }, @@ -1362,31 +1480,46 @@ mod tests { Token::Char('a'), Token::TupleEnd, Token::TupleEnd, - ], - &format!( - "invalid length 1, expected 3 rows of (entity::Identifier, {}, {})", - type_name::(), - type_name::() - ), + Token::TupleEnd, + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length( + 1, + &format!( + "3 rows of (entity::Identifier, {}, {})", + type_name::(), + type_name::() + ) + .as_str() + ) ); } #[test] fn deserialize_by_row_missing_identifier() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 0 }, Token::TupleEnd, - ], - "invalid length 0, expected row-serialized Archetype", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length(0, &"row-serialized Archetype") ); } #[test] fn deserialize_by_row_missing_length() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 1 }, // Identifier @@ -1394,15 +1527,20 @@ mod tests { Token::U8(3), Token::TupleEnd, Token::TupleEnd, - ], - "invalid length 1, expected row-serialized Archetype", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length(1, &"row-serialized Archetype") ); } #[test] fn deserialize_by_row_missing_rows_completely() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::NewtypeStruct { name: "Archetype" }, Token::Tuple { len: 2 }, // Identifier @@ -1412,8 +1550,13 @@ mod tests { // Length Token::U64(3), Token::TupleEnd, - ], - "invalid length 2, expected row-serialized Archetype", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Archetype::::deserialize(&mut deserializer), + Error::invalid_length(2, &"row-serialized Archetype") ); } } diff --git a/src/archetypes/impl_serde.rs b/src/archetypes/impl_serde.rs index 3723b0c0..d54ebced 100644 --- a/src/archetypes/impl_serde.rs +++ b/src/archetypes/impl_serde.rs @@ -106,7 +106,11 @@ where #[cfg(test)] mod tests { - use super::*; + use super::{ + Archetype, + Archetypes, + DeserializeArchetypes, + }; use crate::{ archetype::Identifier, entity, @@ -116,86 +120,33 @@ mod tests { format, vec, }; - use claims::assert_ok; + use claims::{ + assert_err_eq, + assert_ok, + assert_ok_eq, + }; use core::{ any::type_name, - fmt, fmt::Debug, }; use serde::{ - Deserialize, - Deserializer, + de::{ + DeserializeSeed, + Error as _, + }, Serialize, + }; + use serde_assert::{ + de::Error, + Deserializer, Serializer, + Token, + Tokens, }; use serde_derive::{ Deserialize, Serialize, }; - use serde_test::{ - assert_de_tokens_error, - assert_tokens, - Compact, - Configure, - Token, - }; - - struct SeededArchetypes - where - R: crate::registry::Registry, - { - archetypes: Archetypes, - len: usize, - } - - impl PartialEq for SeededArchetypes - where - R: registry::PartialEq, - { - fn eq(&self, other: &Self) -> bool { - self.archetypes == other.archetypes && self.len == other.len - } - } - - impl Eq for SeededArchetypes where R: registry::Eq {} - - impl Debug for SeededArchetypes - where - R: registry::Debug, - { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("SeededArchetypes") - .field("archetypes", &self.archetypes) - .field("len", &self.len) - .finish() - } - } - - impl Serialize for SeededArchetypes - where - R: registry::Serialize, - { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - self.archetypes.serialize(serializer) - } - } - - impl<'de, R> Deserialize<'de> for SeededArchetypes - where - R: registry::Deserialize<'de>, - { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - let mut len = 0; - let archetypes = DeserializeArchetypes::::new(&mut len).deserialize(deserializer)?; - Ok(Self { archetypes, len }) - } - } #[derive(Debug, Deserialize, Eq, PartialEq, Serialize)] struct A(u32); @@ -209,10 +160,21 @@ mod tests { fn serialize_deserialize_empty() { let archetypes = Archetypes::::new(); - assert_tokens( - &SeededArchetypes { archetypes, len: 0 }, - &[Token::Seq { len: Some(0) }, Token::SeqEnd], + let serializer = Serializer::builder().build(); + let tokens = assert_ok_eq!( + archetypes.serialize(&serializer), + Tokens(vec![Token::Seq { len: Some(0) }, Token::SeqEnd]) + ); + let mut len = 0; + let mut deserializer = Deserializer::builder() + .tokens(tokens) + .self_describing(false) + .build(); + assert_ok_eq!( + DeserializeArchetypes::::new(&mut len).deserialize(&mut deserializer), + archetypes ); + assert_eq!(len, 0); } #[test] @@ -245,11 +207,10 @@ mod tests { } assert_ok!(archetypes.insert(no_component_archetype)); - assert_tokens( - &SeededArchetypes { archetypes, len: 6 }.compact(), - // The order here should stay constant, because the fnv hasher uses the same seed every - // time. - &[ + let serializer = Serializer::builder().is_human_readable(false).build(); + let tokens = assert_ok_eq!( + archetypes.serialize(&serializer), + Tokens(vec![ Token::Seq { len: Some(4) }, // B Archetype Token::NewtypeStruct { name: "Archetype" }, @@ -287,9 +248,9 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(5), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::TupleEnd, @@ -312,27 +273,27 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(1), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(2), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::TupleEnd, @@ -373,18 +334,18 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(3), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(4), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::TupleEnd, @@ -398,14 +359,25 @@ mod tests { Token::TupleEnd, Token::TupleEnd, Token::SeqEnd, - ], + ]) ); + let mut len = 0; + let mut deserializer = Deserializer::builder() + .tokens(tokens) + .is_human_readable(false) + .self_describing(false) + .build(); + assert_ok_eq!( + DeserializeArchetypes::::new(&mut len).deserialize(&mut deserializer), + archetypes + ); + assert_eq!(len, 6); } #[test] fn deserialize_duplicate_archetype_identifiers() { - assert_de_tokens_error::>>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Seq { len: Some(4) }, // B Archetype Token::NewtypeStruct { name: "Archetype" }, @@ -445,8 +417,15 @@ mod tests { Token::TupleEnd, Token::TupleEnd, Token::TupleEnd, - ], - &format!("non-unique `Identifier` [\"{}\"], expected sequence of `Archetype`s with unique `Identifier`s", type_name::()), + ])) + .is_human_readable(false) + .self_describing(false) + .build(); + + let mut len = 0; + assert_err_eq!( + DeserializeArchetypes::::new(&mut len).deserialize(&mut deserializer), + Error::custom(&format!("non-unique `Identifier` [\"{}\"], expected sequence of `Archetype`s with unique `Identifier`s", type_name::())) ); } } diff --git a/src/entity/allocator/impl_serde.rs b/src/entity/allocator/impl_serde.rs index 89c6b403..e986884c 100644 --- a/src/entity/allocator/impl_serde.rs +++ b/src/entity/allocator/impl_serde.rs @@ -301,29 +301,43 @@ where #[cfg(test)] mod tests { - use super::*; + use super::{ + Allocator, + DeserializeAllocator, + Location, + }; use crate::{ archetype, archetype::Archetype, + archetypes::Archetypes, entity, - registry, Registry, }; - use claims::assert_ok; - use core::{ - fmt, - fmt::Debug, - marker::PhantomData, + use alloc::vec; + use claims::{ + assert_err_eq, + assert_ok, + assert_ok_eq, }; - use serde_derive::{ - Deserialize, + use core::fmt::Debug; + use serde::{ + de::{ + DeserializeSeed, + Error as _, + }, Serialize, }; - use serde_test::{ - assert_de_tokens, - assert_de_tokens_error, - assert_tokens, + use serde_assert::{ + de::Error, + ser::SerializeStructAs, + Deserializer, + Serializer, Token, + Tokens, + }; + use serde_derive::{ + Deserialize, + Serialize, }; #[derive(Debug, Deserialize, Eq, PartialEq, Serialize)] @@ -333,102 +347,34 @@ mod tests { type Registry = Registry!(A, B); - trait Seed - where - R: crate::registry::Registry, - { - fn archetypes() -> Archetypes; - } - - struct SeededAllocator(Allocator, Option>, PhantomData) - where - R: crate::registry::Registry; - - impl SeededAllocator - where - R: crate::registry::Registry, - { - fn new(allocator: Allocator) -> Self { - Self(allocator, None, PhantomData) - } - } - - impl PartialEq for SeededAllocator - where - R: registry::PartialEq, - { - fn eq(&self, other: &Self) -> bool { - self.0 == other.0 - } - } - - impl Eq for SeededAllocator where R: registry::Eq {} - - impl Debug for SeededAllocator - where - R: registry::Debug, - { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.0.fmt(f) - } - } - - impl Serialize for SeededAllocator - where - R: registry::Serialize, - { - fn serialize(&self, serializer: T) -> Result - where - T: Serializer, - { - self.0.serialize(serializer) - } - } - - impl<'de, R, S> Deserialize<'de> for SeededAllocator - where - R: registry::Deserialize<'de>, - S: Seed, - { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - let archetypes = S::archetypes(); - let allocator = DeserializeAllocator::new(&archetypes).deserialize(deserializer)?; - Ok(Self(allocator, Some(archetypes), PhantomData)) - } - } - #[test] fn serialize_deserialize_empty() { let allocator = Allocator::new(); - struct EmptySeed; - - impl Seed for EmptySeed - where - R: crate::registry::Registry, - { - fn archetypes() -> Archetypes { - Archetypes::new() - } - } - - assert_tokens( - &SeededAllocator::::new(allocator), - &[ + let serializer = Serializer::builder().build(); + let tokens = assert_ok_eq!( + allocator.serialize(&serializer), + Tokens(vec![ Token::Struct { name: "Allocator", len: 2, }, - Token::String("length"), + Token::Field("length"), Token::U64(0), - Token::String("free"), + Token::Field("free"), Token::Seq { len: Some(0) }, Token::SeqEnd, Token::StructEnd, - ], + ]) + ); + let mut deserializer = Deserializer::builder() + .tokens(tokens) + .self_describing(false) + .build(); + assert_ok_eq!( + DeserializeAllocator::new(&Archetypes::::new()) + .deserialize(&mut deserializer), + allocator ); } @@ -461,62 +407,66 @@ mod tests { }); unsafe { allocator.free_unchecked(entity_identifier) }; - struct PopulatedSeed; - - impl Seed for PopulatedSeed { - fn archetypes() -> Archetypes { - let mut archetypes = Archetypes::new(); - let mut allocator = Allocator::new(); - - let mut archetype = - Archetype::new(unsafe { archetype::Identifier::::new(vec![3]) }); - unsafe { - let entity_identifier = archetype.push(entity!(A, B), &mut allocator); // index 0. - archetype.remove_row_unchecked(entity_identifier.index, &mut allocator); // remove index 0. - allocator.free_unchecked(entity_identifier); - archetype.push(entity!(A, B), &mut allocator); // index 0. - archetype.push(entity!(A, B), &mut allocator); // index 1. - let entity_identifier = archetype.push(entity!(A, B), &mut allocator); // index 2. - archetype.remove_row_unchecked(entity_identifier.index, &mut allocator); // remove index 2. - allocator.free_unchecked(entity_identifier); - let entity_identifier = archetype.push(entity!(A, B), &mut allocator); // index 2. - archetype.remove_row_unchecked(entity_identifier.index, &mut allocator); // remove index 2. - allocator.free_unchecked(entity_identifier); - } - assert_ok!(archetypes.insert(archetype)); - - archetypes - } - } - - assert_tokens( - &SeededAllocator::::new(allocator), - &[ + let serializer = Serializer::builder().build(); + let tokens = assert_ok_eq!( + allocator.serialize(&serializer), + Tokens(vec![ Token::Struct { name: "Allocator", len: 2, }, - Token::String("length"), + Token::Field("length"), Token::U64(3), - Token::String("free"), + Token::Field("free"), Token::Seq { len: Some(1) }, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(2), - Token::String("generation"), + Token::Field("generation"), Token::U64(1), Token::StructEnd, Token::SeqEnd, Token::StructEnd, - ], + ]) + ); + let mut deserializer = Deserializer::builder() + .tokens(tokens) + .self_describing(false) + .build(); + let archetypes = { + let mut archetypes = Archetypes::::new(); + let mut allocator = Allocator::new(); + + let mut archetype = + Archetype::new(unsafe { archetype::Identifier::::new(vec![3]) }); + unsafe { + let entity_identifier = archetype.push(entity!(A, B), &mut allocator); // index 0. + archetype.remove_row_unchecked(entity_identifier.index, &mut allocator); // remove index 0. + allocator.free_unchecked(entity_identifier); + archetype.push(entity!(A, B), &mut allocator); // index 0. + archetype.push(entity!(A, B), &mut allocator); // index 1. + let entity_identifier = archetype.push(entity!(A, B), &mut allocator); // index 2. + archetype.remove_row_unchecked(entity_identifier.index, &mut allocator); // remove index 2. + allocator.free_unchecked(entity_identifier); + let entity_identifier = archetype.push(entity!(A, B), &mut allocator); // index 2. + archetype.remove_row_unchecked(entity_identifier.index, &mut allocator); // remove index 2. + allocator.free_unchecked(entity_identifier); + } + assert_ok!(archetypes.insert(archetype)); + + archetypes + }; + assert_ok_eq!( + DeserializeAllocator::new(&archetypes).deserialize(&mut deserializer), + allocator ); } #[test] - fn deserialize_from_seq() { + fn serialize_deserialize_from_seq() { let mut allocator = Allocator::new(); let archetype_identifier = unsafe { archetype::Identifier::::new(vec![3]) }; @@ -544,369 +494,335 @@ mod tests { }); unsafe { allocator.free_unchecked(entity_identifier) }; - struct PopulatedSeed; - - impl Seed for PopulatedSeed { - fn archetypes() -> Archetypes { - let mut archetypes = Archetypes::new(); - let mut allocator = Allocator::new(); - - let mut archetype = - Archetype::new(unsafe { archetype::Identifier::::new(vec![3]) }); - unsafe { - let entity_identifier = archetype.push(entity!(A, B), &mut allocator); // index 0. - archetype.remove_row_unchecked(entity_identifier.index, &mut allocator); // remove index 0. - allocator.free_unchecked(entity_identifier); - archetype.push(entity!(A, B), &mut allocator); // index 0. - archetype.push(entity!(A, B), &mut allocator); // index 1. - let entity_identifier = archetype.push(entity!(A, B), &mut allocator); // index 2. - archetype.remove_row_unchecked(entity_identifier.index, &mut allocator); // remove index 2. - allocator.free_unchecked(entity_identifier); - let entity_identifier = archetype.push(entity!(A, B), &mut allocator); // index 2. - archetype.remove_row_unchecked(entity_identifier.index, &mut allocator); // remove index 2. - allocator.free_unchecked(entity_identifier); - } - assert_ok!(archetypes.insert(archetype)); - - archetypes - } - } - - assert_de_tokens( - &SeededAllocator::::new(allocator), - &[ + let serializer = Serializer::builder() + .serialize_struct_as(SerializeStructAs::Seq) + .build(); + let tokens = assert_ok_eq!( + allocator.serialize(&serializer), + Tokens(vec![ Token::Seq { len: Some(2) }, Token::U64(3), Token::Seq { len: Some(1) }, - Token::Struct { - name: "Identifier", - len: 2, - }, - Token::String("index"), + Token::Seq { len: Some(2) }, Token::U64(2), - Token::String("generation"), Token::U64(1), - Token::StructEnd, Token::SeqEnd, Token::SeqEnd, - ], + Token::SeqEnd, + ]) + ); + let mut deserializer = Deserializer::builder() + .tokens(tokens) + .self_describing(false) + .build(); + let archetypes = { + let mut archetypes = Archetypes::::new(); + let mut allocator = Allocator::new(); + + let mut archetype = + Archetype::new(unsafe { archetype::Identifier::::new(vec![3]) }); + unsafe { + let entity_identifier = archetype.push(entity!(A, B), &mut allocator); // index 0. + archetype.remove_row_unchecked(entity_identifier.index, &mut allocator); // remove index 0. + allocator.free_unchecked(entity_identifier); + archetype.push(entity!(A, B), &mut allocator); // index 0. + archetype.push(entity!(A, B), &mut allocator); // index 1. + let entity_identifier = archetype.push(entity!(A, B), &mut allocator); // index 2. + archetype.remove_row_unchecked(entity_identifier.index, &mut allocator); // remove index 2. + allocator.free_unchecked(entity_identifier); + let entity_identifier = archetype.push(entity!(A, B), &mut allocator); // index 2. + archetype.remove_row_unchecked(entity_identifier.index, &mut allocator); // remove index 2. + allocator.free_unchecked(entity_identifier); + } + assert_ok!(archetypes.insert(archetype)); + + archetypes + }; + assert_ok_eq!( + DeserializeAllocator::new(&archetypes).deserialize(&mut deserializer), + allocator ); } #[test] fn deserialize_missing_field_length() { - struct EmptySeed; - - impl Seed for EmptySeed - where - R: crate::registry::Registry, - { - fn archetypes() -> Archetypes { - Archetypes::new() - } - } - - assert_de_tokens_error::>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Allocator", len: 2, }, - Token::String("free"), + Token::Field("free"), Token::Seq { len: Some(0) }, Token::SeqEnd, Token::StructEnd, - ], - "missing field `length`", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + DeserializeAllocator::new(&Archetypes::::new()) + .deserialize(&mut deserializer), + Error::missing_field("length") ); } #[test] fn deserialize_missing_field_free() { - struct EmptySeed; - - impl Seed for EmptySeed - where - R: crate::registry::Registry, - { - fn archetypes() -> Archetypes { - Archetypes::new() - } - } - - assert_de_tokens_error::>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Allocator", len: 2, }, - Token::String("length"), + Token::Field("length"), Token::U64(0), Token::StructEnd, - ], - "missing field `free`", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + DeserializeAllocator::new(&Archetypes::::new()) + .deserialize(&mut deserializer), + Error::missing_field("free") ); } #[test] fn deserialize_duplicate_field_length() { - struct EmptySeed; - - impl Seed for EmptySeed - where - R: crate::registry::Registry, - { - fn archetypes() -> Archetypes { - Archetypes::new() - } - } - - assert_de_tokens_error::>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Allocator", len: 2, }, - Token::String("length"), + Token::Field("length"), Token::U64(0), - Token::String("free"), + Token::Field("free"), Token::Seq { len: Some(0) }, Token::SeqEnd, - Token::String("length"), + Token::Field("length"), Token::U64(0), - ], - "duplicate field `length`", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + DeserializeAllocator::new(&Archetypes::::new()) + .deserialize(&mut deserializer), + Error::duplicate_field("length") ); } #[test] fn deserialize_duplicate_field_free() { - struct EmptySeed; - - impl Seed for EmptySeed - where - R: crate::registry::Registry, - { - fn archetypes() -> Archetypes { - Archetypes::new() - } - } - - assert_de_tokens_error::>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Allocator", len: 2, }, - Token::String("free"), + Token::Field("free"), Token::Seq { len: Some(0) }, Token::SeqEnd, - Token::String("length"), + Token::Field("length"), Token::U64(0), - Token::String("free"), + Token::Field("free"), Token::Seq { len: Some(0) }, - ], - "duplicate field `free`", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + DeserializeAllocator::new(&Archetypes::::new()) + .deserialize(&mut deserializer), + Error::duplicate_field("free") ); } #[test] fn deserialize_out_of_bounds_free_index() { - struct EmptySeed; - - impl Seed for EmptySeed - where - R: crate::registry::Registry, - { - fn archetypes() -> Archetypes { - Archetypes::new() - } - } - - assert_de_tokens_error::>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Allocator", len: 2, }, - Token::String("length"), + Token::Field("length"), Token::U64(0), - Token::String("free"), + Token::Field("free"), Token::Seq { len: Some(1) }, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(42), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::SeqEnd, Token::StructEnd, - ], - "freed entity index 42 is out of bounds", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + DeserializeAllocator::new(&Archetypes::::new()) + .deserialize(&mut deserializer), + Error::custom("freed entity index 42 is out of bounds") ); } #[test] fn deserialize_duplicate_free_index() { - struct EmptySeed; - - impl Seed for EmptySeed - where - R: crate::registry::Registry, - { - fn archetypes() -> Archetypes { - Archetypes::new() - } - } - - assert_de_tokens_error::>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Allocator", len: 2, }, - Token::String("length"), + Token::Field("length"), Token::U64(1), - Token::String("free"), + Token::Field("free"), Token::Seq { len: Some(2) }, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), - Token::String("generation"), + Token::Field("generation"), Token::U64(1), Token::StructEnd, Token::SeqEnd, Token::StructEnd, - ], - "duplicate freed entity index 0", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + DeserializeAllocator::new(&Archetypes::::new()) + .deserialize(&mut deserializer), + Error::custom("duplicate freed entity index 0") ); } #[test] fn deserialize_out_of_bounds_archetype_index() { - struct PopulatedSeed; - - impl Seed for PopulatedSeed { - fn archetypes() -> Archetypes { - let mut archetypes = Archetypes::new(); - let mut allocator = Allocator::new(); - - let mut archetype = - Archetype::new(unsafe { archetype::Identifier::::new(vec![3]) }); - unsafe { - archetype.push(entity!(A, B), &mut allocator); - } - assert_ok!(archetypes.insert(archetype)); - - archetypes + let archetypes = { + let mut archetypes = Archetypes::::new(); + let mut allocator = Allocator::new(); + + let mut archetype = + Archetype::new(unsafe { archetype::Identifier::::new(vec![3]) }); + unsafe { + archetype.push(entity!(A, B), &mut allocator); } - } + assert_ok!(archetypes.insert(archetype)); - assert_de_tokens_error::>( - &[ + archetypes + }; + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Allocator", len: 2, }, - Token::String("length"), + Token::Field("length"), Token::U64(0), - Token::String("free"), + Token::Field("free"), Token::Seq { len: Some(0) }, Token::SeqEnd, Token::StructEnd, - ], - "archetype entity index 0 is out of bounds", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + DeserializeAllocator::new(&archetypes).deserialize(&mut deserializer), + Error::custom("archetype entity index 0 is out of bounds") ); } #[test] fn deserialize_duplicate_archetype_index() { - struct PopulatedSeed; - - impl Seed for PopulatedSeed { - fn archetypes() -> Archetypes { - let mut archetypes = Archetypes::new(); - let mut allocator = Allocator::new(); - - let mut archetype = - Archetype::new(unsafe { archetype::Identifier::::new(vec![3]) }); - unsafe { - archetype.push(entity!(A, B), &mut allocator); - } - assert_ok!(archetypes.insert(archetype)); - - archetypes + let archetypes = { + let mut archetypes = Archetypes::::new(); + let mut allocator = Allocator::new(); + + let mut archetype = + Archetype::new(unsafe { archetype::Identifier::::new(vec![3]) }); + unsafe { + archetype.push(entity!(A, B), &mut allocator); } - } + assert_ok!(archetypes.insert(archetype)); - assert_de_tokens_error::>( - &[ + archetypes + }; + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Allocator", len: 2, }, - Token::String("length"), + Token::Field("length"), Token::U64(1), - Token::String("free"), + Token::Field("free"), Token::Seq { len: Some(1) }, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::SeqEnd, Token::StructEnd, - ], - "duplicate archetype entity index 0", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + DeserializeAllocator::new(&archetypes).deserialize(&mut deserializer), + Error::custom("duplicate archetype entity index 0") ); } #[test] fn deserialize_missing_index() { - struct EmptySeed; - - impl Seed for EmptySeed - where - R: crate::registry::Registry, - { - fn archetypes() -> Archetypes { - Archetypes::new() - } - } - - assert_de_tokens_error::>( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Allocator", len: 2, }, - Token::String("length"), + Token::Field("length"), Token::U64(1), - Token::String("free"), + Token::Field("free"), Token::Seq { len: Some(0) }, Token::SeqEnd, Token::StructEnd, - ], - "missing entity index 0", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + DeserializeAllocator::new(&Archetypes::::new()) + .deserialize(&mut deserializer), + Error::custom("missing entity index 0") ); } } diff --git a/src/entity/identifier/impl_serde.rs b/src/entity/identifier/impl_serde.rs index 8d1ea67a..25beb3c4 100644 --- a/src/entity/identifier/impl_serde.rs +++ b/src/entity/identifier/impl_serde.rs @@ -125,153 +125,222 @@ impl<'de> Deserialize<'de> for Identifier { #[cfg(test)] mod tests { use crate::entity::Identifier; - use serde_test::{ - assert_de_tokens, - assert_de_tokens_error, - assert_tokens, + use alloc::vec; + use claims::{ + assert_err_eq, + assert_ok_eq, + }; + use serde::{ + de::Error as _, + Deserialize, + Serialize, + }; + use serde_assert::{ + de::Error, + ser::SerializeStructAs, + Deserializer, + Serializer, Token, + Tokens, }; #[test] fn serialize_deserialize() { let identifier = Identifier::new(1, 2); - assert_tokens( - &identifier, - &[ + let serializer = Serializer::builder().build(); + let tokens = assert_ok_eq!( + identifier.serialize(&serializer), + Tokens(vec![ Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(1), - Token::String("generation"), + Token::Field("generation"), Token::U64(2), Token::StructEnd, - ], + ]) ); + let mut deserializer = Deserializer::builder() + .tokens(tokens) + .self_describing(false) + .build(); + assert_ok_eq!(Identifier::deserialize(&mut deserializer), identifier); } #[test] fn deserialize_missing_index() { - assert_de_tokens_error::( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Identifier", len: 1, }, - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, - ], - "missing field `index`", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Identifier::deserialize(&mut deserializer), + Error::missing_field("index") ); } #[test] fn deserialize_missing_generation() { - assert_de_tokens_error::( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Identifier", len: 1, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), Token::StructEnd, - ], - "missing field `generation`", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Identifier::deserialize(&mut deserializer), + Error::missing_field("generation") ); } #[test] fn deserialize_duplicate_index() { - assert_de_tokens_error::( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), - Token::String("index"), - ], - "duplicate field `index`", + Token::Field("index"), + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Identifier::deserialize(&mut deserializer), + Error::duplicate_field("index") ); } #[test] fn deserialize_duplicate_generation() { - assert_de_tokens_error::( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Identifier", len: 2, }, - Token::String("generation"), + Token::Field("generation"), Token::U64(0), - Token::String("generation"), - ], - "duplicate field `generation`", + Token::Field("generation"), + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Identifier::deserialize(&mut deserializer), + Error::duplicate_field("generation") ); } #[test] fn deserialize_unknown_field() { - assert_de_tokens_error::( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Struct { name: "Identifier", len: 2, }, - Token::String("unknown"), - ], - "unknown field `unknown`, expected `index` or `generation`", + Token::Field("unknown"), + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Identifier::deserialize(&mut deserializer), + Error::unknown_field("unknown", &["index", "generation"]) ); } #[test] - fn deserialize_from_seq() { + fn serialize_deserialize_from_seq() { let identifier = Identifier::new(1, 2); - assert_de_tokens( - &identifier, - &[ + let serializer = Serializer::builder() + .serialize_struct_as(SerializeStructAs::Seq) + .build(); + let tokens = assert_ok_eq!( + identifier.serialize(&serializer), + Tokens(vec![ Token::Seq { len: Some(2) }, Token::U64(1), Token::U64(2), Token::SeqEnd, - ], + ]) ); + let mut deserializer = Deserializer::builder() + .tokens(tokens) + .self_describing(false) + .build(); + assert_ok_eq!(Identifier::deserialize(&mut deserializer), identifier); } #[test] fn deserialize_from_seq_no_items() { - assert_de_tokens_error::( - &[Token::Seq { len: Some(0) }, Token::SeqEnd], - "invalid length 0, expected struct Identifier", + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![Token::Seq { len: Some(0) }, Token::SeqEnd])) + .self_describing(false) + .build(); + + assert_err_eq!( + Identifier::deserialize(&mut deserializer), + Error::invalid_length(0, &"struct Identifier") ); } #[test] fn deserialize_from_seq_missing_item() { - assert_de_tokens_error::( - &[Token::Seq { len: Some(1) }, Token::U64(1), Token::SeqEnd], - "invalid length 1, expected struct Identifier", + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ + Token::Seq { len: Some(1) }, + Token::U64(1), + Token::SeqEnd, + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Identifier::deserialize(&mut deserializer), + Error::invalid_length(1, &"struct Identifier") ); } #[test] - #[should_panic(expected = "expected Token::U64(3) but deserialization wants Token::SeqEnd")] fn deserialize_from_seq_too_many_items() { - assert_de_tokens_error::( - &[ + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ Token::Seq { len: Some(3) }, Token::U64(1), Token::U64(2), Token::U64(3), - ], - "", + ])) + .self_describing(false) + .build(); + + assert_err_eq!( + Identifier::deserialize(&mut deserializer), + Error::ExpectedToken(Token::SeqEnd) ); } } diff --git a/src/hlist.rs b/src/hlist.rs index 4b1a417b..0e2ace8d 100644 --- a/src/hlist.rs +++ b/src/hlist.rs @@ -83,11 +83,25 @@ pub(crate) use define_null_uninstantiable; mod tests { use super::*; #[cfg(feature = "serde")] - use serde_test::{ - assert_de_tokens, - assert_de_tokens_error, - assert_tokens, + use alloc::vec; + #[cfg(feature = "serde")] + use claims::{ + assert_err_eq, + assert_ok_eq, + }; + #[cfg(feature = "serde")] + use serde::{ + de::Error as _, + Deserialize, + Serialize, + }; + #[cfg(feature = "serde")] + use serde_assert::{ + de::Error, + Deserializer, + Serializer, Token, + Tokens, }; define_null!(); @@ -95,21 +109,31 @@ mod tests { #[cfg(feature = "serde")] #[test] fn serialize_deserialize() { - assert_tokens(&Null, &[Token::UnitStruct { name: "Null" }]); - } + let null = Null; - #[cfg(feature = "serde")] - #[test] - fn deserialize_from_unit() { - assert_de_tokens(&Null, &[Token::Unit]); + let serializer = Serializer::builder().build(); + let tokens = assert_ok_eq!( + null.serialize(&serializer), + Tokens(vec![Token::UnitStruct { name: "Null" }]) + ); + let mut deserializer = Deserializer::builder() + .tokens(tokens) + .self_describing(false) + .build(); + assert_ok_eq!(Null::deserialize(&mut deserializer), null); } #[cfg(feature = "serde")] #[test] fn deserialize_from_invalid_type() { - assert_de_tokens_error::( - &[Token::U32(42)], - "invalid type: integer `42`, expected struct Null", + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![Token::U32(42)])) + .self_describing(false) + .build(); + + assert_err_eq!( + Null::deserialize(&mut deserializer), + Error::invalid_type((&Token::U32(42)).into(), &"struct Null") ); } } diff --git a/src/world/impl_serde.rs b/src/world/impl_serde.rs index 4676c067..eff5d159 100644 --- a/src/world/impl_serde.rs +++ b/src/world/impl_serde.rs @@ -85,21 +85,31 @@ where #[cfg(test)] mod tests { - use super::*; + use super::World; use crate::{ entity, Registry, }; - use serde_derive::{ + use alloc::vec; + use claims::{ + assert_err_eq, + assert_ok_eq, + }; + use serde::{ + de::Error as _, Deserialize, Serialize, }; - use serde_test::{ - assert_de_tokens_error, - assert_tokens, - Compact, - Configure, + use serde_assert::{ + de::Error, + Deserializer, + Serializer, Token, + Tokens, + }; + use serde_derive::{ + Deserialize, + Serialize, }; #[derive(Debug, Deserialize, Eq, PartialEq, Serialize)] @@ -114,9 +124,10 @@ mod tests { fn serialize_deserialize_empty() { let world = World::::new(); - assert_tokens( - &world, - &[ + let serializer = Serializer::builder().build(); + let tokens = assert_ok_eq!( + world.serialize(&serializer), + Tokens(vec![ Token::Tuple { len: 2 }, // Archetypes Token::Seq { len: Some(0) }, @@ -126,15 +137,20 @@ mod tests { name: "Allocator", len: 2, }, - Token::String("length"), + Token::Field("length"), Token::U64(0), - Token::String("free"), + Token::Field("free"), Token::Seq { len: Some(0) }, Token::SeqEnd, Token::StructEnd, Token::TupleEnd, - ], + ]) ); + let mut deserializer = Deserializer::builder() + .tokens(tokens) + .self_describing(false) + .build(); + assert_ok_eq!(World::::deserialize(&mut deserializer), world); } #[test] @@ -154,9 +170,10 @@ mod tests { let entity_identifier = world.insert(entity!(B('h'))); world.remove(entity_identifier); - assert_tokens( - &world.compact(), - &[ + let serializer = Serializer::builder().is_human_readable(false).build(); + let tokens = assert_ok_eq!( + world.serialize(&serializer), + Tokens(vec![ Token::Tuple { len: 2 }, // Archetypes Token::Seq { len: Some(4) }, @@ -196,9 +213,9 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(5), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::TupleEnd, @@ -221,27 +238,27 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(0), - Token::String("generation"), + Token::Field("generation"), Token::U64(1), Token::StructEnd, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(1), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(2), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::TupleEnd, @@ -282,18 +299,18 @@ mod tests { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(3), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(4), - Token::String("generation"), + Token::Field("generation"), Token::U64(0), Token::StructEnd, Token::TupleEnd, @@ -312,45 +329,63 @@ mod tests { name: "Allocator", len: 2, }, - Token::String("length"), + Token::Field("length"), Token::U64(7), - Token::String("free"), + Token::Field("free"), Token::Seq { len: Some(1) }, Token::Struct { name: "Identifier", len: 2, }, - Token::String("index"), + Token::Field("index"), Token::U64(6), - Token::String("generation"), + Token::Field("generation"), Token::U64(1), Token::StructEnd, Token::SeqEnd, Token::StructEnd, Token::TupleEnd, - ], + ]) ); + let mut deserializer = Deserializer::builder() + .tokens(tokens) + .is_human_readable(false) + .self_describing(false) + .build(); + assert_ok_eq!(World::::deserialize(&mut deserializer), world); } #[test] fn deserialize_missing_archetypes() { - assert_de_tokens_error::>>( - &[Token::Tuple { len: 0 }, Token::TupleEnd], - "invalid length 0, expected serialized World", + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![Token::Tuple { len: 0 }, Token::TupleEnd])) + .is_human_readable(false) + .self_describing(false) + .build(); + + assert_err_eq!( + World::::deserialize(&mut deserializer), + Error::invalid_length(0, &"serialized World") ); } #[test] fn deserialize_missing_entity_allocator() { - assert_de_tokens_error::>>( - &[ - Token::Tuple { len: 0 }, + let mut deserializer = Deserializer::builder() + .tokens(Tokens(vec![ + Token::Tuple { len: 1 }, // Archetypes Token::Seq { len: Some(0) }, Token::SeqEnd, Token::TupleEnd, - ], - "invalid length 1, expected serialized World", + ])) + .is_human_readable(false) + .self_describing(false) + .build(); + + assert_err_eq!( + World::::deserialize(&mut deserializer), + Error::invalid_length(1, &"serialized World") ); } }