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

Move all internally tagged enum tests of test_macros into a dedicated module

Browse Source 
Moved:
- test_internally_tagged_enum_with_untagged_variant             => untagged_variant
- test_internally_tagged_bytes                                  => string_and_bytes mod
- test_internally_tagged_struct_variant_containing_unit_variant => struct_variant_containing_unit_variant
- test_internally_tagged_borrow                                 => borrow
- test_enum_in_internally_tagged_enum                           => newtype_variant_containing_externally_tagged_enum
- test_internally_tagged_newtype_variant_containing_unit_struct => newtype_variant_containing_unit_struct

(review this commit with "ignore whitespace changes" option on)
This commit is contained in:
Mingun 2023-07-27 23:42:58 +05:00
parent aa0654332d
commit 99f905403b
1 changed files with 479 additions and 463 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

942
test_suite/tests/test_macros.rs
View File

@ -831,350 +831,510 @@ mod internally_tagged_enum {
"unknown variant `Z`, expected one of `A`, `B`, `C`, `D`, `E`", "unknown variant `Z`, expected one of `A`, `B`, `C`, `D`, `E`",
); );
} }
}
#[test] #[test]
fn test_internally_tagged_enum_with_untagged_variant() { fn untagged_variant() {
#[derive(Debug, PartialEq, Serialize, Deserialize)] #[derive(Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind")] #[serde(tag = "kind")]
enum InternallyTagged { enum InternallyTagged {
Tagged { Tagged {
a: u8, a: u8,
}, },
#[serde(untagged)] #[serde(untagged)]
Untagged { Untagged {
kind: String, kind: String,
b: u8, b: u8,
}, },
}
assert_de_tokens(
&InternallyTagged::Tagged { a: 1 },
&[
Token::Map { len: Some(2) },
Token::Str("kind"),
Token::Str("Tagged"),
Token::Str("a"),
Token::U8(1),
Token::MapEnd,
],
);
assert_tokens(
&InternallyTagged::Tagged { a: 1 },
&[
Token::Struct {
name: "InternallyTagged",
len: 2,
},
Token::Str("kind"),
Token::Str("Tagged"),
Token::Str("a"),
Token::U8(1),
Token::StructEnd,
],
);
assert_de_tokens(
&InternallyTagged::Untagged {
kind: "Foo".to_owned(),
b: 2,
},
&[
Token::Map { len: Some(2) },
Token::Str("kind"),
Token::Str("Foo"),
Token::Str("b"),
Token::U8(2),
Token::MapEnd,
],
);
assert_tokens(
&InternallyTagged::Untagged {
kind: "Foo".to_owned(),
b: 2,
},
&[
Token::Struct {
name: "InternallyTagged",
len: 2,
},
Token::Str("kind"),
Token::Str("Foo"),
Token::Str("b"),
Token::U8(2),
Token::StructEnd,
],
);
assert_tokens(
&InternallyTagged::Untagged {
kind: "Tagged".to_owned(),
b: 2,
},
&[
Token::Struct {
name: "InternallyTagged",
len: 2,
},
Token::Str("kind"),
Token::Str("Tagged"),
Token::Str("b"),
Token::U8(2),
Token::StructEnd,
],
);
} }
assert_de_tokens( mod string_and_bytes {
&InternallyTagged::Tagged { a: 1 }, use super::*;
&[
Token::Map { len: Some(2) },
Token::Str("kind"),
Token::Str("Tagged"),
Token::Str("a"),
Token::U8(1),
Token::MapEnd,
],
);
assert_tokens( #[derive(Debug, PartialEq, Deserialize)]
&InternallyTagged::Tagged { a: 1 }, #[serde(tag = "type")]
&[ enum InternallyTagged {
Token::Struct { String {
name: "InternallyTagged", string: String,
len: 2,
}, },
Token::Str("kind"), Bytes {
Token::Str("Tagged"), #[serde(with = "bytes")]
Token::Str("a"), bytes: Vec<u8>,
Token::U8(1),
Token::StructEnd,
],
);
assert_de_tokens(
&InternallyTagged::Untagged {
kind: "Foo".to_owned(),
b: 2,
},
&[
Token::Map { len: Some(2) },
Token::Str("kind"),
Token::Str("Foo"),
Token::Str("b"),
Token::U8(2),
Token::MapEnd,
],
);
assert_tokens(
&InternallyTagged::Untagged {
kind: "Foo".to_owned(),
b: 2,
},
&[
Token::Struct {
name: "InternallyTagged",
len: 2,
}, },
Token::Str("kind"), }
Token::Str("Foo"),
Token::Str("b"),
Token::U8(2),
Token::StructEnd,
],
);
assert_tokens( #[test]
&InternallyTagged::Untagged { fn string_from_string() {
kind: "Tagged".to_owned(), assert_de_tokens(
b: 2, &InternallyTagged::String {
}, string: "\0".to_owned(),
&[ },
Token::Struct { &[
name: "InternallyTagged", Token::Struct {
len: 2, name: "String",
}, len: 2,
Token::Str("kind"), },
Token::Str("Tagged"), Token::Str("type"),
Token::Str("b"), Token::Str("String"),
Token::U8(2), Token::Str("string"),
Token::StructEnd, Token::Str("\0"),
], Token::StructEnd,
); ],
} );
#[test] assert_de_tokens(
fn test_internally_tagged_bytes() { &InternallyTagged::String {
#[derive(Debug, PartialEq, Deserialize)] string: "\0".to_owned(),
#[serde(tag = "type")] },
enum InternallyTagged { &[
String { Token::Struct {
string: String, name: "String",
}, len: 2,
Bytes { },
#[serde(with = "bytes")] Token::Str("type"),
bytes: Vec<u8>, Token::Str("String"),
}, Token::Str("string"),
Token::String("\0"),
Token::StructEnd,
],
);
}
#[test]
fn string_from_bytes() {
assert_de_tokens(
&InternallyTagged::String {
string: "\0".to_owned(),
},
&[
Token::Struct {
name: "String",
len: 2,
},
Token::Str("type"),
Token::Str("String"),
Token::Str("string"),
Token::Bytes(b"\0"),
Token::StructEnd,
],
);
assert_de_tokens(
&InternallyTagged::String {
string: "\0".to_owned(),
},
&[
Token::Struct {
name: "String",
len: 2,
},
Token::Str("type"),
Token::Str("String"),
Token::Str("string"),
Token::ByteBuf(b"\0"),
Token::StructEnd,
],
);
}
#[test]
fn bytes_from_string() {
assert_de_tokens(
&InternallyTagged::Bytes { bytes: vec![0] },
&[
Token::Struct {
name: "Bytes",
len: 2,
},
Token::Str("type"),
Token::Str("Bytes"),
Token::Str("bytes"),
Token::Str("\0"),
Token::StructEnd,
],
);
assert_de_tokens(
&InternallyTagged::Bytes { bytes: vec![0] },
&[
Token::Struct {
name: "Bytes",
len: 2,
},
Token::Str("type"),
Token::Str("Bytes"),
Token::Str("bytes"),
Token::String("\0"),
Token::StructEnd,
],
);
}
#[test]
fn bytes_from_bytes() {
assert_de_tokens(
&InternallyTagged::Bytes { bytes: vec![0] },
&[
Token::Struct {
name: "Bytes",
len: 2,
},
Token::Str("type"),
Token::Str("Bytes"),
Token::Str("bytes"),
Token::Bytes(b"\0"),
Token::StructEnd,
],
);
assert_de_tokens(
&InternallyTagged::Bytes { bytes: vec![0] },
&[
Token::Struct {
name: "Bytes",
len: 2,
},
Token::Str("type"),
Token::Str("Bytes"),
Token::Str("bytes"),
Token::ByteBuf(b"\0"),
Token::StructEnd,
],
);
}
#[test]
fn bytes_from_seq() {
assert_de_tokens(
&InternallyTagged::Bytes { bytes: vec![0] },
&[
Token::Struct {
name: "Bytes",
len: 2,
},
Token::Str("type"),
Token::Str("Bytes"),
Token::Str("bytes"),
Token::Seq { len: Some(1) },
Token::U8(0),
Token::SeqEnd,
Token::StructEnd,
],
);
}
} }
assert_de_tokens( #[test]
&InternallyTagged::String { fn struct_variant_containing_unit_variant() {
string: "\0".to_owned(), #[derive(Debug, PartialEq, Serialize, Deserialize)]
}, pub enum Level {
&[ Info,
Token::Struct { }
name: "String",
len: 2,
},
Token::Str("type"),
Token::Str("String"),
Token::Str("string"),
Token::Str("\0"),
Token::StructEnd,
],
);
assert_de_tokens( #[derive(Debug, PartialEq, Serialize, Deserialize)]
&InternallyTagged::String { #[serde(tag = "action")]
string: "\0".to_owned(), pub enum Message {
}, Log { level: Level },
&[ }
Token::Struct {
name: "String",
len: 2,
},
Token::Str("type"),
Token::Str("String"),
Token::Str("string"),
Token::String("\0"),
Token::StructEnd,
],
);
assert_de_tokens( assert_de_tokens(
&InternallyTagged::String { &Level::Info,
string: "\0".to_owned(), &[
}, Token::Enum { name: "Level" },
&[ Token::BorrowedStr("Info"),
Token::Struct { Token::Unit,
name: "String", ],
len: 2, );
},
Token::Str("type"),
Token::Str("String"),
Token::Str("string"),
Token::Bytes(b"\0"),
Token::StructEnd,
],
);
assert_de_tokens( assert_de_tokens(
&InternallyTagged::String { &Message::Log { level: Level::Info },
string: "\0".to_owned(), &[
}, Token::Struct {
&[ name: "Message",
Token::Struct { len: 2,
name: "String", },
len: 2, Token::Str("action"),
}, Token::Str("Log"),
Token::Str("type"), Token::Str("level"),
Token::Str("String"), Token::Enum { name: "Level" },
Token::Str("string"), Token::BorrowedStr("Info"),
Token::ByteBuf(b"\0"), Token::Unit,
Token::StructEnd, Token::StructEnd,
], ],
); );
assert_de_tokens( assert_de_tokens(
&InternallyTagged::Bytes { bytes: vec![0] }, &Message::Log { level: Level::Info },
&[ &[
Token::Struct { Token::Map { len: Some(2) },
name: "Bytes", Token::Str("action"),
len: 2, Token::Str("Log"),
}, Token::Str("level"),
Token::Str("type"), Token::Enum { name: "Level" },
Token::Str("Bytes"), Token::BorrowedStr("Info"),
Token::Str("bytes"), Token::Unit,
Token::Str("\0"), Token::MapEnd,
Token::StructEnd, ],
], );
);
assert_de_tokens( assert_de_tokens(
&InternallyTagged::Bytes { bytes: vec![0] }, &Message::Log { level: Level::Info },
&[ &[
Token::Struct { Token::Seq { len: Some(2) },
name: "Bytes", Token::Str("Log"),
len: 2, Token::Enum { name: "Level" },
}, Token::BorrowedStr("Info"),
Token::Str("type"), Token::Unit,
Token::Str("Bytes"), Token::SeqEnd,
Token::Str("bytes"), ],
Token::String("\0"), );
Token::StructEnd,
],
);
assert_de_tokens(
&InternallyTagged::Bytes { bytes: vec![0] },
&[
Token::Struct {
name: "Bytes",
len: 2,
},
Token::Str("type"),
Token::Str("Bytes"),
Token::Str("bytes"),
Token::Bytes(b"\0"),
Token::StructEnd,
],
);
assert_de_tokens(
&InternallyTagged::Bytes { bytes: vec![0] },
&[
Token::Struct {
name: "Bytes",
len: 2,
},
Token::Str("type"),
Token::Str("Bytes"),
Token::Str("bytes"),
Token::ByteBuf(b"\0"),
Token::StructEnd,
],
);
assert_de_tokens(
&InternallyTagged::Bytes { bytes: vec![0] },
&[
Token::Struct {
name: "Bytes",
len: 2,
},
Token::Str("type"),
Token::Str("Bytes"),
Token::Str("bytes"),
Token::Seq { len: Some(1) },
Token::U8(0),
Token::SeqEnd,
Token::StructEnd,
],
);
}
#[test]
fn test_internally_tagged_struct_variant_containing_unit_variant() {
#[derive(Debug, PartialEq, Serialize, Deserialize)]
pub enum Level {
Info,
} }
#[derive(Debug, PartialEq, Serialize, Deserialize)] #[test]
#[serde(tag = "action")] fn borrow() {
pub enum Message { #[derive(Debug, PartialEq, Serialize, Deserialize)]
Log { level: Level }, #[serde(tag = "type")]
enum Input<'a> {
Package { name: &'a str },
}
assert_tokens(
&Input::Package { name: "borrowed" },
&[
Token::Struct {
name: "Input",
len: 2,
},
Token::BorrowedStr("type"),
Token::BorrowedStr("Package"),
Token::BorrowedStr("name"),
Token::BorrowedStr("borrowed"),
Token::StructEnd,
],
);
} }
assert_de_tokens( #[test]
&Level::Info, fn newtype_variant_containing_externally_tagged_enum() {
&[ #[derive(Debug, PartialEq, Serialize, Deserialize)]
Token::Enum { name: "Level" }, #[serde(tag = "type")]
Token::BorrowedStr("Info"), enum Outer {
Token::Unit, Inner(Inner),
], }
);
assert_de_tokens( #[derive(Debug, PartialEq, Serialize, Deserialize)]
&Message::Log { level: Level::Info }, enum Inner {
&[ Unit,
Token::Struct { Newtype(u8),
name: "Message", Tuple(u8, u8),
len: 2, Struct { f: u8 },
}, }
Token::Str("action"),
Token::Str("Log"),
Token::Str("level"),
Token::Enum { name: "Level" },
Token::BorrowedStr("Info"),
Token::Unit,
Token::StructEnd,
],
);
assert_de_tokens( assert_tokens(
&Message::Log { level: Level::Info }, &Outer::Inner(Inner::Unit),
&[ &[
Token::Map { len: Some(2) }, Token::Map { len: Some(2) },
Token::Str("action"), Token::Str("type"),
Token::Str("Log"), Token::Str("Inner"),
Token::Str("level"), Token::Str("Unit"),
Token::Enum { name: "Level" }, Token::Unit,
Token::BorrowedStr("Info"), Token::MapEnd,
Token::Unit, ],
Token::MapEnd, );
],
);
assert_de_tokens( assert_tokens(
&Message::Log { level: Level::Info }, &Outer::Inner(Inner::Newtype(1)),
&[ &[
Token::Seq { len: Some(2) }, Token::Map { len: Some(2) },
Token::Str("Log"), Token::Str("type"),
Token::Enum { name: "Level" }, Token::Str("Inner"),
Token::BorrowedStr("Info"), Token::Str("Newtype"),
Token::Unit, Token::U8(1),
Token::SeqEnd, Token::MapEnd,
], ],
); );
}
#[test] // Reaches crate::private::de::content::VariantDeserializer::tuple_variant
fn test_internally_tagged_borrow() { // Content::Seq case
#[derive(Debug, PartialEq, Serialize, Deserialize)] // via ContentDeserializer::deserialize_enum
#[serde(tag = "type")] assert_tokens(
pub enum Input<'a> { &Outer::Inner(Inner::Tuple(1, 1)),
Package { name: &'a str }, &[
Token::Map { len: Some(2) },
Token::Str("type"),
Token::Str("Inner"),
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(
&Outer::Inner(Inner::Struct { f: 1 }),
&[
Token::Map { len: Some(2) },
Token::Str("type"),
Token::Str("Inner"),
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(
&Outer::Inner(Inner::Struct { f: 1 }),
&[
Token::Map { len: Some(2) },
Token::Str("type"),
Token::Str("Inner"),
Token::Str("Struct"),
Token::Seq { len: Some(1) },
Token::U8(1), // f
Token::SeqEnd,
Token::MapEnd,
],
);
} }
assert_tokens( #[test]
&Input::Package { name: "borrowed" }, fn newtype_variant_containing_unit_struct() {
&[ #[derive(Debug, PartialEq, Serialize, Deserialize)]
Token::Struct { struct Info;
name: "Input",
len: 2, #[derive(Debug, PartialEq, Serialize, Deserialize)]
}, #[serde(tag = "topic")]
Token::BorrowedStr("type"), enum Message {
Token::BorrowedStr("Package"), Info(Info),
Token::BorrowedStr("name"), }
Token::BorrowedStr("borrowed"),
Token::StructEnd, assert_tokens(
], &Message::Info(Info),
); &[
Token::Map { len: Some(1) },
Token::Str("topic"),
Token::Str("Info"),
Token::MapEnd,
],
);
assert_de_tokens(
&Message::Info(Info),
&[
Token::Struct {
name: "Message",
len: 1,
},
Token::Str("topic"),
Token::Str("Info"),
Token::StructEnd,
],
);
assert_de_tokens(
&Message::Info(Info),
&[
Token::Seq { len: Some(1) },
Token::Str("Info"),
Token::SeqEnd,
],
);
}
} }
#[test] #[test]
@ -1571,106 +1731,6 @@ fn test_adjacently_tagged_enum_deny_unknown_fields() {
); );
} }
#[test]
fn test_enum_in_internally_tagged_enum() {
#[derive(Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
enum Outer {
Inner(Inner),
}
#[derive(Debug, PartialEq, Serialize, Deserialize)]
enum Inner {
Unit,
Newtype(u8),
Tuple(u8, u8),
Struct { f: u8 },
}
assert_tokens(
&Outer::Inner(Inner::Unit),
&[
Token::Map { len: Some(2) },
Token::Str("type"),
Token::Str("Inner"),
Token::Str("Unit"),
Token::Unit,
Token::MapEnd,
],
);
assert_tokens(
&Outer::Inner(Inner::Newtype(1)),
&[
Token::Map { len: Some(2) },
Token::Str("type"),
Token::Str("Inner"),
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(
&Outer::Inner(Inner::Tuple(1, 1)),
&[
Token::Map { len: Some(2) },
Token::Str("type"),
Token::Str("Inner"),
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(
&Outer::Inner(Inner::Struct { f: 1 }),
&[
Token::Map { len: Some(2) },
Token::Str("type"),
Token::Str("Inner"),
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(
&Outer::Inner(Inner::Struct { f: 1 }),
&[
Token::Map { len: Some(2) },
Token::Str("type"),
Token::Str("Inner"),
Token::Str("Struct"),
Token::Seq { len: Some(1) },
Token::U8(1), // f
Token::SeqEnd,
Token::MapEnd,
],
);
}
#[test] #[test]
fn test_internally_tagged_struct() { fn test_internally_tagged_struct() {
#[derive(Debug, PartialEq, Serialize, Deserialize)] #[derive(Debug, PartialEq, Serialize, Deserialize)]
@ -2205,50 +2265,6 @@ fn test_untagged_newtype_variant_containing_unit_struct_not_map() {
); );
} }
#[test]
fn test_internally_tagged_newtype_variant_containing_unit_struct() {
#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct Info;
#[derive(Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "topic")]
enum Message {
Info(Info),
}
assert_tokens(
&Message::Info(Info),
&[
Token::Map { len: Some(1) },
Token::Str("topic"),
Token::Str("Info"),
Token::MapEnd,
],
);
assert_de_tokens(
&Message::Info(Info),
&[
Token::Struct {
name: "Message",
len: 1,
},
Token::Str("topic"),
Token::Str("Info"),
Token::StructEnd,
],
);
assert_de_tokens(
&Message::Info(Info),
&[
Token::Seq { len: Some(1) },
Token::Str("Info"),
Token::SeqEnd,
],
);
}
#[test] #[test]
fn test_packed_struct_can_derive_serialize() { fn test_packed_struct_can_derive_serialize() {
#[derive(Copy, Clone, Serialize)] #[derive(Copy, Clone, Serialize)]