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

6
test_suite/tests/test_borrow.rs
View File

@ -69,7 +69,7 @@ fn test_tuple() {
assert_de_tokens(
&("str", &b"bytes"[..]),
&[
Token::Tuple(2),
Token::Tuple { len: 2 },
Token::BorrowedStr("str"),
Token::BorrowedBytes(b"bytes"),
Token::TupleEnd,
@ -91,7 +91,7 @@ fn test_struct() {
bb: b"bytes",
},
&[
Token::Struct("Borrowing", 2),
Token::Struct { name: "Borrowing", len: 2 },
Token::BorrowedStr("bs"),
Token::BorrowedStr("str"),
@ -115,7 +115,7 @@ fn test_cow() {
}
let tokens = &[
Token::Struct("Cows", 2),
Token::Struct { name: "Cows", len: 2 },
Token::Str("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
// stream for an IgnoreBase type
let concated_tokens: Vec<Token> = vec![
Token::Map(Some(2)),
Token::Map { len: Some(2) },
Token::Str("a"),
Token::I32(1),
@ -221,12 +221,12 @@ declare_tests! {
}
test_result {
Ok::<i32, i32>(0) => &[
Token::Enum("Result"),
Token::Enum { name: "Result" },
Token::Str("Ok"),
Token::I32(0),
],
Err::<i32, i32>(1) => &[
Token::Enum("Result"),
Token::Enum { name: "Result" },
Token::Str("Err"),
Token::I32(1),
],
@ -237,39 +237,39 @@ declare_tests! {
test_unit_struct {
UnitStruct => &[Token::Unit],
UnitStruct => &[
Token::UnitStruct("UnitStruct"),
Token::UnitStruct { name: "UnitStruct" },
],
}
test_newtype_struct {
NewtypeStruct(1) => &[
Token::NewtypeStruct("NewtypeStruct"),
Token::NewtypeStruct { name: "NewtypeStruct" },
Token::I32(1),
],
}
test_tuple_struct {
TupleStruct(1, 2, 3) => &[
Token::Seq(Some(3)),
Token::Seq { len: Some(3) },
Token::I32(1),
Token::I32(2),
Token::I32(3),
Token::SeqEnd,
],
TupleStruct(1, 2, 3) => &[
Token::Seq(None),
Token::Seq { len: None },
Token::I32(1),
Token::I32(2),
Token::I32(3),
Token::SeqEnd,
],
TupleStruct(1, 2, 3) => &[
Token::TupleStruct("TupleStruct", 3),
Token::TupleStruct { name: "TupleStruct", len: 3 },
Token::I32(1),
Token::I32(2),
Token::I32(3),
Token::TupleStructEnd,
],
TupleStruct(1, 2, 3) => &[
Token::TupleStruct("TupleStruct", 3),
Token::TupleStruct { name: "TupleStruct", len: 3 },
Token::I32(1),
Token::I32(2),
Token::I32(3),
@ -278,47 +278,47 @@ declare_tests! {
}
test_btreeset {
BTreeSet::<isize>::new() => &[
Token::Seq(Some(0)),
Token::Seq { len: Some(0) },
Token::SeqEnd,
],
btreeset![btreeset![], btreeset![1], btreeset![2, 3]] => &[
Token::Seq(Some(3)),
Token::Seq(Some(0)),
Token::Seq { len: Some(3) },
Token::Seq { len: Some(0) },
Token::SeqEnd,
Token::Seq(Some(1)),
Token::Seq { len: Some(1) },
Token::I32(1),
Token::SeqEnd,
Token::Seq(Some(2)),
Token::Seq { len: Some(2) },
Token::I32(2),
Token::I32(3),
Token::SeqEnd,
Token::SeqEnd,
],
BTreeSet::<isize>::new() => &[
Token::TupleStruct("Anything", 0),
Token::TupleStruct { name: "Anything", len: 0 },
Token::TupleStructEnd,
],
}
test_hashset {
HashSet::<isize>::new() => &[
Token::Seq(Some(0)),
Token::Seq { len: Some(0) },
Token::SeqEnd,
],
hashset![1, 2, 3] => &[
Token::Seq(Some(3)),
Token::Seq { len: Some(3) },
Token::I32(1),
Token::I32(2),
Token::I32(3),
Token::SeqEnd,
],
HashSet::<isize>::new() => &[
Token::TupleStruct("Anything", 0),
Token::TupleStruct { name: "Anything", len: 0 },
Token::TupleStructEnd,
],
hashset![FnvHasher @ 1, 2, 3] => &[
Token::Seq(Some(3)),
Token::Seq { len: Some(3) },
Token::I32(1),
Token::I32(2),
Token::I32(3),
@ -327,93 +327,93 @@ declare_tests! {
}
test_vec {
Vec::<isize>::new() => &[
Token::Seq(Some(0)),
Token::Seq { len: Some(0) },
Token::SeqEnd,
],
vec![vec![], vec![1], vec![2, 3]] => &[
Token::Seq(Some(3)),
Token::Seq(Some(0)),
Token::Seq { len: Some(3) },
Token::Seq { len: Some(0) },
Token::SeqEnd,
Token::Seq(Some(1)),
Token::Seq { len: Some(1) },
Token::I32(1),
Token::SeqEnd,
Token::Seq(Some(2)),
Token::Seq { len: Some(2) },
Token::I32(2),
Token::I32(3),
Token::SeqEnd,
Token::SeqEnd,
],
Vec::<isize>::new() => &[
Token::TupleStruct("Anything", 0),
Token::TupleStruct { name: "Anything", len: 0 },
Token::TupleStructEnd,
],
}
test_array {
[0; 0] => &[
Token::Seq(Some(0)),
Token::Seq { len: Some(0) },
Token::SeqEnd,
],
[0; 0] => &[
Token::Tuple(0),
Token::Tuple { len: 0 },
Token::TupleEnd,
],
([0; 0], [1], [2, 3]) => &[
Token::Seq(Some(3)),
Token::Seq(Some(0)),
Token::Seq { len: Some(3) },
Token::Seq { len: Some(0) },
Token::SeqEnd,
Token::Seq(Some(1)),
Token::Seq { len: Some(1) },
Token::I32(1),
Token::SeqEnd,
Token::Seq(Some(2)),
Token::Seq { len: Some(2) },
Token::I32(2),
Token::I32(3),
Token::SeqEnd,
Token::SeqEnd,
],
([0; 0], [1], [2, 3]) => &[
Token::Tuple(3),
Token::Tuple(0),
Token::Tuple { len: 3 },
Token::Tuple { len: 0 },
Token::TupleEnd,
Token::Tuple(1),
Token::Tuple { len: 1 },
Token::I32(1),
Token::TupleEnd,
Token::Tuple(2),
Token::Tuple { len: 2 },
Token::I32(2),
Token::I32(3),
Token::TupleEnd,
Token::TupleEnd,
],
[0; 0] => &[
Token::TupleStruct("Anything", 0),
Token::TupleStruct { name: "Anything", len: 0 },
Token::TupleStructEnd,
],
}
test_tuple {
(1,) => &[
Token::Seq(Some(1)),
Token::Seq { len: Some(1) },
Token::I32(1),
Token::SeqEnd,
],
(1, 2, 3) => &[
Token::Seq(Some(3)),
Token::Seq { len: Some(3) },
Token::I32(1),
Token::I32(2),
Token::I32(3),
Token::SeqEnd,
],
(1,) => &[
Token::Tuple(1),
Token::Tuple { len: 1 },
Token::I32(1),
Token::TupleEnd,
],
(1, 2, 3) => &[
Token::Tuple(3),
Token::Tuple { len: 3 },
Token::I32(1),
Token::I32(2),
Token::I32(3),
@ -422,17 +422,17 @@ declare_tests! {
}
test_btreemap {
BTreeMap::<isize, isize>::new() => &[
Token::Map(Some(0)),
Token::Map { len: Some(0) },
Token::MapEnd,
],
btreemap![1 => 2] => &[
Token::Map(Some(1)),
Token::Map { len: Some(1) },
Token::I32(1),
Token::I32(2),
Token::MapEnd,
],
btreemap![1 => 2, 3 => 4] => &[
Token::Map(Some(2)),
Token::Map { len: Some(2) },
Token::I32(1),
Token::I32(2),
@ -441,13 +441,13 @@ declare_tests! {
Token::MapEnd,
],
btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => &[
Token::Map(Some(2)),
Token::Map { len: Some(2) },
Token::I32(1),
Token::Map(Some(0)),
Token::Map { len: Some(0) },
Token::MapEnd,
Token::I32(2),
Token::Map(Some(2)),
Token::Map { len: Some(2) },
Token::I32(3),
Token::I32(4),
@ -457,23 +457,23 @@ declare_tests! {
Token::MapEnd,
],
BTreeMap::<isize, isize>::new() => &[
Token::Struct("Anything", 0),
Token::Struct { name: "Anything", len: 0 },
Token::StructEnd,
],
}
test_hashmap {
HashMap::<isize, isize>::new() => &[
Token::Map(Some(0)),
Token::Map { len: Some(0) },
Token::MapEnd,
],
hashmap![1 => 2] => &[
Token::Map(Some(1)),
Token::Map { len: Some(1) },
Token::I32(1),
Token::I32(2),
Token::MapEnd,
],
hashmap![1 => 2, 3 => 4] => &[
Token::Map(Some(2)),
Token::Map { len: Some(2) },
Token::I32(1),
Token::I32(2),
@ -482,13 +482,13 @@ declare_tests! {
Token::MapEnd,
],
hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]] => &[
Token::Map(Some(2)),
Token::Map { len: Some(2) },
Token::I32(1),
Token::Map(Some(0)),
Token::Map { len: Some(0) },
Token::MapEnd,
Token::I32(2),
Token::Map(Some(2)),
Token::Map { len: Some(2) },
Token::I32(3),
Token::I32(4),
@ -498,11 +498,11 @@ declare_tests! {
Token::MapEnd,
],
HashMap::<isize, isize>::new() => &[
Token::Struct("Anything", 0),
Token::Struct { name: "Anything", len: 0 },
Token::StructEnd,
],
hashmap![FnvHasher @ 1 => 2, 3 => 4] => &[
Token::Map(Some(2)),
Token::Map { len: Some(2) },
Token::I32(1),
Token::I32(2),
@ -513,7 +513,7 @@ declare_tests! {
}
test_struct {
Struct { a: 1, b: 2, c: 0 } => &[
Token::Map(Some(3)),
Token::Map { len: Some(3) },
Token::Str("a"),
Token::I32(1),
@ -522,7 +522,7 @@ declare_tests! {
Token::MapEnd,
],
Struct { a: 1, b: 2, c: 0 } => &[
Token::Struct("Struct", 3),
Token::Struct { name: "Struct", len: 3 },
Token::Str("a"),
Token::I32(1),
@ -531,7 +531,7 @@ declare_tests! {
Token::StructEnd,
],
Struct { a: 1, b: 2, c: 0 } => &[
Token::Seq(Some(3)),
Token::Seq { len: Some(3) },
Token::I32(1),
Token::I32(2),
Token::SeqEnd,
@ -539,7 +539,7 @@ declare_tests! {
}
test_struct_with_skip {
Struct { a: 1, b: 2, c: 0 } => &[
Token::Map(Some(3)),
Token::Map { len: Some(3) },
Token::Str("a"),
Token::I32(1),
@ -554,7 +554,7 @@ declare_tests! {
Token::MapEnd,
],
Struct { a: 1, b: 2, c: 0 } => &[
Token::Struct("Struct", 3),
Token::Struct { name: "Struct", len: 3 },
Token::Str("a"),
Token::I32(1),
@ -571,11 +571,11 @@ declare_tests! {
}
test_struct_skip_all {
StructSkipAll { a: 0 } => &[
Token::Struct("StructSkipAll", 0),
Token::Struct { name: "StructSkipAll", len: 0 },
Token::StructEnd,
],
StructSkipAll { a: 0 } => &[
Token::Struct("StructSkipAll", 1),
Token::Struct { name: "StructSkipAll", len: 1 },
Token::Str("a"),
Token::I32(1),
@ -586,13 +586,13 @@ declare_tests! {
}
test_struct_skip_all_deny_unknown {
StructSkipAllDenyUnknown { a: 0 } => &[
Token::Struct("StructSkipAllDenyUnknown", 0),
Token::Struct { name: "StructSkipAllDenyUnknown", len: 0 },
Token::StructEnd,
],
}
test_struct_default {
StructDefault { a: 50, b: "overwritten".to_string() } => &[
Token::Struct("StructDefault", 1),
Token::Struct { name: "StructDefault", len: 1 },
Token::Str("a"),
Token::I32(50),
@ -601,24 +601,24 @@ declare_tests! {
Token::StructEnd,
],
StructDefault { a: 100, b: "default".to_string() } => &[
Token::Struct("StructDefault", 0),
Token::Struct { name: "StructDefault", len: 0 },
Token::StructEnd,
],
}
test_enum_unit {
Enum::Unit => &[
Token::UnitVariant("Enum", "Unit"),
Token::UnitVariant { name: "Enum", variant: "Unit" },
],
}
test_enum_simple {
Enum::Simple(1) => &[
Token::NewtypeVariant("Enum", "Simple"),
Token::NewtypeVariant { name: "Enum", variant: "Simple" },
Token::I32(1),
],
}
test_enum_seq {
Enum::Seq(1, 2, 3) => &[
Token::TupleVariant("Enum", "Seq", 3),
Token::TupleVariant { name: "Enum", variant: "Seq", len: 3 },
Token::I32(1),
Token::I32(2),
Token::I32(3),
@ -627,7 +627,7 @@ declare_tests! {
}
test_enum_map {
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::I32(1),
@ -641,14 +641,14 @@ declare_tests! {
}
test_enum_unit_usize {
Enum::Unit => &[
Token::Enum("Enum"),
Token::Enum { name: "Enum" },
Token::U32(0),
Token::Unit,
],
}
test_enum_unit_bytes {
Enum::Unit => &[
Token::Enum("Enum"),
Token::Enum { name: "Enum" },
Token::Bytes(b"Unit"),
Token::Unit,
],
@ -658,7 +658,7 @@ declare_tests! {
}
test_boxed_slice {
Box::new([0, 1, 2]) => &[
Token::Seq(Some(3)),
Token::Seq { len: Some(3) },
Token::I32(0),
Token::I32(1),
Token::I32(2),
@ -667,7 +667,7 @@ declare_tests! {
}
test_duration {
Duration::new(1, 2) => &[
Token::Struct("Duration", 2),
Token::Struct { name: "Duration", len: 2 },
Token::Str("secs"),
Token::U64(1),
@ -676,7 +676,7 @@ declare_tests! {
Token::StructEnd,
],
Duration::new(1, 2) => &[
Token::Seq(Some(2)),
Token::Seq { len: Some(2) },
Token::I64(1),
Token::I64(2),
Token::SeqEnd,
@ -684,7 +684,7 @@ declare_tests! {
}
test_range {
1u32..2u32 => &[
Token::Struct("Range", 2),
Token::Struct { name: "Range", len: 2 },
Token::Str("start"),
Token::U32(1),
@ -693,7 +693,7 @@ declare_tests! {
Token::StructEnd,
],
1u32..2u32 => &[
Token::Seq(Some(2)),
Token::Seq { len: Some(2) },
Token::U64(1),
Token::U64(2),
Token::SeqEnd,
@ -729,9 +729,9 @@ fn test_osstring() {
let value = OsString::from_vec(vec![1, 2, 3]);
let tokens = [
Token::Enum("OsString"),
Token::Enum { name: "OsString" },
Token::Str("Unix"),
Token::Seq(Some(2)),
Token::Seq { len: Some(2) },
Token::U8(1),
Token::U8(2),
Token::U8(3),
@ -749,9 +749,9 @@ fn test_osstring() {
let value = OsString::from_wide(&[1, 2, 3]);
let tokens = [
Token::Enum("OsString"),
Token::Enum { name: "OsString" },
Token::Str("Windows"),
Token::Seq(Some(2)),
Token::Seq { len: Some(2) },
Token::U16(1),
Token::U16(2),
Token::U16(3),
@ -801,7 +801,7 @@ fn test_cstr_internal_null_end() {
declare_error_tests! {
test_unknown_field<StructDenyUnknown> {
&[
Token::Struct("StructDenyUnknown", 2),
Token::Struct { name: "StructDenyUnknown", len: 2 },
Token::Str("a"),
Token::I32(0),
@ -811,39 +811,39 @@ declare_error_tests! {
}
test_skipped_field_is_unknown<StructDenyUnknown> {
&[
Token::Struct("StructDenyUnknown", 2),
Token::Struct { name: "StructDenyUnknown", len: 2 },
Token::Str("b"),
],
"unknown field `b`, expected `a`",
}
test_skip_all_deny_unknown<StructSkipAllDenyUnknown> {
&[
Token::Struct("StructSkipAllDenyUnknown", 1),
Token::Struct { name: "StructSkipAllDenyUnknown", len: 1 },
Token::Str("a"),
],
"unknown field `a`, there are no fields",
}
test_unknown_variant<Enum> {
&[
Token::UnitVariant("Enum", "Foo"),
Token::UnitVariant { name: "Enum", variant: "Foo" },
],
"unknown variant `Foo`, expected one of `Unit`, `Simple`, `Seq`, `Map`",
}
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`",
}
test_enum_skip_all<EnumSkipAll> {
&[
Token::UnitVariant("EnumSkipAll", "Skipped"),
Token::UnitVariant { name: "EnumSkipAll", variant: "Skipped" },
],
"unknown variant `Skipped`, there are no variants",
}
test_duplicate_field_struct<Struct> {
&[
Token::Map(Some(3)),
Token::Map { len: Some(3) },
Token::Str("a"),
Token::I32(1),
@ -853,7 +853,7 @@ declare_error_tests! {
}
test_duplicate_field_enum<Enum> {
&[
Token::StructVariant("Enum", "Map", 3),
Token::StructVariant { name: "Enum", variant: "Map", len: 3 },
Token::Str("a"),
Token::I32(1),
@ -863,7 +863,7 @@ declare_error_tests! {
}
test_enum_out_of_range<Enum> {
&[
Token::Enum("Enum"),
Token::Enum { name: "Enum" },
Token::U32(4),
Token::Unit,
],
@ -871,7 +871,7 @@ declare_error_tests! {
}
test_short_tuple<(u8, u8, u8)> {
&[
Token::Tuple(1),
Token::Tuple { len: 1 },
Token::U8(1),
Token::TupleEnd,
],
@ -879,7 +879,7 @@ declare_error_tests! {
}
test_short_array<[u8; 3]> {
&[
Token::Seq(Some(1)),
Token::Seq { len: Some(1) },
Token::U8(1),
Token::SeqEnd,
],
@ -899,21 +899,21 @@ declare_error_tests! {
}
test_unit_from_empty_seq<()> {
&[
Token::Seq(Some(0)),
Token::Seq { len: Some(0) },
Token::SeqEnd,
],
"invalid type: sequence, expected unit",
}
test_unit_from_empty_seq_without_len<()> {
&[
Token::Seq(None),
Token::Seq { len: None },
Token::SeqEnd,
],
"invalid type: sequence, expected unit",
}
test_unit_from_tuple_struct<()> {
&[
Token::TupleStruct("Anything", 0),
Token::TupleStruct { name: "Anything", len: 0 },
Token::TupleStructEnd,
],
"invalid type: sequence, expected unit",
@ -932,7 +932,7 @@ declare_error_tests! {
}
test_btreeset_from_unit_struct<BTreeSet<isize>> {
&[
Token::UnitStruct("Anything"),
Token::UnitStruct { name: "Anything" },
],
"invalid type: unit value, expected a sequence",
}
@ -944,7 +944,7 @@ declare_error_tests! {
}
test_hashset_from_unit_struct<HashSet<isize>> {
&[
Token::UnitStruct("Anything"),
Token::UnitStruct { name: "Anything" },
],
"invalid type: unit value, expected a sequence",
}
@ -956,7 +956,7 @@ declare_error_tests! {
}
test_vec_from_unit_struct<Vec<isize>> {
&[
Token::UnitStruct("Anything"),
Token::UnitStruct { name: "Anything" },
],
"invalid type: unit value, expected a sequence",
}
@ -968,7 +968,7 @@ declare_error_tests! {
}
test_zero_array_from_unit_struct<[isize; 0]> {
&[
Token::UnitStruct("Anything"),
Token::UnitStruct { name: "Anything" },
],
"invalid type: unit value, expected an empty array",
}
@ -980,7 +980,7 @@ declare_error_tests! {
}
test_btreemap_from_unit_struct<BTreeMap<isize, isize>> {
&[
Token::UnitStruct("Anything"),
Token::UnitStruct { name: "Anything" },
],
"invalid type: unit value, expected a map",
}
@ -992,7 +992,7 @@ declare_error_tests! {
}
test_hashmap_from_unit_struct<HashMap<isize, isize>> {
&[
Token::UnitStruct("Anything"),
Token::UnitStruct { name: "Anything" },
],
"invalid type: unit value, expected a map",
}
@ -1016,7 +1016,7 @@ declare_error_tests! {
}
test_unit_struct_from_seq<UnitStruct> {
&[
Token::Seq(Some(0)),
Token::Seq { len: Some(0) },
Token::SeqEnd,
],
"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]
fn test_named_unit() {
assert_tokens(&NamedUnit, &[Token::UnitStruct("NamedUnit")]);
assert_tokens(&NamedUnit, &[Token::UnitStruct { name: "NamedUnit" }]);
}
#[test]
@ -126,7 +126,7 @@ fn test_ser_named_tuple() {
assert_ser_tokens(
&SerNamedTuple(&a, &mut b, c),
&[
Token::TupleStruct("SerNamedTuple", 3),
Token::TupleStruct { name: "SerNamedTuple", len: 3 },
Token::I32(5),
Token::I32(6),
Token::I32(7),
@ -140,7 +140,7 @@ fn test_de_named_tuple() {
assert_de_tokens(
&DeNamedTuple(5, 6, 7),
&[
Token::Seq(Some(3)),
Token::Seq { len: Some(3) },
Token::I32(5),
Token::I32(6),
Token::I32(7),
@ -151,7 +151,7 @@ fn test_de_named_tuple() {
assert_de_tokens(
&DeNamedTuple(5, 6, 7),
&[
Token::TupleStruct("DeNamedTuple", 3),
Token::TupleStruct { name: "DeNamedTuple", len: 3 },
Token::I32(5),
Token::I32(6),
Token::I32(7),
@ -173,7 +173,7 @@ fn test_ser_named_map() {
c: c,
},
&[
Token::Struct("SerNamedMap", 3),
Token::Struct { name: "SerNamedMap", len: 3 },
Token::Str("a"),
Token::I32(5),
@ -194,7 +194,7 @@ fn test_de_named_map() {
assert_de_tokens(
&DeNamedMap { a: 5, b: 6, c: 7 },
&[
Token::Struct("DeNamedMap", 3),
Token::Struct { name: "DeNamedMap", len: 3 },
Token::Str("a"),
Token::I32(5),
@ -214,7 +214,7 @@ fn test_de_named_map() {
fn test_ser_enum_unit() {
assert_ser_tokens(
&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(
&SerEnum::Seq(a, b, &c, &mut d),
&[
Token::TupleVariant("SerEnum", "Seq", 4),
Token::TupleVariant { name: "SerEnum", variant: "Seq", len: 4 },
Token::I8(1),
Token::I32(2),
Token::I32(3),
@ -253,7 +253,7 @@ fn test_ser_enum_map() {
d: &mut d,
},
&[
Token::StructVariant("SerEnum", "Map", 4),
Token::StructVariant { name: "SerEnum", variant: "Map", len: 4 },
Token::Str("a"),
Token::I8(1),
@ -276,7 +276,7 @@ fn test_ser_enum_map() {
fn test_de_enum_unit() {
assert_tokens(
&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(
&DeEnum::Seq(a, b, c, d),
&[
Token::TupleVariant("DeEnum", "Seq", 4),
Token::TupleVariant { name: "DeEnum", variant: "Seq", len: 4 },
Token::I8(1),
Token::I32(2),
Token::I32(3),
@ -315,7 +315,7 @@ fn test_de_enum_map() {
d: d,
},
&[
Token::StructVariant("DeEnum", "Map", 4),
Token::StructVariant { name: "DeEnum", variant: "Map", len: 4 },
Token::Str("a"),
Token::I8(1),
@ -341,7 +341,7 @@ fn test_lifetimes() {
assert_ser_tokens(
&Lifetimes::LifetimeSeq(&value),
&[
Token::NewtypeVariant("Lifetimes", "LifetimeSeq"),
Token::NewtypeVariant { name: "Lifetimes", variant: "LifetimeSeq" },
Token::I32(5),
],
);
@ -349,7 +349,7 @@ fn test_lifetimes() {
assert_ser_tokens(
&Lifetimes::NoLifetimeSeq(5),
&[
Token::NewtypeVariant("Lifetimes", "NoLifetimeSeq"),
Token::NewtypeVariant { name: "Lifetimes", variant: "NoLifetimeSeq" },
Token::I32(5),
],
);
@ -357,7 +357,7 @@ fn test_lifetimes() {
assert_ser_tokens(
&Lifetimes::LifetimeMap { a: &value },
&[
Token::StructVariant("Lifetimes", "LifetimeMap", 1),
Token::StructVariant { name: "Lifetimes", variant: "LifetimeMap", len: 1 },
Token::Str("a"),
Token::I32(5),
@ -369,7 +369,7 @@ fn test_lifetimes() {
assert_ser_tokens(
&Lifetimes::NoLifetimeMap { a: 5 },
&[
Token::StructVariant("Lifetimes", "NoLifetimeMap", 1),
Token::StructVariant { name: "Lifetimes", variant: "NoLifetimeMap", len: 1 },
Token::Str("a"),
Token::I32(5),
@ -384,7 +384,7 @@ fn test_generic_struct() {
assert_tokens(
&GenericStruct { x: 5u32 },
&[
Token::Struct("GenericStruct", 1),
Token::Struct { name: "GenericStruct", len: 1 },
Token::Str("x"),
Token::U32(5),
@ -398,7 +398,7 @@ fn test_generic_struct() {
fn test_generic_newtype_struct() {
assert_tokens(
&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(
&GenericTupleStruct(5u32, 6u32),
&[
Token::TupleStruct("GenericTupleStruct", 2),
Token::TupleStruct { name: "GenericTupleStruct", len: 2 },
Token::U32(5),
Token::U32(6),
Token::TupleStructEnd,
@ -419,7 +419,7 @@ fn test_generic_tuple_struct() {
fn test_generic_enum_unit() {
assert_tokens(
&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(
&GenericEnum::NewType::<u32, u32>(5),
&[
Token::NewtypeVariant("GenericEnum", "NewType"),
Token::NewtypeVariant { name: "GenericEnum", variant: "NewType" },
Token::U32(5),
],
);
@ -439,7 +439,7 @@ fn test_generic_enum_seq() {
assert_tokens(
&GenericEnum::Seq::<u32, u32>(5, 6),
&[
Token::TupleVariant("GenericEnum", "Seq", 2),
Token::TupleVariant { name: "GenericEnum", variant: "Seq", len: 2 },
Token::U32(5),
Token::U32(6),
Token::TupleVariantEnd,
@ -452,7 +452,7 @@ fn test_generic_enum_map() {
assert_tokens(
&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::U32(5),
@ -470,10 +470,10 @@ fn test_default_ty_param() {
assert_tokens(
&DefaultTyParam::<i32> { phantom: PhantomData },
&[
Token::Struct("DefaultTyParam", 1),
Token::Struct { name: "DefaultTyParam", len: 1 },
Token::Str("phantom"),
Token::UnitStruct("PhantomData"),
Token::UnitStruct { name: "PhantomData" },
Token::StructEnd,
],
@ -493,7 +493,7 @@ fn test_enum_state_field() {
state: true,
},
&[
Token::StructVariant("SomeEnum", "Key", 2),
Token::StructVariant { name: "SomeEnum", variant: "Key", len: 2 },
Token::Str("key"),
Token::Char('a'),
@ -522,7 +522,7 @@ fn test_untagged_enum() {
assert_tokens(
&Untagged::A { a: 1 },
&[
Token::Struct("Untagged", 1),
Token::Struct { name: "Untagged", len: 1 },
Token::Str("a"),
Token::U8(1),
@ -534,7 +534,7 @@ fn test_untagged_enum() {
assert_tokens(
&Untagged::B { b: 2 },
&[
Token::Struct("Untagged", 1),
Token::Struct { name: "Untagged", len: 1 },
Token::Str("b"),
Token::U8(2),
@ -550,7 +550,7 @@ fn test_untagged_enum() {
assert_tokens(
&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>(
@ -559,13 +559,13 @@ fn test_untagged_enum() {
);
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",
);
assert_de_tokens_error::<Untagged>(
&[
Token::Tuple(3),
Token::Tuple { len: 3 },
Token::U8(1),
Token::U8(2),
Token::U8(3),
@ -599,7 +599,7 @@ fn test_internally_tagged_enum() {
assert_tokens(
&InternallyTagged::A { a: 1 },
&[
Token::Struct("InternallyTagged", 2),
Token::Struct { name: "InternallyTagged", len: 2 },
Token::Str("type"),
Token::Str("A"),
@ -614,7 +614,7 @@ fn test_internally_tagged_enum() {
assert_tokens(
&InternallyTagged::B { b: 2 },
&[
Token::Struct("InternallyTagged", 2),
Token::Struct { name: "InternallyTagged", len: 2 },
Token::Str("type"),
Token::Str("B"),
@ -629,7 +629,7 @@ fn test_internally_tagged_enum() {
assert_tokens(
&InternallyTagged::C,
&[
Token::Struct("InternallyTagged", 1),
Token::Struct { name: "InternallyTagged", len: 1 },
Token::Str("type"),
Token::Str("C"),
@ -641,7 +641,7 @@ fn test_internally_tagged_enum() {
assert_tokens(
&InternallyTagged::D(BTreeMap::new()),
&[
Token::Map(Some(1)),
Token::Map { len: Some(1) },
Token::Str("type"),
Token::Str("D"),
@ -653,7 +653,7 @@ fn test_internally_tagged_enum() {
assert_tokens(
&InternallyTagged::E(Newtype(BTreeMap::new())),
&[
Token::Map(Some(1)),
Token::Map { len: Some(1) },
Token::Str("type"),
Token::Str("E"),
@ -665,7 +665,7 @@ fn test_internally_tagged_enum() {
assert_tokens(
&InternallyTagged::F(Struct { f: 6 }),
&[
Token::Struct("Struct", 2),
Token::Struct { name: "Struct", len: 2 },
Token::Str("type"),
Token::Str("F"),
@ -678,13 +678,13 @@ fn test_internally_tagged_enum() {
);
assert_de_tokens_error::<InternallyTagged>(
&[Token::Map(Some(0)), Token::MapEnd],
&[Token::Map { len: Some(0) }, Token::MapEnd],
"missing field `type`",
);
assert_de_tokens_error::<InternallyTagged>(
&[
Token::Map(Some(1)),
Token::Map { len: Some(1) },
Token::Str("type"),
Token::Str("Z"),
@ -710,7 +710,7 @@ fn test_adjacently_tagged_enum() {
assert_tokens(
&AdjacentlyTagged::Unit::<u8>,
&[
Token::Struct("AdjacentlyTagged", 1),
Token::Struct { name: "AdjacentlyTagged", len: 1 },
Token::Str("t"),
Token::Str("Unit"),
@ -723,7 +723,7 @@ fn test_adjacently_tagged_enum() {
assert_de_tokens(
&AdjacentlyTagged::Unit::<u8>,
&[
Token::Struct("AdjacentlyTagged", 1),
Token::Struct { name: "AdjacentlyTagged", len: 1 },
Token::Str("t"),
Token::Str("Unit"),
@ -739,7 +739,7 @@ fn test_adjacently_tagged_enum() {
assert_de_tokens(
&AdjacentlyTagged::Unit::<u8>,
&[
Token::Struct("AdjacentlyTagged", 1),
Token::Struct { name: "AdjacentlyTagged", len: 1 },
Token::Str("c"),
Token::Unit,
@ -755,7 +755,7 @@ fn test_adjacently_tagged_enum() {
assert_tokens(
&AdjacentlyTagged::Newtype::<u8>(1),
&[
Token::Struct("AdjacentlyTagged", 2),
Token::Struct { name: "AdjacentlyTagged", len: 2 },
Token::Str("t"),
Token::Str("Newtype"),
@ -771,7 +771,7 @@ fn test_adjacently_tagged_enum() {
assert_de_tokens(
&AdjacentlyTagged::Newtype::<u8>(1),
&[
Token::Struct("AdjacentlyTagged", 2),
Token::Struct { name: "AdjacentlyTagged", len: 2 },
Token::Str("c"),
Token::U8(1),
@ -787,13 +787,13 @@ fn test_adjacently_tagged_enum() {
assert_tokens(
&AdjacentlyTagged::Tuple::<u8>(1, 1),
&[
Token::Struct("AdjacentlyTagged", 2),
Token::Struct { name: "AdjacentlyTagged", len: 2 },
Token::Str("t"),
Token::Str("Tuple"),
Token::Str("c"),
Token::Tuple(2),
Token::Tuple { len: 2 },
Token::U8(1),
Token::U8(1),
Token::TupleEnd,
@ -806,10 +806,10 @@ fn test_adjacently_tagged_enum() {
assert_de_tokens(
&AdjacentlyTagged::Tuple::<u8>(1, 1),
&[
Token::Struct("AdjacentlyTagged", 2),
Token::Struct { name: "AdjacentlyTagged", len: 2 },
Token::Str("c"),
Token::Tuple(2),
Token::Tuple { len: 2 },
Token::U8(1),
Token::U8(1),
Token::TupleEnd,
@ -825,13 +825,13 @@ fn test_adjacently_tagged_enum() {
assert_tokens(
&AdjacentlyTagged::Struct::<u8> { f: 1 },
&[
Token::Struct("AdjacentlyTagged", 2),
Token::Struct { name: "AdjacentlyTagged", len: 2 },
Token::Str("t"),
Token::Str("Struct"),
Token::Str("c"),
Token::Struct("Struct", 1),
Token::Struct { name: "Struct", len: 1 },
Token::Str("f"),
Token::U8(1),
Token::StructEnd,
@ -844,10 +844,10 @@ fn test_adjacently_tagged_enum() {
assert_de_tokens(
&AdjacentlyTagged::Struct::<u8> { f: 1 },
&[
Token::Struct("AdjacentlyTagged", 2),
Token::Struct { name: "AdjacentlyTagged", len: 2 },
Token::Str("c"),
Token::Struct("Struct", 1),
Token::Struct { name: "Struct", len: 1 },
Token::Str("f"),
Token::U8(1),
Token::StructEnd,
@ -879,7 +879,7 @@ fn test_enum_in_internally_tagged_enum() {
assert_tokens(
&Outer::Inner(Inner::Unit),
&[
Token::Map(Some(2)),
Token::Map { len: Some(2) },
Token::Str("type"),
Token::Str("Inner"),
@ -894,7 +894,7 @@ fn test_enum_in_internally_tagged_enum() {
assert_tokens(
&Outer::Inner(Inner::Newtype(1)),
&[
Token::Map(Some(2)),
Token::Map { len: Some(2) },
Token::Str("type"),
Token::Str("Inner"),
@ -909,13 +909,13 @@ fn test_enum_in_internally_tagged_enum() {
assert_tokens(
&Outer::Inner(Inner::Tuple(1, 1)),
&[
Token::Map(Some(2)),
Token::Map { len: Some(2) },
Token::Str("type"),
Token::Str("Inner"),
Token::Str("Tuple"),
Token::TupleStruct("Tuple", 2),
Token::TupleStruct { name: "Tuple", len: 2 },
Token::U8(1),
Token::U8(1),
Token::TupleStructEnd,
@ -927,13 +927,13 @@ fn test_enum_in_internally_tagged_enum() {
assert_tokens(
&Outer::Inner(Inner::Struct { f: 1 }),
&[
Token::Map(Some(2)),
Token::Map { len: Some(2) },
Token::Str("type"),
Token::Str("Inner"),
Token::Str("Struct"),
Token::Struct("Struct", 1),
Token::Struct { name: "Struct", len: 1 },
Token::Str("f"),
Token::U8(1),
Token::StructEnd,
@ -961,18 +961,18 @@ fn test_enum_in_untagged_enum() {
assert_tokens(
&Outer::Inner(Inner::Unit),
&[Token::UnitVariant("Inner", "Unit")],
&[Token::UnitVariant { name: "Inner", variant: "Unit" }],
);
assert_tokens(
&Outer::Inner(Inner::Newtype(1)),
&[Token::NewtypeVariant("Inner", "Newtype"), Token::U8(1)],
&[Token::NewtypeVariant { name: "Inner", variant: "Newtype" }, Token::U8(1)],
);
assert_tokens(
&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::TupleVariantEnd,
@ -982,7 +982,7 @@ fn test_enum_in_untagged_enum() {
assert_tokens(
&Outer::Inner(Inner::Struct { f: 1 }),
&[
Token::StructVariant("Inner", "Struct", 1),
Token::StructVariant { name: "Inner", variant: "Struct", len: 1 },
Token::Str("f"),
Token::U8(1),
@ -1027,7 +1027,7 @@ fn test_rename_all() {
serialize_seq: true,
},
&[
Token::StructVariant("E", "serialize", 2),
Token::StructVariant { name: "E", variant: "serialize", len: 2 },
Token::Str("serialize"),
Token::Bool(true),
Token::Str("serializeSeq"),
@ -1042,7 +1042,7 @@ fn test_rename_all() {
serialize_seq: true,
},
&[
Token::StructVariant("E", "serialize_seq", 2),
Token::StructVariant { name: "E", variant: "serialize_seq", len: 2 },
Token::Str("serialize"),
Token::Bool(true),
Token::Str("serialize-seq"),
@ -1057,7 +1057,7 @@ fn test_rename_all() {
serialize_seq: true,
},
&[
Token::StructVariant("E", "serialize_map", 2),
Token::StructVariant { name: "E", variant: "serialize_map", len: 2 },
Token::Str("SERIALIZE"),
Token::Bool(true),
Token::Str("SERIALIZE_SEQ"),
@ -1072,7 +1072,7 @@ fn test_rename_all() {
serialize_seq: true,
},
&[
Token::Struct("S", 2),
Token::Struct { name: "S", len: 2 },
Token::Str("Serialize"),
Token::Bool(true),
Token::Str("SerializeSeq"),

68
test_suite/tests/test_ser.rs
View File

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