itsscb/serde
1
0
Fork 0
mirror of https://github.com/serde-rs/serde.git synced 2025-10-02 15:25:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use struct variants in test suite

Browse Source
This commit is contained in:
David Tolnay 2017-04-19 13:06:31 -07:00
parent 4767ca3f5d
commit 15341780a2
No known key found for this signature in database
GPG Key ID: F9BA143B95FF6D82
5 changed files with 243 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
test_suite/tests/test_annotations.rs
View File

@ -102,7 +102,7 @@ fn test_default_struct() {
a5: 123, a5: 123,
}, },
&[ &[
Token::Struct("DefaultStruct", 3), Token::Struct { name: "DefaultStruct", len: 3 },
Token::Str("a1"), Token::Str("a1"),
Token::I32(1), Token::I32(1),
@ -132,7 +132,7 @@ fn test_default_struct() {
a5: 123, a5: 123,
}, },
&[ &[
Token::Struct("DefaultStruct", 1), Token::Struct { name: "DefaultStruct", len: 1 },
Token::Str("a1"), Token::Str("a1"),
Token::I32(1), Token::I32(1),
@ -172,7 +172,7 @@ fn test_default_enum() {
a5: 123, a5: 123,
}, },
&[ &[
Token::StructVariant("DefaultEnum", "Struct", 3), Token::StructVariant { name: "DefaultEnum", variant: "Struct", len: 3 },
Token::Str("a1"), Token::Str("a1"),
Token::I32(1), Token::I32(1),
@ -202,7 +202,7 @@ fn test_default_enum() {
a5: 123, a5: 123,
}, },
&[ &[
Token::StructVariant("DefaultEnum", "Struct", 3), Token::StructVariant { name: "DefaultEnum", variant: "Struct", len: 3 },
Token::Str("a1"), Token::Str("a1"),
Token::I32(1), Token::I32(1),
@ -234,16 +234,16 @@ struct ContainsNoStdDefault<A: MyDefault> {
fn test_no_std_default() { fn test_no_std_default() {
assert_de_tokens( assert_de_tokens(
&ContainsNoStdDefault { a: NoStdDefault(123) }, &ContainsNoStdDefault { a: NoStdDefault(123) },
&[Token::Struct("ContainsNoStdDefault", 1), Token::StructEnd], &[Token::Struct { name: "ContainsNoStdDefault", len: 1 }, Token::StructEnd],
); );
assert_de_tokens( assert_de_tokens(
&ContainsNoStdDefault { a: NoStdDefault(8) }, &ContainsNoStdDefault { a: NoStdDefault(8) },
&[ &[
Token::Struct("ContainsNoStdDefault", 1), Token::Struct { name: "ContainsNoStdDefault", len: 1 },
Token::Str("a"), Token::Str("a"),
Token::NewtypeStruct("NoStdDefault"), Token::NewtypeStruct { name: "NoStdDefault" },
Token::I8(8), Token::I8(8),
Token::StructEnd, Token::StructEnd,
@ -306,7 +306,7 @@ fn test_elt_not_deserialize() {
c: NotDeserializeStruct(123), c: NotDeserializeStruct(123),
e: NotDeserializeEnum::Trouble, e: NotDeserializeEnum::Trouble,
}, },
&[Token::Struct("ContainsNotDeserialize", 3), Token::StructEnd], &[Token::Struct { name: "ContainsNotDeserialize", len: 3 }, Token::StructEnd],
); );
} }
@ -328,7 +328,7 @@ fn test_ignore_unknown() {
a5: 123, a5: 123,
}, },
&[ &[
Token::Struct("DefaultStruct", 5), Token::Struct { name: "DefaultStruct", len: 5 },
Token::Str("whoops1"), Token::Str("whoops1"),
Token::I32(2), Token::I32(2),
@ -337,7 +337,7 @@ fn test_ignore_unknown() {
Token::I32(1), Token::I32(1),
Token::Str("whoops2"), Token::Str("whoops2"),
Token::Seq(Some(1)), Token::Seq { len: Some(1) },
Token::I32(2), Token::I32(2),
Token::SeqEnd, Token::SeqEnd,
@ -356,7 +356,7 @@ fn test_ignore_unknown() {
assert_de_tokens_error::<DenyUnknown>( assert_de_tokens_error::<DenyUnknown>(
&[ &[
Token::Struct("DenyUnknown", 2), Token::Struct { name: "DenyUnknown", len: 2 },
Token::Str("a1"), Token::Str("a1"),
Token::I32(1), Token::I32(1),
@ -388,7 +388,7 @@ fn test_rename_struct() {
assert_tokens( assert_tokens(
&RenameStruct { a1: 1, a2: 2 }, &RenameStruct { a1: 1, a2: 2 },
&[ &[
Token::Struct("Superhero", 2), Token::Struct { name: "Superhero", len: 2 },
Token::Str("a1"), Token::Str("a1"),
Token::I32(1), Token::I32(1),
@ -403,7 +403,7 @@ fn test_rename_struct() {
assert_ser_tokens( assert_ser_tokens(
&RenameStructSerializeDeserialize { a1: 1, a2: 2 }, &RenameStructSerializeDeserialize { a1: 1, a2: 2 },
&[ &[
Token::Struct("SuperheroSer", 2), Token::Struct { name: "SuperheroSer", len: 2 },
Token::Str("a1"), Token::Str("a1"),
Token::I32(1), Token::I32(1),
@ -418,7 +418,7 @@ fn test_rename_struct() {
assert_de_tokens( assert_de_tokens(
&RenameStructSerializeDeserialize { a1: 1, a2: 2 }, &RenameStructSerializeDeserialize { a1: 1, a2: 2 },
&[ &[
Token::Struct("SuperheroDe", 2), Token::Struct { name: "SuperheroDe", len: 2 },
Token::Str("a1"), Token::Str("a1"),
Token::I32(1), Token::I32(1),
@ -463,13 +463,13 @@ enum RenameEnumSerializeDeserialize<A> {
fn test_rename_enum() { fn test_rename_enum() {
assert_tokens( assert_tokens(
&RenameEnum::Batman, &RenameEnum::Batman,
&[Token::UnitVariant("Superhero", "bruce_wayne")], &[Token::UnitVariant { name: "Superhero", variant: "bruce_wayne" }],
); );
assert_tokens( assert_tokens(
&RenameEnum::Superman(0), &RenameEnum::Superman(0),
&[ &[
Token::NewtypeVariant("Superhero", "clark_kent"), Token::NewtypeVariant { name: "Superhero", variant: "clark_kent" },
Token::I8(0), Token::I8(0),
], ],
); );
@ -477,7 +477,7 @@ fn test_rename_enum() {
assert_tokens( assert_tokens(
&RenameEnum::WonderWoman(0, 1), &RenameEnum::WonderWoman(0, 1),
&[ &[
Token::TupleVariant("Superhero", "diana_prince", 2), Token::TupleVariant { name: "Superhero", variant: "diana_prince", len: 2 },
Token::I8(0), Token::I8(0),
Token::I8(1), Token::I8(1),
Token::TupleVariantEnd, Token::TupleVariantEnd,
@ -487,7 +487,7 @@ fn test_rename_enum() {
assert_tokens( assert_tokens(
&RenameEnum::Flash { a: 1 }, &RenameEnum::Flash { a: 1 },
&[ &[
Token::StructVariant("Superhero", "barry_allan", 1), Token::StructVariant { name: "Superhero", variant: "barry_allan", len: 1 },
Token::Str("b"), Token::Str("b"),
Token::I32(1), Token::I32(1),
@ -502,7 +502,7 @@ fn test_rename_enum() {
b: String::new(), b: String::new(),
}, },
&[ &[
Token::StructVariant("SuperheroSer", "dick_grayson", 2), Token::StructVariant { name: "SuperheroSer", variant: "dick_grayson", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I8(0), Token::I8(0),
@ -520,7 +520,7 @@ fn test_rename_enum() {
b: String::new(), b: String::new(),
}, },
&[ &[
Token::StructVariant("SuperheroDe", "jason_todd", 2), Token::StructVariant { name: "SuperheroDe", variant: "jason_todd", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I8(0), Token::I8(0),
@ -551,7 +551,7 @@ fn test_skip_serializing_struct() {
assert_ser_tokens( assert_ser_tokens(
&SkipSerializingStruct { a: &a, b: 2, c: 3 }, &SkipSerializingStruct { a: &a, b: 2, c: 3 },
&[ &[
Token::Struct("SkipSerializingStruct", 2), Token::Struct { name: "SkipSerializingStruct", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -570,7 +570,7 @@ fn test_skip_serializing_struct() {
c: 123, c: 123,
}, },
&[ &[
Token::Struct("SkipSerializingStruct", 1), Token::Struct { name: "SkipSerializingStruct", len: 1 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -600,7 +600,7 @@ fn test_skip_serializing_enum() {
assert_ser_tokens( assert_ser_tokens(
&SkipSerializingEnum::Struct { a: &a, _b: 2, c: 3 }, &SkipSerializingEnum::Struct { a: &a, _b: 2, c: 3 },
&[ &[
Token::StructVariant("SkipSerializingEnum", "Struct", 2), Token::StructVariant { name: "SkipSerializingEnum", variant: "Struct", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -619,7 +619,7 @@ fn test_skip_serializing_enum() {
c: 123, c: 123,
}, },
&[ &[
Token::StructVariant("SkipSerializingEnum", "Struct", 1), Token::StructVariant { name: "SkipSerializingEnum", variant: "Struct", len: 1 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -672,7 +672,7 @@ fn test_elt_not_serialize() {
d: NotSerializeEnum::Trouble, d: NotSerializeEnum::Trouble,
}, },
&[ &[
Token::Struct("ContainsNotSerialize", 2), Token::Struct { name: "ContainsNotSerialize", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::Some, Token::Some,
@ -702,7 +702,7 @@ fn test_serialize_with_struct() {
assert_ser_tokens( assert_ser_tokens(
&SerializeWithStruct { a: &a, b: 2 }, &SerializeWithStruct { a: &a, b: 2 },
&[ &[
Token::Struct("SerializeWithStruct", 2), Token::Struct { name: "SerializeWithStruct", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -717,7 +717,7 @@ fn test_serialize_with_struct() {
assert_ser_tokens( assert_ser_tokens(
&SerializeWithStruct { a: &a, b: 123 }, &SerializeWithStruct { a: &a, b: 123 },
&[ &[
Token::Struct("SerializeWithStruct", 2), Token::Struct { name: "SerializeWithStruct", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -748,7 +748,7 @@ fn test_serialize_with_enum() {
assert_ser_tokens( assert_ser_tokens(
&SerializeWithEnum::Struct { a: &a, b: 2 }, &SerializeWithEnum::Struct { a: &a, b: 2 },
&[ &[
Token::StructVariant("SerializeWithEnum", "Struct", 2), Token::StructVariant { name: "SerializeWithEnum", variant: "Struct", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -763,7 +763,7 @@ fn test_serialize_with_enum() {
assert_ser_tokens( assert_ser_tokens(
&SerializeWithEnum::Struct { a: &a, b: 123 }, &SerializeWithEnum::Struct { a: &a, b: 123 },
&[ &[
Token::StructVariant("SerializeWithEnum", "Struct", 2), Token::StructVariant { name: "SerializeWithEnum", variant: "Struct", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -791,7 +791,7 @@ fn test_deserialize_with_struct() {
assert_de_tokens( assert_de_tokens(
&DeserializeWithStruct { a: 1, b: 2 }, &DeserializeWithStruct { a: 1, b: 2 },
&[ &[
Token::Struct("DeserializeWithStruct", 2), Token::Struct { name: "DeserializeWithStruct", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -806,7 +806,7 @@ fn test_deserialize_with_struct() {
assert_de_tokens( assert_de_tokens(
&DeserializeWithStruct { a: 1, b: 123 }, &DeserializeWithStruct { a: 1, b: 123 },
&[ &[
Token::Struct("DeserializeWithStruct", 2), Token::Struct { name: "DeserializeWithStruct", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -836,7 +836,7 @@ fn test_deserialize_with_enum() {
assert_de_tokens( assert_de_tokens(
&DeserializeWithEnum::Struct { a: 1, b: 2 }, &DeserializeWithEnum::Struct { a: 1, b: 2 },
&[ &[
Token::StructVariant("DeserializeWithEnum", "Struct", 2), Token::StructVariant { name: "DeserializeWithEnum", variant: "Struct", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -851,7 +851,7 @@ fn test_deserialize_with_enum() {
assert_de_tokens( assert_de_tokens(
&DeserializeWithEnum::Struct { a: 1, b: 123 }, &DeserializeWithEnum::Struct { a: 1, b: 123 },
&[ &[
Token::StructVariant("DeserializeWithEnum", "Struct", 2), Token::StructVariant { name: "DeserializeWithEnum", variant: "Struct", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -868,7 +868,7 @@ fn test_deserialize_with_enum() {
fn test_missing_renamed_field_struct() { fn test_missing_renamed_field_struct() {
assert_de_tokens_error::<RenameStruct>( assert_de_tokens_error::<RenameStruct>(
&[ &[
Token::Struct("Superhero", 2), Token::Struct { name: "Superhero", len: 2 },
Token::Str("a1"), Token::Str("a1"),
Token::I32(1), Token::I32(1),
@ -880,7 +880,7 @@ fn test_missing_renamed_field_struct() {
assert_de_tokens_error::<RenameStructSerializeDeserialize>( assert_de_tokens_error::<RenameStructSerializeDeserialize>(
&[ &[
Token::Struct("SuperheroDe", 2), Token::Struct { name: "SuperheroDe", len: 2 },
Token::Str("a1"), Token::Str("a1"),
Token::I32(1), Token::I32(1),
@ -895,7 +895,7 @@ fn test_missing_renamed_field_struct() {
fn test_missing_renamed_field_enum() { fn test_missing_renamed_field_enum() {
assert_de_tokens_error::<RenameEnum>( assert_de_tokens_error::<RenameEnum>(
&[ &[
Token::StructVariant("Superhero", "barry_allan", 1), Token::StructVariant { name: "Superhero", variant: "barry_allan", len: 1 },
Token::StructVariantEnd, Token::StructVariantEnd,
], ],
@ -904,7 +904,7 @@ fn test_missing_renamed_field_enum() {
assert_de_tokens_error::<RenameEnumSerializeDeserialize<i8>>( assert_de_tokens_error::<RenameEnumSerializeDeserialize<i8>>(
&[ &[
Token::StructVariant("SuperheroDe", "jason_todd", 2), Token::StructVariant { name: "SuperheroDe", variant: "jason_todd", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I8(0), Token::I8(0),
@ -930,7 +930,7 @@ enum InvalidLengthEnum {
fn test_invalid_length_enum() { fn test_invalid_length_enum() {
assert_de_tokens_error::<InvalidLengthEnum>( assert_de_tokens_error::<InvalidLengthEnum>(
&[ &[
Token::TupleVariant("InvalidLengthEnum", "A", 3), Token::TupleVariant { name: "InvalidLengthEnum", variant: "A", len: 3 },
Token::I32(1), Token::I32(1),
Token::TupleVariantEnd, Token::TupleVariantEnd,
], ],
@ -938,7 +938,7 @@ fn test_invalid_length_enum() {
); );
assert_de_tokens_error::<InvalidLengthEnum>( assert_de_tokens_error::<InvalidLengthEnum>(
&[ &[
Token::TupleVariant("InvalidLengthEnum", "B", 3), Token::TupleVariant { name: "InvalidLengthEnum", variant: "B", len: 3 },
Token::I32(1), Token::I32(1),
Token::TupleVariantEnd, Token::TupleVariantEnd,
], ],

6
test_suite/tests/test_borrow.rs
View File

@ -69,7 +69,7 @@ fn test_tuple() {
assert_de_tokens( assert_de_tokens(
&("str", &b"bytes"[..]), &("str", &b"bytes"[..]),
&[ &[
Token::Tuple(2), Token::Tuple { len: 2 },
Token::BorrowedStr("str"), Token::BorrowedStr("str"),
Token::BorrowedBytes(b"bytes"), Token::BorrowedBytes(b"bytes"),
Token::TupleEnd, Token::TupleEnd,
@ -91,7 +91,7 @@ fn test_struct() {
bb: b"bytes", bb: b"bytes",
}, },
&[ &[
Token::Struct("Borrowing", 2), Token::Struct { name: "Borrowing", len: 2 },
Token::BorrowedStr("bs"), Token::BorrowedStr("bs"),
Token::BorrowedStr("str"), Token::BorrowedStr("str"),
@ -115,7 +115,7 @@ fn test_cow() {
} }
let tokens = &[ let tokens = &[
Token::Struct("Cows", 2), Token::Struct { name: "Cows", len: 2 },
Token::Str("copied"), Token::Str("copied"),
Token::BorrowedStr("copied"), Token::BorrowedStr("copied"),

202
test_suite/tests/test_de.rs
View File

@ -152,7 +152,7 @@ fn assert_de_tokens_ignore(ignorable_tokens: &[Token]) {
// Embed the tokens to be ignored in the normal token // Embed the tokens to be ignored in the normal token
// stream for an IgnoreBase type // stream for an IgnoreBase type
let concated_tokens: Vec<Token> = vec![ let concated_tokens: Vec<Token> = vec![
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::Str("a"), Token::Str("a"),
Token::I32(1), Token::I32(1),
@ -221,12 +221,12 @@ declare_tests! {
} }
test_result { test_result {
Ok::<i32, i32>(0) => &[ Ok::<i32, i32>(0) => &[
Token::Enum("Result"), Token::Enum { name: "Result" },
Token::Str("Ok"), Token::Str("Ok"),
Token::I32(0), Token::I32(0),
], ],
Err::<i32, i32>(1) => &[ Err::<i32, i32>(1) => &[
Token::Enum("Result"), Token::Enum { name: "Result" },
Token::Str("Err"), Token::Str("Err"),
Token::I32(1), Token::I32(1),
], ],
@ -237,39 +237,39 @@ declare_tests! {
test_unit_struct { test_unit_struct {
UnitStruct => &[Token::Unit], UnitStruct => &[Token::Unit],
UnitStruct => &[ UnitStruct => &[
Token::UnitStruct("UnitStruct"), Token::UnitStruct { name: "UnitStruct" },
], ],
} }
test_newtype_struct { test_newtype_struct {
NewtypeStruct(1) => &[ NewtypeStruct(1) => &[
Token::NewtypeStruct("NewtypeStruct"), Token::NewtypeStruct { name: "NewtypeStruct" },
Token::I32(1), Token::I32(1),
], ],
} }
test_tuple_struct { test_tuple_struct {
TupleStruct(1, 2, 3) => &[ TupleStruct(1, 2, 3) => &[
Token::Seq(Some(3)), Token::Seq { len: Some(3) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
Token::SeqEnd, Token::SeqEnd,
], ],
TupleStruct(1, 2, 3) => &[ TupleStruct(1, 2, 3) => &[
Token::Seq(None), Token::Seq { len: None },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
Token::SeqEnd, Token::SeqEnd,
], ],
TupleStruct(1, 2, 3) => &[ TupleStruct(1, 2, 3) => &[
Token::TupleStruct("TupleStruct", 3), Token::TupleStruct { name: "TupleStruct", len: 3 },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
Token::TupleStructEnd, Token::TupleStructEnd,
], ],
TupleStruct(1, 2, 3) => &[ TupleStruct(1, 2, 3) => &[
Token::TupleStruct("TupleStruct", 3), Token::TupleStruct { name: "TupleStruct", len: 3 },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
@ -278,47 +278,47 @@ declare_tests! {
} }
test_btreeset { test_btreeset {
BTreeSet::<isize>::new() => &[ BTreeSet::<isize>::new() => &[
Token::Seq(Some(0)), Token::Seq { len: Some(0) },
Token::SeqEnd, Token::SeqEnd,
], ],
btreeset![btreeset![], btreeset![1], btreeset![2, 3]] => &[ btreeset![btreeset![], btreeset![1], btreeset![2, 3]] => &[
Token::Seq(Some(3)), Token::Seq { len: Some(3) },
Token::Seq(Some(0)), Token::Seq { len: Some(0) },
Token::SeqEnd, Token::SeqEnd,
Token::Seq(Some(1)), Token::Seq { len: Some(1) },
Token::I32(1), Token::I32(1),
Token::SeqEnd, Token::SeqEnd,
Token::Seq(Some(2)), Token::Seq { len: Some(2) },
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
Token::SeqEnd, Token::SeqEnd,
Token::SeqEnd, Token::SeqEnd,
], ],
BTreeSet::<isize>::new() => &[ BTreeSet::<isize>::new() => &[
Token::TupleStruct("Anything", 0), Token::TupleStruct { name: "Anything", len: 0 },
Token::TupleStructEnd, Token::TupleStructEnd,
], ],
} }
test_hashset { test_hashset {
HashSet::<isize>::new() => &[ HashSet::<isize>::new() => &[
Token::Seq(Some(0)), Token::Seq { len: Some(0) },
Token::SeqEnd, Token::SeqEnd,
], ],
hashset![1, 2, 3] => &[ hashset![1, 2, 3] => &[
Token::Seq(Some(3)), Token::Seq { len: Some(3) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
Token::SeqEnd, Token::SeqEnd,
], ],
HashSet::<isize>::new() => &[ HashSet::<isize>::new() => &[
Token::TupleStruct("Anything", 0), Token::TupleStruct { name: "Anything", len: 0 },
Token::TupleStructEnd, Token::TupleStructEnd,
], ],
hashset![FnvHasher @ 1, 2, 3] => &[ hashset![FnvHasher @ 1, 2, 3] => &[
Token::Seq(Some(3)), Token::Seq { len: Some(3) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
@ -327,93 +327,93 @@ declare_tests! {
} }
test_vec { test_vec {
Vec::<isize>::new() => &[ Vec::<isize>::new() => &[
Token::Seq(Some(0)), Token::Seq { len: Some(0) },
Token::SeqEnd, Token::SeqEnd,
], ],
vec![vec![], vec![1], vec![2, 3]] => &[ vec![vec![], vec![1], vec![2, 3]] => &[
Token::Seq(Some(3)), Token::Seq { len: Some(3) },
Token::Seq(Some(0)), Token::Seq { len: Some(0) },
Token::SeqEnd, Token::SeqEnd,
Token::Seq(Some(1)), Token::Seq { len: Some(1) },
Token::I32(1), Token::I32(1),
Token::SeqEnd, Token::SeqEnd,
Token::Seq(Some(2)), Token::Seq { len: Some(2) },
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
Token::SeqEnd, Token::SeqEnd,
Token::SeqEnd, Token::SeqEnd,
], ],
Vec::<isize>::new() => &[ Vec::<isize>::new() => &[
Token::TupleStruct("Anything", 0), Token::TupleStruct { name: "Anything", len: 0 },
Token::TupleStructEnd, Token::TupleStructEnd,
], ],
} }
test_array { test_array {
[0; 0] => &[ [0; 0] => &[
Token::Seq(Some(0)), Token::Seq { len: Some(0) },
Token::SeqEnd, Token::SeqEnd,
], ],
[0; 0] => &[ [0; 0] => &[
Token::Tuple(0), Token::Tuple { len: 0 },
Token::TupleEnd, Token::TupleEnd,
], ],
([0; 0], [1], [2, 3]) => &[ ([0; 0], [1], [2, 3]) => &[
Token::Seq(Some(3)), Token::Seq { len: Some(3) },
Token::Seq(Some(0)), Token::Seq { len: Some(0) },
Token::SeqEnd, Token::SeqEnd,
Token::Seq(Some(1)), Token::Seq { len: Some(1) },
Token::I32(1), Token::I32(1),
Token::SeqEnd, Token::SeqEnd,
Token::Seq(Some(2)), Token::Seq { len: Some(2) },
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
Token::SeqEnd, Token::SeqEnd,
Token::SeqEnd, Token::SeqEnd,
], ],
([0; 0], [1], [2, 3]) => &[ ([0; 0], [1], [2, 3]) => &[
Token::Tuple(3), Token::Tuple { len: 3 },
Token::Tuple(0), Token::Tuple { len: 0 },
Token::TupleEnd, Token::TupleEnd,
Token::Tuple(1), Token::Tuple { len: 1 },
Token::I32(1), Token::I32(1),
Token::TupleEnd, Token::TupleEnd,
Token::Tuple(2), Token::Tuple { len: 2 },
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
Token::TupleEnd, Token::TupleEnd,
Token::TupleEnd, Token::TupleEnd,
], ],
[0; 0] => &[ [0; 0] => &[
Token::TupleStruct("Anything", 0), Token::TupleStruct { name: "Anything", len: 0 },
Token::TupleStructEnd, Token::TupleStructEnd,
], ],
} }
test_tuple { test_tuple {
(1,) => &[ (1,) => &[
Token::Seq(Some(1)), Token::Seq { len: Some(1) },
Token::I32(1), Token::I32(1),
Token::SeqEnd, Token::SeqEnd,
], ],
(1, 2, 3) => &[ (1, 2, 3) => &[
Token::Seq(Some(3)), Token::Seq { len: Some(3) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
Token::SeqEnd, Token::SeqEnd,
], ],
(1,) => &[ (1,) => &[
Token::Tuple(1), Token::Tuple { len: 1 },
Token::I32(1), Token::I32(1),
Token::TupleEnd, Token::TupleEnd,
], ],
(1, 2, 3) => &[ (1, 2, 3) => &[
Token::Tuple(3), Token::Tuple { len: 3 },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
@ -422,17 +422,17 @@ declare_tests! {
} }
test_btreemap { test_btreemap {
BTreeMap::<isize, isize>::new() => &[ BTreeMap::<isize, isize>::new() => &[
Token::Map(Some(0)), Token::Map { len: Some(0) },
Token::MapEnd, Token::MapEnd,
], ],
btreemap![1 => 2] => &[ btreemap![1 => 2] => &[
Token::Map(Some(1)), Token::Map { len: Some(1) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::MapEnd, Token::MapEnd,
], ],
btreemap![1 => 2, 3 => 4] => &[ btreemap![1 => 2, 3 => 4] => &[
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
@ -441,13 +441,13 @@ declare_tests! {
Token::MapEnd, Token::MapEnd,
], ],
btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => &[ btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => &[
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::I32(1), Token::I32(1),
Token::Map(Some(0)), Token::Map { len: Some(0) },
Token::MapEnd, Token::MapEnd,
Token::I32(2), Token::I32(2),
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::I32(3), Token::I32(3),
Token::I32(4), Token::I32(4),
@ -457,23 +457,23 @@ declare_tests! {
Token::MapEnd, Token::MapEnd,
], ],
BTreeMap::<isize, isize>::new() => &[ BTreeMap::<isize, isize>::new() => &[
Token::Struct("Anything", 0), Token::Struct { name: "Anything", len: 0 },
Token::StructEnd, Token::StructEnd,
], ],
} }
test_hashmap { test_hashmap {
HashMap::<isize, isize>::new() => &[ HashMap::<isize, isize>::new() => &[
Token::Map(Some(0)), Token::Map { len: Some(0) },
Token::MapEnd, Token::MapEnd,
], ],
hashmap![1 => 2] => &[ hashmap![1 => 2] => &[
Token::Map(Some(1)), Token::Map { len: Some(1) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::MapEnd, Token::MapEnd,
], ],
hashmap![1 => 2, 3 => 4] => &[ hashmap![1 => 2, 3 => 4] => &[
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
@ -482,13 +482,13 @@ declare_tests! {
Token::MapEnd, Token::MapEnd,
], ],
hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]] => &[ hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]] => &[
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::I32(1), Token::I32(1),
Token::Map(Some(0)), Token::Map { len: Some(0) },
Token::MapEnd, Token::MapEnd,
Token::I32(2), Token::I32(2),
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::I32(3), Token::I32(3),
Token::I32(4), Token::I32(4),
@ -498,11 +498,11 @@ declare_tests! {
Token::MapEnd, Token::MapEnd,
], ],
HashMap::<isize, isize>::new() => &[ HashMap::<isize, isize>::new() => &[
Token::Struct("Anything", 0), Token::Struct { name: "Anything", len: 0 },
Token::StructEnd, Token::StructEnd,
], ],
hashmap![FnvHasher @ 1 => 2, 3 => 4] => &[ hashmap![FnvHasher @ 1 => 2, 3 => 4] => &[
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
@ -513,7 +513,7 @@ declare_tests! {
} }
test_struct { test_struct {
Struct { a: 1, b: 2, c: 0 } => &[ Struct { a: 1, b: 2, c: 0 } => &[
Token::Map(Some(3)), Token::Map { len: Some(3) },
Token::Str("a"), Token::Str("a"),
Token::I32(1), Token::I32(1),
@ -522,7 +522,7 @@ declare_tests! {
Token::MapEnd, Token::MapEnd,
], ],
Struct { a: 1, b: 2, c: 0 } => &[ Struct { a: 1, b: 2, c: 0 } => &[
Token::Struct("Struct", 3), Token::Struct { name: "Struct", len: 3 },
Token::Str("a"), Token::Str("a"),
Token::I32(1), Token::I32(1),
@ -531,7 +531,7 @@ declare_tests! {
Token::StructEnd, Token::StructEnd,
], ],
Struct { a: 1, b: 2, c: 0 } => &[ Struct { a: 1, b: 2, c: 0 } => &[
Token::Seq(Some(3)), Token::Seq { len: Some(3) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::SeqEnd, Token::SeqEnd,
@ -539,7 +539,7 @@ declare_tests! {
} }
test_struct_with_skip { test_struct_with_skip {
Struct { a: 1, b: 2, c: 0 } => &[ Struct { a: 1, b: 2, c: 0 } => &[
Token::Map(Some(3)), Token::Map { len: Some(3) },
Token::Str("a"), Token::Str("a"),
Token::I32(1), Token::I32(1),
@ -554,7 +554,7 @@ declare_tests! {
Token::MapEnd, Token::MapEnd,
], ],
Struct { a: 1, b: 2, c: 0 } => &[ Struct { a: 1, b: 2, c: 0 } => &[
Token::Struct("Struct", 3), Token::Struct { name: "Struct", len: 3 },
Token::Str("a"), Token::Str("a"),
Token::I32(1), Token::I32(1),
@ -571,11 +571,11 @@ declare_tests! {
} }
test_struct_skip_all { test_struct_skip_all {
StructSkipAll { a: 0 } => &[ StructSkipAll { a: 0 } => &[
Token::Struct("StructSkipAll", 0), Token::Struct { name: "StructSkipAll", len: 0 },
Token::StructEnd, Token::StructEnd,
], ],
StructSkipAll { a: 0 } => &[ StructSkipAll { a: 0 } => &[
Token::Struct("StructSkipAll", 1), Token::Struct { name: "StructSkipAll", len: 1 },
Token::Str("a"), Token::Str("a"),
Token::I32(1), Token::I32(1),
@ -586,13 +586,13 @@ declare_tests! {
} }
test_struct_skip_all_deny_unknown { test_struct_skip_all_deny_unknown {
StructSkipAllDenyUnknown { a: 0 } => &[ StructSkipAllDenyUnknown { a: 0 } => &[
Token::Struct("StructSkipAllDenyUnknown", 0), Token::Struct { name: "StructSkipAllDenyUnknown", len: 0 },
Token::StructEnd, Token::StructEnd,
], ],
} }
test_struct_default { test_struct_default {
StructDefault { a: 50, b: "overwritten".to_string() } => &[ StructDefault { a: 50, b: "overwritten".to_string() } => &[
Token::Struct("StructDefault", 1), Token::Struct { name: "StructDefault", len: 1 },
Token::Str("a"), Token::Str("a"),
Token::I32(50), Token::I32(50),
@ -601,24 +601,24 @@ declare_tests! {
Token::StructEnd, Token::StructEnd,
], ],
StructDefault { a: 100, b: "default".to_string() } => &[ StructDefault { a: 100, b: "default".to_string() } => &[
Token::Struct("StructDefault", 0), Token::Struct { name: "StructDefault", len: 0 },
Token::StructEnd, Token::StructEnd,
], ],
} }
test_enum_unit { test_enum_unit {
Enum::Unit => &[ Enum::Unit => &[
Token::UnitVariant("Enum", "Unit"), Token::UnitVariant { name: "Enum", variant: "Unit" },
], ],
} }
test_enum_simple { test_enum_simple {
Enum::Simple(1) => &[ Enum::Simple(1) => &[
Token::NewtypeVariant("Enum", "Simple"), Token::NewtypeVariant { name: "Enum", variant: "Simple" },
Token::I32(1), Token::I32(1),
], ],
} }
test_enum_seq { test_enum_seq {
Enum::Seq(1, 2, 3) => &[ Enum::Seq(1, 2, 3) => &[
Token::TupleVariant("Enum", "Seq", 3), Token::TupleVariant { name: "Enum", variant: "Seq", len: 3 },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
@ -627,7 +627,7 @@ declare_tests! {
} }
test_enum_map { test_enum_map {
Enum::Map { a: 1, b: 2, c: 3 } => &[ Enum::Map { a: 1, b: 2, c: 3 } => &[
Token::StructVariant("Enum", "Map", 3), Token::StructVariant { name: "Enum", variant: "Map", len: 3 },
Token::Str("a"), Token::Str("a"),
Token::I32(1), Token::I32(1),
@ -641,14 +641,14 @@ declare_tests! {
} }
test_enum_unit_usize { test_enum_unit_usize {
Enum::Unit => &[ Enum::Unit => &[
Token::Enum("Enum"), Token::Enum { name: "Enum" },
Token::U32(0), Token::U32(0),
Token::Unit, Token::Unit,
], ],
} }
test_enum_unit_bytes { test_enum_unit_bytes {
Enum::Unit => &[ Enum::Unit => &[
Token::Enum("Enum"), Token::Enum { name: "Enum" },
Token::Bytes(b"Unit"), Token::Bytes(b"Unit"),
Token::Unit, Token::Unit,
], ],
@ -658,7 +658,7 @@ declare_tests! {
} }
test_boxed_slice { test_boxed_slice {
Box::new([0, 1, 2]) => &[ Box::new([0, 1, 2]) => &[
Token::Seq(Some(3)), Token::Seq { len: Some(3) },
Token::I32(0), Token::I32(0),
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
@ -667,7 +667,7 @@ declare_tests! {
} }
test_duration { test_duration {
Duration::new(1, 2) => &[ Duration::new(1, 2) => &[
Token::Struct("Duration", 2), Token::Struct { name: "Duration", len: 2 },
Token::Str("secs"), Token::Str("secs"),
Token::U64(1), Token::U64(1),
@ -676,7 +676,7 @@ declare_tests! {
Token::StructEnd, Token::StructEnd,
], ],
Duration::new(1, 2) => &[ Duration::new(1, 2) => &[
Token::Seq(Some(2)), Token::Seq { len: Some(2) },
Token::I64(1), Token::I64(1),
Token::I64(2), Token::I64(2),
Token::SeqEnd, Token::SeqEnd,
@ -684,7 +684,7 @@ declare_tests! {
} }
test_range { test_range {
1u32..2u32 => &[ 1u32..2u32 => &[
Token::Struct("Range", 2), Token::Struct { name: "Range", len: 2 },
Token::Str("start"), Token::Str("start"),
Token::U32(1), Token::U32(1),
@ -693,7 +693,7 @@ declare_tests! {
Token::StructEnd, Token::StructEnd,
], ],
1u32..2u32 => &[ 1u32..2u32 => &[
Token::Seq(Some(2)), Token::Seq { len: Some(2) },
Token::U64(1), Token::U64(1),
Token::U64(2), Token::U64(2),
Token::SeqEnd, Token::SeqEnd,
@ -729,9 +729,9 @@ fn test_osstring() {
let value = OsString::from_vec(vec![1, 2, 3]); let value = OsString::from_vec(vec![1, 2, 3]);
let tokens = [ let tokens = [
Token::Enum("OsString"), Token::Enum { name: "OsString" },
Token::Str("Unix"), Token::Str("Unix"),
Token::Seq(Some(2)), Token::Seq { len: Some(2) },
Token::U8(1), Token::U8(1),
Token::U8(2), Token::U8(2),
Token::U8(3), Token::U8(3),
@ -749,9 +749,9 @@ fn test_osstring() {
let value = OsString::from_wide(&[1, 2, 3]); let value = OsString::from_wide(&[1, 2, 3]);
let tokens = [ let tokens = [
Token::Enum("OsString"), Token::Enum { name: "OsString" },
Token::Str("Windows"), Token::Str("Windows"),
Token::Seq(Some(2)), Token::Seq { len: Some(2) },
Token::U16(1), Token::U16(1),
Token::U16(2), Token::U16(2),
Token::U16(3), Token::U16(3),
@ -801,7 +801,7 @@ fn test_cstr_internal_null_end() {
declare_error_tests! { declare_error_tests! {
test_unknown_field<StructDenyUnknown> { test_unknown_field<StructDenyUnknown> {
&[ &[
Token::Struct("StructDenyUnknown", 2), Token::Struct { name: "StructDenyUnknown", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I32(0), Token::I32(0),
@ -811,39 +811,39 @@ declare_error_tests! {
} }
test_skipped_field_is_unknown<StructDenyUnknown> { test_skipped_field_is_unknown<StructDenyUnknown> {
&[ &[
Token::Struct("StructDenyUnknown", 2), Token::Struct { name: "StructDenyUnknown", len: 2 },
Token::Str("b"), Token::Str("b"),
], ],
"unknown field `b`, expected `a`", "unknown field `b`, expected `a`",
} }
test_skip_all_deny_unknown<StructSkipAllDenyUnknown> { test_skip_all_deny_unknown<StructSkipAllDenyUnknown> {
&[ &[
Token::Struct("StructSkipAllDenyUnknown", 1), Token::Struct { name: "StructSkipAllDenyUnknown", len: 1 },
Token::Str("a"), Token::Str("a"),
], ],
"unknown field `a`, there are no fields", "unknown field `a`, there are no fields",
} }
test_unknown_variant<Enum> { test_unknown_variant<Enum> {
&[ &[
Token::UnitVariant("Enum", "Foo"), Token::UnitVariant { name: "Enum", variant: "Foo" },
], ],
"unknown variant `Foo`, expected one of `Unit`, `Simple`, `Seq`, `Map`", "unknown variant `Foo`, expected one of `Unit`, `Simple`, `Seq`, `Map`",
} }
test_enum_skipped_variant<Enum> { test_enum_skipped_variant<Enum> {
&[ &[
Token::UnitVariant("Enum", "Skipped"), Token::UnitVariant { name: "Enum", variant: "Skipped" },
], ],
"unknown variant `Skipped`, expected one of `Unit`, `Simple`, `Seq`, `Map`", "unknown variant `Skipped`, expected one of `Unit`, `Simple`, `Seq`, `Map`",
} }
test_enum_skip_all<EnumSkipAll> { test_enum_skip_all<EnumSkipAll> {
&[ &[
Token::UnitVariant("EnumSkipAll", "Skipped"), Token::UnitVariant { name: "EnumSkipAll", variant: "Skipped" },
], ],
"unknown variant `Skipped`, there are no variants", "unknown variant `Skipped`, there are no variants",
} }
test_duplicate_field_struct<Struct> { test_duplicate_field_struct<Struct> {
&[ &[
Token::Map(Some(3)), Token::Map { len: Some(3) },
Token::Str("a"), Token::Str("a"),
Token::I32(1), Token::I32(1),
@ -853,7 +853,7 @@ declare_error_tests! {
} }
test_duplicate_field_enum<Enum> { test_duplicate_field_enum<Enum> {
&[ &[
Token::StructVariant("Enum", "Map", 3), Token::StructVariant { name: "Enum", variant: "Map", len: 3 },
Token::Str("a"), Token::Str("a"),
Token::I32(1), Token::I32(1),
@ -863,7 +863,7 @@ declare_error_tests! {
} }
test_enum_out_of_range<Enum> { test_enum_out_of_range<Enum> {
&[ &[
Token::Enum("Enum"), Token::Enum { name: "Enum" },
Token::U32(4), Token::U32(4),
Token::Unit, Token::Unit,
], ],
@ -871,7 +871,7 @@ declare_error_tests! {
} }
test_short_tuple<(u8, u8, u8)> { test_short_tuple<(u8, u8, u8)> {
&[ &[
Token::Tuple(1), Token::Tuple { len: 1 },
Token::U8(1), Token::U8(1),
Token::TupleEnd, Token::TupleEnd,
], ],
@ -879,7 +879,7 @@ declare_error_tests! {
} }
test_short_array<[u8; 3]> { test_short_array<[u8; 3]> {
&[ &[
Token::Seq(Some(1)), Token::Seq { len: Some(1) },
Token::U8(1), Token::U8(1),
Token::SeqEnd, Token::SeqEnd,
], ],
@ -899,21 +899,21 @@ declare_error_tests! {
} }
test_unit_from_empty_seq<()> { test_unit_from_empty_seq<()> {
&[ &[
Token::Seq(Some(0)), Token::Seq { len: Some(0) },
Token::SeqEnd, Token::SeqEnd,
], ],
"invalid type: sequence, expected unit", "invalid type: sequence, expected unit",
} }
test_unit_from_empty_seq_without_len<()> { test_unit_from_empty_seq_without_len<()> {
&[ &[
Token::Seq(None), Token::Seq { len: None },
Token::SeqEnd, Token::SeqEnd,
], ],
"invalid type: sequence, expected unit", "invalid type: sequence, expected unit",
} }
test_unit_from_tuple_struct<()> { test_unit_from_tuple_struct<()> {
&[ &[
Token::TupleStruct("Anything", 0), Token::TupleStruct { name: "Anything", len: 0 },
Token::TupleStructEnd, Token::TupleStructEnd,
], ],
"invalid type: sequence, expected unit", "invalid type: sequence, expected unit",
@ -932,7 +932,7 @@ declare_error_tests! {
} }
test_btreeset_from_unit_struct<BTreeSet<isize>> { test_btreeset_from_unit_struct<BTreeSet<isize>> {
&[ &[
Token::UnitStruct("Anything"), Token::UnitStruct { name: "Anything" },
], ],
"invalid type: unit value, expected a sequence", "invalid type: unit value, expected a sequence",
} }
@ -944,7 +944,7 @@ declare_error_tests! {
} }
test_hashset_from_unit_struct<HashSet<isize>> { test_hashset_from_unit_struct<HashSet<isize>> {
&[ &[
Token::UnitStruct("Anything"), Token::UnitStruct { name: "Anything" },
], ],
"invalid type: unit value, expected a sequence", "invalid type: unit value, expected a sequence",
} }
@ -956,7 +956,7 @@ declare_error_tests! {
} }
test_vec_from_unit_struct<Vec<isize>> { test_vec_from_unit_struct<Vec<isize>> {
&[ &[
Token::UnitStruct("Anything"), Token::UnitStruct { name: "Anything" },
], ],
"invalid type: unit value, expected a sequence", "invalid type: unit value, expected a sequence",
} }
@ -968,7 +968,7 @@ declare_error_tests! {
} }
test_zero_array_from_unit_struct<[isize; 0]> { test_zero_array_from_unit_struct<[isize; 0]> {
&[ &[
Token::UnitStruct("Anything"), Token::UnitStruct { name: "Anything" },
], ],
"invalid type: unit value, expected an empty array", "invalid type: unit value, expected an empty array",
} }
@ -980,7 +980,7 @@ declare_error_tests! {
} }
test_btreemap_from_unit_struct<BTreeMap<isize, isize>> { test_btreemap_from_unit_struct<BTreeMap<isize, isize>> {
&[ &[
Token::UnitStruct("Anything"), Token::UnitStruct { name: "Anything" },
], ],
"invalid type: unit value, expected a map", "invalid type: unit value, expected a map",
} }
@ -992,7 +992,7 @@ declare_error_tests! {
} }
test_hashmap_from_unit_struct<HashMap<isize, isize>> { test_hashmap_from_unit_struct<HashMap<isize, isize>> {
&[ &[
Token::UnitStruct("Anything"), Token::UnitStruct { name: "Anything" },
], ],
"invalid type: unit value, expected a map", "invalid type: unit value, expected a map",
} }
@ -1016,7 +1016,7 @@ declare_error_tests! {
} }
test_unit_struct_from_seq<UnitStruct> { test_unit_struct_from_seq<UnitStruct> {
&[ &[
Token::Seq(Some(0)), Token::Seq { len: Some(0) },
Token::SeqEnd, Token::SeqEnd,
], ],
"invalid type: sequence, expected unit struct UnitStruct", "invalid type: sequence, expected unit struct UnitStruct",

132
test_suite/tests/test_macros.rs
View File

@ -115,7 +115,7 @@ struct DefaultTyParam<T: AssociatedType<X = i32> = i32> {
#[test] #[test]
fn test_named_unit() { fn test_named_unit() {
assert_tokens(&NamedUnit, &[Token::UnitStruct("NamedUnit")]); assert_tokens(&NamedUnit, &[Token::UnitStruct { name: "NamedUnit" }]);
} }
#[test] #[test]
@ -126,7 +126,7 @@ fn test_ser_named_tuple() {
assert_ser_tokens( assert_ser_tokens(
&SerNamedTuple(&a, &mut b, c), &SerNamedTuple(&a, &mut b, c),
&[ &[
Token::TupleStruct("SerNamedTuple", 3), Token::TupleStruct { name: "SerNamedTuple", len: 3 },
Token::I32(5), Token::I32(5),
Token::I32(6), Token::I32(6),
Token::I32(7), Token::I32(7),
@ -140,7 +140,7 @@ fn test_de_named_tuple() {
assert_de_tokens( assert_de_tokens(
&DeNamedTuple(5, 6, 7), &DeNamedTuple(5, 6, 7),
&[ &[
Token::Seq(Some(3)), Token::Seq { len: Some(3) },
Token::I32(5), Token::I32(5),
Token::I32(6), Token::I32(6),
Token::I32(7), Token::I32(7),
@ -151,7 +151,7 @@ fn test_de_named_tuple() {
assert_de_tokens( assert_de_tokens(
&DeNamedTuple(5, 6, 7), &DeNamedTuple(5, 6, 7),
&[ &[
Token::TupleStruct("DeNamedTuple", 3), Token::TupleStruct { name: "DeNamedTuple", len: 3 },
Token::I32(5), Token::I32(5),
Token::I32(6), Token::I32(6),
Token::I32(7), Token::I32(7),
@ -173,7 +173,7 @@ fn test_ser_named_map() {
c: c, c: c,
}, },
&[ &[
Token::Struct("SerNamedMap", 3), Token::Struct { name: "SerNamedMap", len: 3 },
Token::Str("a"), Token::Str("a"),
Token::I32(5), Token::I32(5),
@ -194,7 +194,7 @@ fn test_de_named_map() {
assert_de_tokens( assert_de_tokens(
&DeNamedMap { a: 5, b: 6, c: 7 }, &DeNamedMap { a: 5, b: 6, c: 7 },
&[ &[
Token::Struct("DeNamedMap", 3), Token::Struct { name: "DeNamedMap", len: 3 },
Token::Str("a"), Token::Str("a"),
Token::I32(5), Token::I32(5),
@ -214,7 +214,7 @@ fn test_de_named_map() {
fn test_ser_enum_unit() { fn test_ser_enum_unit() {
assert_ser_tokens( assert_ser_tokens(
&SerEnum::Unit::<u32, u32, u32>, &SerEnum::Unit::<u32, u32, u32>,
&[Token::UnitVariant("SerEnum", "Unit")], &[Token::UnitVariant { name: "SerEnum", variant: "Unit" }],
); );
} }
@ -228,7 +228,7 @@ fn test_ser_enum_seq() {
assert_ser_tokens( assert_ser_tokens(
&SerEnum::Seq(a, b, &c, &mut d), &SerEnum::Seq(a, b, &c, &mut d),
&[ &[
Token::TupleVariant("SerEnum", "Seq", 4), Token::TupleVariant { name: "SerEnum", variant: "Seq", len: 4 },
Token::I8(1), Token::I8(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
@ -253,7 +253,7 @@ fn test_ser_enum_map() {
d: &mut d, d: &mut d,
}, },
&[ &[
Token::StructVariant("SerEnum", "Map", 4), Token::StructVariant { name: "SerEnum", variant: "Map", len: 4 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -276,7 +276,7 @@ fn test_ser_enum_map() {
fn test_de_enum_unit() { fn test_de_enum_unit() {
assert_tokens( assert_tokens(
&DeEnum::Unit::<u32, u32, u32>, &DeEnum::Unit::<u32, u32, u32>,
&[Token::UnitVariant("DeEnum", "Unit")], &[Token::UnitVariant { name: "DeEnum", variant: "Unit" }],
); );
} }
@ -290,7 +290,7 @@ fn test_de_enum_seq() {
assert_tokens( assert_tokens(
&DeEnum::Seq(a, b, c, d), &DeEnum::Seq(a, b, c, d),
&[ &[
Token::TupleVariant("DeEnum", "Seq", 4), Token::TupleVariant { name: "DeEnum", variant: "Seq", len: 4 },
Token::I8(1), Token::I8(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
@ -315,7 +315,7 @@ fn test_de_enum_map() {
d: d, d: d,
}, },
&[ &[
Token::StructVariant("DeEnum", "Map", 4), Token::StructVariant { name: "DeEnum", variant: "Map", len: 4 },
Token::Str("a"), Token::Str("a"),
Token::I8(1), Token::I8(1),
@ -341,7 +341,7 @@ fn test_lifetimes() {
assert_ser_tokens( assert_ser_tokens(
&Lifetimes::LifetimeSeq(&value), &Lifetimes::LifetimeSeq(&value),
&[ &[
Token::NewtypeVariant("Lifetimes", "LifetimeSeq"), Token::NewtypeVariant { name: "Lifetimes", variant: "LifetimeSeq" },
Token::I32(5), Token::I32(5),
], ],
); );
@ -349,7 +349,7 @@ fn test_lifetimes() {
assert_ser_tokens( assert_ser_tokens(
&Lifetimes::NoLifetimeSeq(5), &Lifetimes::NoLifetimeSeq(5),
&[ &[
Token::NewtypeVariant("Lifetimes", "NoLifetimeSeq"), Token::NewtypeVariant { name: "Lifetimes", variant: "NoLifetimeSeq" },
Token::I32(5), Token::I32(5),
], ],
); );
@ -357,7 +357,7 @@ fn test_lifetimes() {
assert_ser_tokens( assert_ser_tokens(
&Lifetimes::LifetimeMap { a: &value }, &Lifetimes::LifetimeMap { a: &value },
&[ &[
Token::StructVariant("Lifetimes", "LifetimeMap", 1), Token::StructVariant { name: "Lifetimes", variant: "LifetimeMap", len: 1 },
Token::Str("a"), Token::Str("a"),
Token::I32(5), Token::I32(5),
@ -369,7 +369,7 @@ fn test_lifetimes() {
assert_ser_tokens( assert_ser_tokens(
&Lifetimes::NoLifetimeMap { a: 5 }, &Lifetimes::NoLifetimeMap { a: 5 },
&[ &[
Token::StructVariant("Lifetimes", "NoLifetimeMap", 1), Token::StructVariant { name: "Lifetimes", variant: "NoLifetimeMap", len: 1 },
Token::Str("a"), Token::Str("a"),
Token::I32(5), Token::I32(5),
@ -384,7 +384,7 @@ fn test_generic_struct() {
assert_tokens( assert_tokens(
&GenericStruct { x: 5u32 }, &GenericStruct { x: 5u32 },
&[ &[
Token::Struct("GenericStruct", 1), Token::Struct { name: "GenericStruct", len: 1 },
Token::Str("x"), Token::Str("x"),
Token::U32(5), Token::U32(5),
@ -398,7 +398,7 @@ fn test_generic_struct() {
fn test_generic_newtype_struct() { fn test_generic_newtype_struct() {
assert_tokens( assert_tokens(
&GenericNewTypeStruct(5u32), &GenericNewTypeStruct(5u32),
&[Token::NewtypeStruct("GenericNewTypeStruct"), Token::U32(5)], &[Token::NewtypeStruct { name: "GenericNewTypeStruct" }, Token::U32(5)],
); );
} }
@ -407,7 +407,7 @@ fn test_generic_tuple_struct() {
assert_tokens( assert_tokens(
&GenericTupleStruct(5u32, 6u32), &GenericTupleStruct(5u32, 6u32),
&[ &[
Token::TupleStruct("GenericTupleStruct", 2), Token::TupleStruct { name: "GenericTupleStruct", len: 2 },
Token::U32(5), Token::U32(5),
Token::U32(6), Token::U32(6),
Token::TupleStructEnd, Token::TupleStructEnd,
@ -419,7 +419,7 @@ fn test_generic_tuple_struct() {
fn test_generic_enum_unit() { fn test_generic_enum_unit() {
assert_tokens( assert_tokens(
&GenericEnum::Unit::<u32, u32>, &GenericEnum::Unit::<u32, u32>,
&[Token::UnitVariant("GenericEnum", "Unit")], &[Token::UnitVariant { name: "GenericEnum", variant: "Unit" }],
); );
} }
@ -428,7 +428,7 @@ fn test_generic_enum_newtype() {
assert_tokens( assert_tokens(
&GenericEnum::NewType::<u32, u32>(5), &GenericEnum::NewType::<u32, u32>(5),
&[ &[
Token::NewtypeVariant("GenericEnum", "NewType"), Token::NewtypeVariant { name: "GenericEnum", variant: "NewType" },
Token::U32(5), Token::U32(5),
], ],
); );
@ -439,7 +439,7 @@ fn test_generic_enum_seq() {
assert_tokens( assert_tokens(
&GenericEnum::Seq::<u32, u32>(5, 6), &GenericEnum::Seq::<u32, u32>(5, 6),
&[ &[
Token::TupleVariant("GenericEnum", "Seq", 2), Token::TupleVariant { name: "GenericEnum", variant: "Seq", len: 2 },
Token::U32(5), Token::U32(5),
Token::U32(6), Token::U32(6),
Token::TupleVariantEnd, Token::TupleVariantEnd,
@ -452,7 +452,7 @@ fn test_generic_enum_map() {
assert_tokens( assert_tokens(
&GenericEnum::Map::<u32, u32> { x: 5, y: 6 }, &GenericEnum::Map::<u32, u32> { x: 5, y: 6 },
&[ &[
Token::StructVariant("GenericEnum", "Map", 2), Token::StructVariant { name: "GenericEnum", variant: "Map", len: 2 },
Token::Str("x"), Token::Str("x"),
Token::U32(5), Token::U32(5),
@ -470,10 +470,10 @@ fn test_default_ty_param() {
assert_tokens( assert_tokens(
&DefaultTyParam::<i32> { phantom: PhantomData }, &DefaultTyParam::<i32> { phantom: PhantomData },
&[ &[
Token::Struct("DefaultTyParam", 1), Token::Struct { name: "DefaultTyParam", len: 1 },
Token::Str("phantom"), Token::Str("phantom"),
Token::UnitStruct("PhantomData"), Token::UnitStruct { name: "PhantomData" },
Token::StructEnd, Token::StructEnd,
], ],
@ -493,7 +493,7 @@ fn test_enum_state_field() {
state: true, state: true,
}, },
&[ &[
Token::StructVariant("SomeEnum", "Key", 2), Token::StructVariant { name: "SomeEnum", variant: "Key", len: 2 },
Token::Str("key"), Token::Str("key"),
Token::Char('a'), Token::Char('a'),
@ -522,7 +522,7 @@ fn test_untagged_enum() {
assert_tokens( assert_tokens(
&Untagged::A { a: 1 }, &Untagged::A { a: 1 },
&[ &[
Token::Struct("Untagged", 1), Token::Struct { name: "Untagged", len: 1 },
Token::Str("a"), Token::Str("a"),
Token::U8(1), Token::U8(1),
@ -534,7 +534,7 @@ fn test_untagged_enum() {
assert_tokens( assert_tokens(
&Untagged::B { b: 2 }, &Untagged::B { b: 2 },
&[ &[
Token::Struct("Untagged", 1), Token::Struct { name: "Untagged", len: 1 },
Token::Str("b"), Token::Str("b"),
Token::U8(2), Token::U8(2),
@ -550,7 +550,7 @@ fn test_untagged_enum() {
assert_tokens( assert_tokens(
&Untagged::F(1, 2), &Untagged::F(1, 2),
&[Token::Tuple(2), Token::U8(1), Token::U8(2), Token::TupleEnd], &[Token::Tuple { len: 2 }, Token::U8(1), Token::U8(2), Token::TupleEnd],
); );
assert_de_tokens_error::<Untagged>( assert_de_tokens_error::<Untagged>(
@ -559,13 +559,13 @@ fn test_untagged_enum() {
); );
assert_de_tokens_error::<Untagged>( assert_de_tokens_error::<Untagged>(
&[Token::Tuple(1), Token::U8(1), Token::TupleEnd], &[Token::Tuple { len: 1 }, Token::U8(1), Token::TupleEnd],
"data did not match any variant of untagged enum Untagged", "data did not match any variant of untagged enum Untagged",
); );
assert_de_tokens_error::<Untagged>( assert_de_tokens_error::<Untagged>(
&[ &[
Token::Tuple(3), Token::Tuple { len: 3 },
Token::U8(1), Token::U8(1),
Token::U8(2), Token::U8(2),
Token::U8(3), Token::U8(3),
@ -599,7 +599,7 @@ fn test_internally_tagged_enum() {
assert_tokens( assert_tokens(
&InternallyTagged::A { a: 1 }, &InternallyTagged::A { a: 1 },
&[ &[
Token::Struct("InternallyTagged", 2), Token::Struct { name: "InternallyTagged", len: 2 },
Token::Str("type"), Token::Str("type"),
Token::Str("A"), Token::Str("A"),
@ -614,7 +614,7 @@ fn test_internally_tagged_enum() {
assert_tokens( assert_tokens(
&InternallyTagged::B { b: 2 }, &InternallyTagged::B { b: 2 },
&[ &[
Token::Struct("InternallyTagged", 2), Token::Struct { name: "InternallyTagged", len: 2 },
Token::Str("type"), Token::Str("type"),
Token::Str("B"), Token::Str("B"),
@ -629,7 +629,7 @@ fn test_internally_tagged_enum() {
assert_tokens( assert_tokens(
&InternallyTagged::C, &InternallyTagged::C,
&[ &[
Token::Struct("InternallyTagged", 1), Token::Struct { name: "InternallyTagged", len: 1 },
Token::Str("type"), Token::Str("type"),
Token::Str("C"), Token::Str("C"),
@ -641,7 +641,7 @@ fn test_internally_tagged_enum() {
assert_tokens( assert_tokens(
&InternallyTagged::D(BTreeMap::new()), &InternallyTagged::D(BTreeMap::new()),
&[ &[
Token::Map(Some(1)), Token::Map { len: Some(1) },
Token::Str("type"), Token::Str("type"),
Token::Str("D"), Token::Str("D"),
@ -653,7 +653,7 @@ fn test_internally_tagged_enum() {
assert_tokens( assert_tokens(
&InternallyTagged::E(Newtype(BTreeMap::new())), &InternallyTagged::E(Newtype(BTreeMap::new())),
&[ &[
Token::Map(Some(1)), Token::Map { len: Some(1) },
Token::Str("type"), Token::Str("type"),
Token::Str("E"), Token::Str("E"),
@ -665,7 +665,7 @@ fn test_internally_tagged_enum() {
assert_tokens( assert_tokens(
&InternallyTagged::F(Struct { f: 6 }), &InternallyTagged::F(Struct { f: 6 }),
&[ &[
Token::Struct("Struct", 2), Token::Struct { name: "Struct", len: 2 },
Token::Str("type"), Token::Str("type"),
Token::Str("F"), Token::Str("F"),
@ -678,13 +678,13 @@ fn test_internally_tagged_enum() {
); );
assert_de_tokens_error::<InternallyTagged>( assert_de_tokens_error::<InternallyTagged>(
&[Token::Map(Some(0)), Token::MapEnd], &[Token::Map { len: Some(0) }, Token::MapEnd],
"missing field `type`", "missing field `type`",
); );
assert_de_tokens_error::<InternallyTagged>( assert_de_tokens_error::<InternallyTagged>(
&[ &[
Token::Map(Some(1)), Token::Map { len: Some(1) },
Token::Str("type"), Token::Str("type"),
Token::Str("Z"), Token::Str("Z"),
@ -710,7 +710,7 @@ fn test_adjacently_tagged_enum() {
assert_tokens( assert_tokens(
&AdjacentlyTagged::Unit::<u8>, &AdjacentlyTagged::Unit::<u8>,
&[ &[
Token::Struct("AdjacentlyTagged", 1), Token::Struct { name: "AdjacentlyTagged", len: 1 },
Token::Str("t"), Token::Str("t"),
Token::Str("Unit"), Token::Str("Unit"),
@ -723,7 +723,7 @@ fn test_adjacently_tagged_enum() {
assert_de_tokens( assert_de_tokens(
&AdjacentlyTagged::Unit::<u8>, &AdjacentlyTagged::Unit::<u8>,
&[ &[
Token::Struct("AdjacentlyTagged", 1), Token::Struct { name: "AdjacentlyTagged", len: 1 },
Token::Str("t"), Token::Str("t"),
Token::Str("Unit"), Token::Str("Unit"),
@ -739,7 +739,7 @@ fn test_adjacently_tagged_enum() {
assert_de_tokens( assert_de_tokens(
&AdjacentlyTagged::Unit::<u8>, &AdjacentlyTagged::Unit::<u8>,
&[ &[
Token::Struct("AdjacentlyTagged", 1), Token::Struct { name: "AdjacentlyTagged", len: 1 },
Token::Str("c"), Token::Str("c"),
Token::Unit, Token::Unit,
@ -755,7 +755,7 @@ fn test_adjacently_tagged_enum() {
assert_tokens( assert_tokens(
&AdjacentlyTagged::Newtype::<u8>(1), &AdjacentlyTagged::Newtype::<u8>(1),
&[ &[
Token::Struct("AdjacentlyTagged", 2), Token::Struct { name: "AdjacentlyTagged", len: 2 },
Token::Str("t"), Token::Str("t"),
Token::Str("Newtype"), Token::Str("Newtype"),
@ -771,7 +771,7 @@ fn test_adjacently_tagged_enum() {
assert_de_tokens( assert_de_tokens(
&AdjacentlyTagged::Newtype::<u8>(1), &AdjacentlyTagged::Newtype::<u8>(1),
&[ &[
Token::Struct("AdjacentlyTagged", 2), Token::Struct { name: "AdjacentlyTagged", len: 2 },
Token::Str("c"), Token::Str("c"),
Token::U8(1), Token::U8(1),
@ -787,13 +787,13 @@ fn test_adjacently_tagged_enum() {
assert_tokens( assert_tokens(
&AdjacentlyTagged::Tuple::<u8>(1, 1), &AdjacentlyTagged::Tuple::<u8>(1, 1),
&[ &[
Token::Struct("AdjacentlyTagged", 2), Token::Struct { name: "AdjacentlyTagged", len: 2 },
Token::Str("t"), Token::Str("t"),
Token::Str("Tuple"), Token::Str("Tuple"),
Token::Str("c"), Token::Str("c"),
Token::Tuple(2), Token::Tuple { len: 2 },
Token::U8(1), Token::U8(1),
Token::U8(1), Token::U8(1),
Token::TupleEnd, Token::TupleEnd,
@ -806,10 +806,10 @@ fn test_adjacently_tagged_enum() {
assert_de_tokens( assert_de_tokens(
&AdjacentlyTagged::Tuple::<u8>(1, 1), &AdjacentlyTagged::Tuple::<u8>(1, 1),
&[ &[
Token::Struct("AdjacentlyTagged", 2), Token::Struct { name: "AdjacentlyTagged", len: 2 },
Token::Str("c"), Token::Str("c"),
Token::Tuple(2), Token::Tuple { len: 2 },
Token::U8(1), Token::U8(1),
Token::U8(1), Token::U8(1),
Token::TupleEnd, Token::TupleEnd,
@ -825,13 +825,13 @@ fn test_adjacently_tagged_enum() {
assert_tokens( assert_tokens(
&AdjacentlyTagged::Struct::<u8> { f: 1 }, &AdjacentlyTagged::Struct::<u8> { f: 1 },
&[ &[
Token::Struct("AdjacentlyTagged", 2), Token::Struct { name: "AdjacentlyTagged", len: 2 },
Token::Str("t"), Token::Str("t"),
Token::Str("Struct"), Token::Str("Struct"),
Token::Str("c"), Token::Str("c"),
Token::Struct("Struct", 1), Token::Struct { name: "Struct", len: 1 },
Token::Str("f"), Token::Str("f"),
Token::U8(1), Token::U8(1),
Token::StructEnd, Token::StructEnd,
@ -844,10 +844,10 @@ fn test_adjacently_tagged_enum() {
assert_de_tokens( assert_de_tokens(
&AdjacentlyTagged::Struct::<u8> { f: 1 }, &AdjacentlyTagged::Struct::<u8> { f: 1 },
&[ &[
Token::Struct("AdjacentlyTagged", 2), Token::Struct { name: "AdjacentlyTagged", len: 2 },
Token::Str("c"), Token::Str("c"),
Token::Struct("Struct", 1), Token::Struct { name: "Struct", len: 1 },
Token::Str("f"), Token::Str("f"),
Token::U8(1), Token::U8(1),
Token::StructEnd, Token::StructEnd,
@ -879,7 +879,7 @@ fn test_enum_in_internally_tagged_enum() {
assert_tokens( assert_tokens(
&Outer::Inner(Inner::Unit), &Outer::Inner(Inner::Unit),
&[ &[
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::Str("type"), Token::Str("type"),
Token::Str("Inner"), Token::Str("Inner"),
@ -894,7 +894,7 @@ fn test_enum_in_internally_tagged_enum() {
assert_tokens( assert_tokens(
&Outer::Inner(Inner::Newtype(1)), &Outer::Inner(Inner::Newtype(1)),
&[ &[
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::Str("type"), Token::Str("type"),
Token::Str("Inner"), Token::Str("Inner"),
@ -909,13 +909,13 @@ fn test_enum_in_internally_tagged_enum() {
assert_tokens( assert_tokens(
&Outer::Inner(Inner::Tuple(1, 1)), &Outer::Inner(Inner::Tuple(1, 1)),
&[ &[
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::Str("type"), Token::Str("type"),
Token::Str("Inner"), Token::Str("Inner"),
Token::Str("Tuple"), Token::Str("Tuple"),
Token::TupleStruct("Tuple", 2), Token::TupleStruct { name: "Tuple", len: 2 },
Token::U8(1), Token::U8(1),
Token::U8(1), Token::U8(1),
Token::TupleStructEnd, Token::TupleStructEnd,
@ -927,13 +927,13 @@ fn test_enum_in_internally_tagged_enum() {
assert_tokens( assert_tokens(
&Outer::Inner(Inner::Struct { f: 1 }), &Outer::Inner(Inner::Struct { f: 1 }),
&[ &[
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::Str("type"), Token::Str("type"),
Token::Str("Inner"), Token::Str("Inner"),
Token::Str("Struct"), Token::Str("Struct"),
Token::Struct("Struct", 1), Token::Struct { name: "Struct", len: 1 },
Token::Str("f"), Token::Str("f"),
Token::U8(1), Token::U8(1),
Token::StructEnd, Token::StructEnd,
@ -961,18 +961,18 @@ fn test_enum_in_untagged_enum() {
assert_tokens( assert_tokens(
&Outer::Inner(Inner::Unit), &Outer::Inner(Inner::Unit),
&[Token::UnitVariant("Inner", "Unit")], &[Token::UnitVariant { name: "Inner", variant: "Unit" }],
); );
assert_tokens( assert_tokens(
&Outer::Inner(Inner::Newtype(1)), &Outer::Inner(Inner::Newtype(1)),
&[Token::NewtypeVariant("Inner", "Newtype"), Token::U8(1)], &[Token::NewtypeVariant { name: "Inner", variant: "Newtype" }, Token::U8(1)],
); );
assert_tokens( assert_tokens(
&Outer::Inner(Inner::Tuple(1, 1)), &Outer::Inner(Inner::Tuple(1, 1)),
&[ &[
Token::TupleVariant("Inner", "Tuple", 2), Token::TupleVariant { name: "Inner", variant: "Tuple", len: 2 },
Token::U8(1), Token::U8(1),
Token::U8(1), Token::U8(1),
Token::TupleVariantEnd, Token::TupleVariantEnd,
@ -982,7 +982,7 @@ fn test_enum_in_untagged_enum() {
assert_tokens( assert_tokens(
&Outer::Inner(Inner::Struct { f: 1 }), &Outer::Inner(Inner::Struct { f: 1 }),
&[ &[
Token::StructVariant("Inner", "Struct", 1), Token::StructVariant { name: "Inner", variant: "Struct", len: 1 },
Token::Str("f"), Token::Str("f"),
Token::U8(1), Token::U8(1),
@ -1027,7 +1027,7 @@ fn test_rename_all() {
serialize_seq: true, serialize_seq: true,
}, },
&[ &[
Token::StructVariant("E", "serialize", 2), Token::StructVariant { name: "E", variant: "serialize", len: 2 },
Token::Str("serialize"), Token::Str("serialize"),
Token::Bool(true), Token::Bool(true),
Token::Str("serializeSeq"), Token::Str("serializeSeq"),
@ -1042,7 +1042,7 @@ fn test_rename_all() {
serialize_seq: true, serialize_seq: true,
}, },
&[ &[
Token::StructVariant("E", "serialize_seq", 2), Token::StructVariant { name: "E", variant: "serialize_seq", len: 2 },
Token::Str("serialize"), Token::Str("serialize"),
Token::Bool(true), Token::Bool(true),
Token::Str("serialize-seq"), Token::Str("serialize-seq"),
@ -1057,7 +1057,7 @@ fn test_rename_all() {
serialize_seq: true, serialize_seq: true,
}, },
&[ &[
Token::StructVariant("E", "serialize_map", 2), Token::StructVariant { name: "E", variant: "serialize_map", len: 2 },
Token::Str("SERIALIZE"), Token::Str("SERIALIZE"),
Token::Bool(true), Token::Bool(true),
Token::Str("SERIALIZE_SEQ"), Token::Str("SERIALIZE_SEQ"),
@ -1072,7 +1072,7 @@ fn test_rename_all() {
serialize_seq: true, serialize_seq: true,
}, },
&[ &[
Token::Struct("S", 2), Token::Struct { name: "S", len: 2 },
Token::Str("Serialize"), Token::Str("Serialize"),
Token::Bool(true), Token::Bool(true),
Token::Str("SerializeSeq"), Token::Str("SerializeSeq"),

68
test_suite/tests/test_ser.rs
View File

@ -115,21 +115,21 @@ declare_tests! {
} }
test_result { test_result {
Ok::<i32, i32>(0) => &[ Ok::<i32, i32>(0) => &[
Token::NewtypeVariant("Result", "Ok"), Token::NewtypeVariant { name: "Result", variant: "Ok" },
Token::I32(0), Token::I32(0),
], ],
Err::<i32, i32>(1) => &[ Err::<i32, i32>(1) => &[
Token::NewtypeVariant("Result", "Err"), Token::NewtypeVariant { name: "Result", variant: "Err" },
Token::I32(1), Token::I32(1),
], ],
} }
test_slice { test_slice {
&[0][..0] => &[ &[0][..0] => &[
Token::Seq(Some(0)), Token::Seq { len: Some(0) },
Token::SeqEnd, Token::SeqEnd,
], ],
&[1, 2, 3][..] => &[ &[1, 2, 3][..] => &[
Token::Seq(Some(3)), Token::Seq { len: Some(3) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
@ -138,11 +138,11 @@ declare_tests! {
} }
test_array { test_array {
[0; 0] => &[ [0; 0] => &[
Token::Tuple(0), Token::Tuple { len: 0 },
Token::TupleEnd, Token::TupleEnd,
], ],
[1, 2, 3] => &[ [1, 2, 3] => &[
Token::Tuple(3), Token::Tuple { len: 3 },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
@ -151,19 +151,19 @@ declare_tests! {
} }
test_vec { test_vec {
Vec::<isize>::new() => &[ Vec::<isize>::new() => &[
Token::Seq(Some(0)), Token::Seq { len: Some(0) },
Token::SeqEnd, Token::SeqEnd,
], ],
vec![vec![], vec![1], vec![2, 3]] => &[ vec![vec![], vec![1], vec![2, 3]] => &[
Token::Seq(Some(3)), Token::Seq { len: Some(3) },
Token::Seq(Some(0)), Token::Seq { len: Some(0) },
Token::SeqEnd, Token::SeqEnd,
Token::Seq(Some(1)), Token::Seq { len: Some(1) },
Token::I32(1), Token::I32(1),
Token::SeqEnd, Token::SeqEnd,
Token::Seq(Some(2)), Token::Seq { len: Some(2) },
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
Token::SeqEnd, Token::SeqEnd,
@ -172,28 +172,28 @@ declare_tests! {
} }
test_hashset { test_hashset {
HashSet::<isize>::new() => &[ HashSet::<isize>::new() => &[
Token::Seq(Some(0)), Token::Seq { len: Some(0) },
Token::SeqEnd, Token::SeqEnd,
], ],
hashset![1] => &[ hashset![1] => &[
Token::Seq(Some(1)), Token::Seq { len: Some(1) },
Token::I32(1), Token::I32(1),
Token::SeqEnd, Token::SeqEnd,
], ],
hashset![FnvHasher @ 1] => &[ hashset![FnvHasher @ 1] => &[
Token::Seq(Some(1)), Token::Seq { len: Some(1) },
Token::I32(1), Token::I32(1),
Token::SeqEnd, Token::SeqEnd,
], ],
} }
test_tuple { test_tuple {
(1,) => &[ (1,) => &[
Token::Tuple(1), Token::Tuple { len: 1 },
Token::I32(1), Token::I32(1),
Token::TupleEnd, Token::TupleEnd,
], ],
(1, 2, 3) => &[ (1, 2, 3) => &[
Token::Tuple(3), Token::Tuple { len: 3 },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
@ -202,13 +202,13 @@ declare_tests! {
} }
test_btreemap { test_btreemap {
btreemap![1 => 2] => &[ btreemap![1 => 2] => &[
Token::Map(Some(1)), Token::Map { len: Some(1) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::MapEnd, Token::MapEnd,
], ],
btreemap![1 => 2, 3 => 4] => &[ btreemap![1 => 2, 3 => 4] => &[
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
@ -217,13 +217,13 @@ declare_tests! {
Token::MapEnd, Token::MapEnd,
], ],
btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => &[ btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => &[
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::I32(1), Token::I32(1),
Token::Map(Some(0)), Token::Map { len: Some(0) },
Token::MapEnd, Token::MapEnd,
Token::I32(2), Token::I32(2),
Token::Map(Some(2)), Token::Map { len: Some(2) },
Token::I32(3), Token::I32(3),
Token::I32(4), Token::I32(4),
@ -235,28 +235,28 @@ declare_tests! {
} }
test_hashmap { test_hashmap {
HashMap::<isize, isize>::new() => &[ HashMap::<isize, isize>::new() => &[
Token::Map(Some(0)), Token::Map { len: Some(0) },
Token::MapEnd, Token::MapEnd,
], ],
hashmap![1 => 2] => &[ hashmap![1 => 2] => &[
Token::Map(Some(1)), Token::Map { len: Some(1) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::MapEnd, Token::MapEnd,
], ],
hashmap![FnvHasher @ 1 => 2] => &[ hashmap![FnvHasher @ 1 => 2] => &[
Token::Map(Some(1)), Token::Map { len: Some(1) },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::MapEnd, Token::MapEnd,
], ],
} }
test_unit_struct { test_unit_struct {
UnitStruct => &[Token::UnitStruct("UnitStruct")], UnitStruct => &[Token::UnitStruct { name: "UnitStruct" }],
} }
test_tuple_struct { test_tuple_struct {
TupleStruct(1, 2, 3) => &[ TupleStruct(1, 2, 3) => &[
Token::TupleStruct("TupleStruct", 3), Token::TupleStruct { name: "TupleStruct", len: 3 },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::I32(3), Token::I32(3),
@ -265,7 +265,7 @@ declare_tests! {
} }
test_struct { test_struct {
Struct { a: 1, b: 2, c: 3 } => &[ Struct { a: 1, b: 2, c: 3 } => &[
Token::Struct("Struct", 3), Token::Struct { name: "Struct", len: 3 },
Token::Str("a"), Token::Str("a"),
Token::I32(1), Token::I32(1),
@ -278,16 +278,16 @@ declare_tests! {
], ],
} }
test_enum { test_enum {
Enum::Unit => &[Token::UnitVariant("Enum", "Unit")], Enum::Unit => &[Token::UnitVariant { name: "Enum", variant: "Unit" }],
Enum::One(42) => &[Token::NewtypeVariant("Enum", "One"), Token::I32(42)], Enum::One(42) => &[Token::NewtypeVariant { name: "Enum", variant: "One" }, Token::I32(42)],
Enum::Seq(1, 2) => &[ Enum::Seq(1, 2) => &[
Token::TupleVariant("Enum", "Seq", 2), Token::TupleVariant { name: "Enum", variant: "Seq", len: 2 },
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
Token::TupleVariantEnd, Token::TupleVariantEnd,
], ],
Enum::Map { a: 1, b: 2 } => &[ Enum::Map { a: 1, b: 2 } => &[
Token::StructVariant("Enum", "Map", 2), Token::StructVariant { name: "Enum", variant: "Map", len: 2 },
Token::Str("a"), Token::Str("a"),
Token::I32(1), Token::I32(1),
@ -301,7 +301,7 @@ declare_tests! {
} }
test_boxed_slice { test_boxed_slice {
Box::new([0, 1, 2]) => &[ Box::new([0, 1, 2]) => &[
Token::Tuple(3), Token::Tuple { len: 3 },
Token::I32(0), Token::I32(0),
Token::I32(1), Token::I32(1),
Token::I32(2), Token::I32(2),
@ -310,7 +310,7 @@ declare_tests! {
} }
test_duration { test_duration {
Duration::new(1, 2) => &[ Duration::new(1, 2) => &[
Token::Struct("Duration", 2), Token::Struct { name: "Duration", len: 2 },
Token::Str("secs"), Token::Str("secs"),
Token::U64(1), Token::U64(1),
@ -321,7 +321,7 @@ declare_tests! {
} }
test_range { test_range {
1u32..2u32 => &[ 1u32..2u32 => &[
Token::Struct("Range", 2), Token::Struct { name: "Range", len: 2 },
Token::Str("start"), Token::Str("start"),
Token::U32(1), Token::U32(1),