mikros/serde
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Convert newtype_enum and struct_enum tests into modules

Browse Source 
Separate testing each variant kind of enum (unit, newtype, tuple, struct) results
in more specific information if that checks fail

(review this commit with "ignore whitespace changes" option on)
This commit is contained in:
Mingun 2023-08-08 00:54:36 +05:00
parent 8bfe0d0ac0
commit 4987fd15f7
1 changed files with 148 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

279
test_suite/tests/test_enum_internally_tagged.rs
View File

@ -187,90 +187,103 @@ fn newtype_struct() {
); );
} }
#[test] mod newtype_enum {
fn newtype_enum() { use super::*;
assert_tokens(
&InternallyTagged::NewtypeEnum(Enum::Unit),
&[
Token::Map { len: Some(2) },
Token::Str("tag"),
Token::Str("NewtypeEnum"),
Token::Str("Unit"),
Token::Unit,
Token::MapEnd,
],
);
assert_tokens( #[test]
&InternallyTagged::NewtypeEnum(Enum::Newtype(1)), fn unit() {
&[ assert_tokens(
Token::Map { len: Some(2) }, &InternallyTagged::NewtypeEnum(Enum::Unit),
Token::Str("tag"), &[
Token::Str("NewtypeEnum"), Token::Map { len: Some(2) },
Token::Str("Newtype"), Token::Str("tag"),
Token::U8(1), Token::Str("NewtypeEnum"),
Token::MapEnd, Token::Str("Unit"),
], Token::Unit,
); Token::MapEnd,
],
);
}
// Reaches crate::private::de::content::VariantDeserializer::tuple_variant #[test]
// Content::Seq case fn newtype() {
// via ContentDeserializer::deserialize_enum assert_tokens(
assert_tokens( &InternallyTagged::NewtypeEnum(Enum::Newtype(1)),
&InternallyTagged::NewtypeEnum(Enum::Tuple(1, 1)), &[
&[ Token::Map { len: Some(2) },
Token::Map { len: Some(2) }, Token::Str("tag"),
Token::Str("tag"), Token::Str("NewtypeEnum"),
Token::Str("NewtypeEnum"), Token::Str("Newtype"),
Token::Str("Tuple"), Token::U8(1),
Token::TupleStruct { Token::MapEnd,
name: "Tuple", ],
len: 2, );
}, }
Token::U8(1),
Token::U8(1),
Token::TupleStructEnd,
Token::MapEnd,
],
);
// Reaches crate::private::de::content::VariantDeserializer::struct_variant #[test]
// Content::Map case fn tuple() {
// via ContentDeserializer::deserialize_enum // Reaches crate::private::de::content::VariantDeserializer::tuple_variant
assert_tokens( // Content::Seq case
&InternallyTagged::NewtypeEnum(Enum::Struct { f: 1 }), // via ContentDeserializer::deserialize_enum
&[ assert_tokens(
Token::Map { len: Some(2) }, &InternallyTagged::NewtypeEnum(Enum::Tuple(1, 1)),
Token::Str("tag"), &[
Token::Str("NewtypeEnum"), Token::Map { len: Some(2) },
Token::Str("Struct"), Token::Str("tag"),
Token::Struct { Token::Str("NewtypeEnum"),
name: "Struct", Token::Str("Tuple"),
len: 1, Token::TupleStruct {
}, name: "Tuple",
Token::Str("f"), len: 2,
Token::U8(1), },
Token::StructEnd, Token::U8(1),
Token::MapEnd, Token::U8(1),
], Token::TupleStructEnd,
); Token::MapEnd,
],
);
}
// Reaches crate::private::de::content::VariantDeserializer::struct_variant #[test]
// Content::Seq case fn struct_() {
// via ContentDeserializer::deserialize_enum // Reaches crate::private::de::content::VariantDeserializer::struct_variant
assert_de_tokens( // Content::Map case
&InternallyTagged::NewtypeEnum(Enum::Struct { f: 1 }), // via ContentDeserializer::deserialize_enum
&[ assert_tokens(
Token::Map { len: Some(2) }, &InternallyTagged::NewtypeEnum(Enum::Struct { f: 1 }),
Token::Str("tag"), &[
Token::Str("NewtypeEnum"), Token::Map { len: Some(2) },
Token::Str("Struct"), Token::Str("tag"),
Token::Seq { len: Some(1) }, Token::Str("NewtypeEnum"),
Token::U8(1), // f Token::Str("Struct"),
Token::SeqEnd, Token::Struct {
Token::MapEnd, name: "Struct",
], len: 1,
); },
Token::Str("f"),
Token::U8(1),
Token::StructEnd,
Token::MapEnd,
],
);
// Reaches crate::private::de::content::VariantDeserializer::struct_variant
// Content::Seq case
// via ContentDeserializer::deserialize_enum
assert_de_tokens(
&InternallyTagged::NewtypeEnum(Enum::Struct { f: 1 }),
&[
Token::Map { len: Some(2) },
Token::Str("tag"),
Token::Str("NewtypeEnum"),
Token::Str("Struct"),
Token::Seq { len: Some(1) },
Token::U8(1), // f
Token::SeqEnd,
Token::MapEnd,
],
);
}
} }
#[test] #[test]
@ -301,61 +314,65 @@ fn struct_() {
); );
} }
#[test] mod struct_enum {
fn struct_enum() { use super::*;
assert_de_tokens(
&Enum::Unit,
&[
Token::Enum { name: "Enum" },
Token::BorrowedStr("Unit"),
Token::Unit,
],
);
let value = InternallyTagged::StructEnum { enum_: Enum::Unit }; #[test]
fn unit() {
assert_de_tokens(
&Enum::Unit,
&[
Token::Enum { name: "Enum" },
Token::BorrowedStr("Unit"),
Token::Unit,
],
);
assert_de_tokens( let value = InternallyTagged::StructEnum { enum_: Enum::Unit };
&value,
&[
Token::Struct {
name: "InternallyTagged",
len: 2,
},
Token::Str("tag"),
Token::Str("StructEnum"),
Token::Str("enum_"),
Token::Enum { name: "Enum" },
Token::BorrowedStr("Unit"),
Token::Unit,
Token::StructEnd,
],
);
assert_de_tokens( assert_de_tokens(
&value, &value,
&[ &[
Token::Map { len: Some(2) }, Token::Struct {
Token::Str("tag"), name: "InternallyTagged",
Token::Str("StructEnum"), len: 2,
Token::Str("enum_"), },
Token::Enum { name: "Enum" }, Token::Str("tag"),
Token::BorrowedStr("Unit"), Token::Str("StructEnum"),
Token::Unit, Token::Str("enum_"),
Token::MapEnd, Token::Enum { name: "Enum" },
], Token::BorrowedStr("Unit"),
); Token::Unit,
Token::StructEnd,
],
);
assert_de_tokens( assert_de_tokens(
&value, &value,
&[ &[
Token::Seq { len: Some(2) }, Token::Map { len: Some(2) },
Token::Str("StructEnum"), // tag Token::Str("tag"),
Token::Enum { name: "Enum" }, // enum_ Token::Str("StructEnum"),
Token::BorrowedStr("Unit"), Token::Str("enum_"),
Token::Unit, Token::Enum { name: "Enum" },
Token::SeqEnd, Token::BorrowedStr("Unit"),
], Token::Unit,
); Token::MapEnd,
],
);
assert_de_tokens(
&value,
&[
Token::Seq { len: Some(2) },
Token::Str("StructEnum"), // tag
Token::Enum { name: "Enum" }, // enum_
Token::BorrowedStr("Unit"),
Token::Unit,
Token::SeqEnd,
],
);
}
} }
#[test] #[test]