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

Move and rename tests:

Browse Source 
- newtype_variant_containing_unit                   -> newtype_unit
- newtype_variant_containing_unit_struct            -> newtype_unit_struct
- newtype_variant_containing_externally_tagged_enum -> newtype_enum
- struct_variant_containing_unit_variant            -> struct_enum
This commit is contained in:
Mingun 2023-08-07 22:51:46 +05:00
parent 7c0e6bd18f
commit 8bfe0d0ac0
1 changed files with 195 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

390
test_suite/tests/test_enum_internally_tagged.rs
View File

@ -70,6 +70,58 @@ fn unit() {
);
}
#[test]
fn newtype_unit() {
let value = InternallyTagged::NewtypeUnit(());
assert_tokens(
&value,
&[
Token::Map { len: Some(1) },
Token::Str("tag"),
Token::Str("NewtypeUnit"),
Token::MapEnd,
],
);
}
#[test]
fn newtype_unit_struct() {
let value = InternallyTagged::NewtypeUnitStruct(Unit);
assert_tokens(
&value,
&[
Token::Map { len: Some(1) },
Token::Str("tag"),
Token::Str("NewtypeUnitStruct"),
Token::MapEnd,
],
);
assert_de_tokens(
&value,
&[
Token::Struct {
name: "InternallyTagged",
len: 1,
},
Token::Str("tag"),
Token::Str("NewtypeUnitStruct"),
Token::StructEnd,
],
);
assert_de_tokens(
&value,
&[
Token::Seq { len: Some(1) },
Token::Str("NewtypeUnitStruct"), // tag
Token::SeqEnd,
],
);
}
#[test]
fn newtype_newtype() {
assert_tokens(
@ -135,6 +187,92 @@ fn newtype_struct() {
);
}
#[test]
fn newtype_enum() {
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(
&InternallyTagged::NewtypeEnum(Enum::Newtype(1)),
&[
Token::Map { len: Some(2) },
Token::Str("tag"),
Token::Str("NewtypeEnum"),
Token::Str("Newtype"),
Token::U8(1),
Token::MapEnd,
],
);
// Reaches crate::private::de::content::VariantDeserializer::tuple_variant
// Content::Seq case
// via ContentDeserializer::deserialize_enum
assert_tokens(
&InternallyTagged::NewtypeEnum(Enum::Tuple(1, 1)),
&[
Token::Map { len: Some(2) },
Token::Str("tag"),
Token::Str("NewtypeEnum"),
Token::Str("Tuple"),
Token::TupleStruct {
name: "Tuple",
len: 2,
},
Token::U8(1),
Token::U8(1),
Token::TupleStructEnd,
Token::MapEnd,
],
);
// Reaches crate::private::de::content::VariantDeserializer::struct_variant
// Content::Map case
// via ContentDeserializer::deserialize_enum
assert_tokens(
&InternallyTagged::NewtypeEnum(Enum::Struct { f: 1 }),
&[
Token::Map { len: Some(2) },
Token::Str("tag"),
Token::Str("NewtypeEnum"),
Token::Str("Struct"),
Token::Struct {
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]
fn struct_() {
assert_tokens(
@ -163,6 +301,63 @@ fn struct_() {
);
}
#[test]
fn struct_enum() {
assert_de_tokens(
&Enum::Unit,
&[
Token::Enum { name: "Enum" },
Token::BorrowedStr("Unit"),
Token::Unit,
],
);
let value = InternallyTagged::StructEnum { enum_: Enum::Unit };
assert_de_tokens(
&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(
&value,
&[
Token::Map { len: Some(2) },
Token::Str("tag"),
Token::Str("StructEnum"),
Token::Str("enum_"),
Token::Enum { name: "Enum" },
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]
fn wrong_tag() {
assert_de_tokens_error::<InternallyTagged>(
@ -460,63 +655,6 @@ mod string_and_bytes {
}
}
#[test]
fn struct_variant_containing_unit_variant() {
assert_de_tokens(
&Enum::Unit,
&[
Token::Enum { name: "Enum" },
Token::BorrowedStr("Unit"),
Token::Unit,
],
);
let value = InternallyTagged::StructEnum { enum_: Enum::Unit };
assert_de_tokens(
&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(
&value,
&[
Token::Map { len: Some(2) },
Token::Str("tag"),
Token::Str("StructEnum"),
Token::Str("enum_"),
Token::Enum { name: "Enum" },
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]
fn borrow() {
#[derive(Debug, PartialEq, Serialize, Deserialize)]
@ -541,129 +679,6 @@ fn borrow() {
);
}
#[test]
fn newtype_variant_containing_externally_tagged_enum() {
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(
&InternallyTagged::NewtypeEnum(Enum::Newtype(1)),
&[
Token::Map { len: Some(2) },
Token::Str("tag"),
Token::Str("NewtypeEnum"),
Token::Str("Newtype"),
Token::U8(1),
Token::MapEnd,
],
);
// Reaches crate::private::de::content::VariantDeserializer::tuple_variant
// Content::Seq case
// via ContentDeserializer::deserialize_enum
assert_tokens(
&InternallyTagged::NewtypeEnum(Enum::Tuple(1, 1)),
&[
Token::Map { len: Some(2) },
Token::Str("tag"),
Token::Str("NewtypeEnum"),
Token::Str("Tuple"),
Token::TupleStruct {
name: "Tuple",
len: 2,
},
Token::U8(1),
Token::U8(1),
Token::TupleStructEnd,
Token::MapEnd,
],
);
// Reaches crate::private::de::content::VariantDeserializer::struct_variant
// Content::Map case
// via ContentDeserializer::deserialize_enum
assert_tokens(
&InternallyTagged::NewtypeEnum(Enum::Struct { f: 1 }),
&[
Token::Map { len: Some(2) },
Token::Str("tag"),
Token::Str("NewtypeEnum"),
Token::Str("Struct"),
Token::Struct {
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]
fn newtype_variant_containing_unit_struct() {
let value = InternallyTagged::NewtypeUnitStruct(Unit);
assert_tokens(
&value,
&[
Token::Map { len: Some(1) },
Token::Str("tag"),
Token::Str("NewtypeUnitStruct"),
Token::MapEnd,
],
);
assert_de_tokens(
&value,
&[
Token::Struct {
name: "InternallyTagged",
len: 1,
},
Token::Str("tag"),
Token::Str("NewtypeUnitStruct"),
Token::StructEnd,
],
);
assert_de_tokens(
&value,
&[
Token::Seq { len: Some(1) },
Token::Str("NewtypeUnitStruct"), // tag
Token::SeqEnd,
],
);
}
#[test]
fn with_skipped_conflict() {
#[derive(Debug, PartialEq, Serialize, Deserialize)]
@ -734,21 +749,6 @@ fn containing_flatten() {
);
}
#[test]
fn newtype_variant_containing_unit() {
let value = InternallyTagged::NewtypeUnit(());
assert_tokens(
&value,
&[
Token::Map { len: Some(1) },
Token::Str("tag"),
Token::Str("NewtypeUnit"),
Token::MapEnd,
],
);
}
#[test]
fn unit_variant_with_unknown_fields() {
let value = InternallyTagged::Unit;