Update token names in test suite
This commit is contained in:
David Tolnay
parent
826b53f691
commit
51d3fb1ebc
@ -85,7 +85,7 @@ fn test_default_struct() {
|
||||
assert_de_tokens(
|
||||
&DefaultStruct { a1: 1, a2: 2, a3: 3, a4: 0, a5: 123 },
|
||||
&[
|
||||
Token::StructStart("DefaultStruct", 3),
|
||||
Token::Struct("DefaultStruct", 3),
|
||||
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
@ -109,7 +109,7 @@ fn test_default_struct() {
|
||||
assert_de_tokens(
|
||||
&DefaultStruct { a1: 1, a2: 0, a3: 123, a4: 0, a5: 123 },
|
||||
&[
|
||||
Token::StructStart("DefaultStruct", 1),
|
||||
Token::Struct("DefaultStruct", 1),
|
||||
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
@ -142,7 +142,7 @@ fn test_default_enum() {
|
||||
assert_de_tokens(
|
||||
&DefaultEnum::Struct { a1: 1, a2: 2, a3: 3, a4: 0, a5: 123 },
|
||||
&[
|
||||
Token::EnumMapStart("DefaultEnum", "Struct", 3),
|
||||
Token::StructVariant("DefaultEnum", "Struct", 3),
|
||||
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
@ -159,19 +159,19 @@ fn test_default_enum() {
|
||||
Token::Str("a5"),
|
||||
Token::I32(5),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_de_tokens(
|
||||
&DefaultEnum::Struct { a1: 1, a2: 0, a3: 123, a4: 0, a5: 123 },
|
||||
&[
|
||||
Token::EnumMapStart("DefaultEnum", "Struct", 3),
|
||||
Token::StructVariant("DefaultEnum", "Struct", 3),
|
||||
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
@ -199,7 +199,7 @@ fn test_no_std_default() {
|
||||
assert_de_tokens(
|
||||
&ContainsNoStdDefault { a: NoStdDefault(123) },
|
||||
&[
|
||||
Token::StructStart("ContainsNoStdDefault", 1),
|
||||
Token::Struct("ContainsNoStdDefault", 1),
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
@ -207,10 +207,10 @@ fn test_no_std_default() {
|
||||
assert_de_tokens(
|
||||
&ContainsNoStdDefault { a: NoStdDefault(8) },
|
||||
&[
|
||||
Token::StructStart("ContainsNoStdDefault", 1),
|
||||
Token::Struct("ContainsNoStdDefault", 1),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::StructNewType("NoStdDefault"),
|
||||
Token::NewtypeStruct("NoStdDefault"),
|
||||
Token::I8(8),
|
||||
|
||||
Token::StructEnd,
|
||||
@ -271,7 +271,7 @@ fn test_elt_not_deserialize() {
|
||||
e: NotDeserializeEnum::Trouble,
|
||||
},
|
||||
&[
|
||||
Token::StructStart("ContainsNotDeserialize", 3),
|
||||
Token::Struct("ContainsNotDeserialize", 3),
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
@ -289,7 +289,7 @@ fn test_ignore_unknown() {
|
||||
assert_de_tokens(
|
||||
&DefaultStruct { a1: 1, a2: 2, a3: 3, a4: 0, a5: 123 },
|
||||
&[
|
||||
Token::StructStart("DefaultStruct", 5),
|
||||
Token::Struct("DefaultStruct", 5),
|
||||
|
||||
Token::Str("whoops1"),
|
||||
Token::I32(2),
|
||||
@ -298,7 +298,7 @@ fn test_ignore_unknown() {
|
||||
Token::I32(1),
|
||||
|
||||
Token::Str("whoops2"),
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::Seq(Some(1)),
|
||||
Token::I32(2),
|
||||
Token::SeqEnd,
|
||||
|
||||
@ -317,7 +317,7 @@ fn test_ignore_unknown() {
|
||||
|
||||
assert_de_tokens_error::<DenyUnknown>(
|
||||
&[
|
||||
Token::StructStart("DenyUnknown", 2),
|
||||
Token::Struct("DenyUnknown", 2),
|
||||
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
@ -349,7 +349,7 @@ fn test_rename_struct() {
|
||||
assert_tokens(
|
||||
&RenameStruct { a1: 1, a2: 2 },
|
||||
&[
|
||||
Token::StructStart("Superhero", 2),
|
||||
Token::Struct("Superhero", 2),
|
||||
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
@ -364,7 +364,7 @@ fn test_rename_struct() {
|
||||
assert_ser_tokens(
|
||||
&RenameStructSerializeDeserialize { a1: 1, a2: 2 },
|
||||
&[
|
||||
Token::StructStart("SuperheroSer", 2),
|
||||
Token::Struct("SuperheroSer", 2),
|
||||
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
@ -379,7 +379,7 @@ fn test_rename_struct() {
|
||||
assert_de_tokens(
|
||||
&RenameStructSerializeDeserialize { a1: 1, a2: 2 },
|
||||
&[
|
||||
Token::StructStart("SuperheroDe", 2),
|
||||
Token::Struct("SuperheroDe", 2),
|
||||
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
@ -425,14 +425,14 @@ fn test_rename_enum() {
|
||||
assert_tokens(
|
||||
&RenameEnum::Batman,
|
||||
&[
|
||||
Token::EnumUnit("Superhero", "bruce_wayne"),
|
||||
Token::UnitVariant("Superhero", "bruce_wayne"),
|
||||
]
|
||||
);
|
||||
|
||||
assert_tokens(
|
||||
&RenameEnum::Superman(0),
|
||||
&[
|
||||
Token::EnumNewType("Superhero", "clark_kent"),
|
||||
Token::NewtypeVariant("Superhero", "clark_kent"),
|
||||
Token::I8(0),
|
||||
]
|
||||
);
|
||||
@ -440,22 +440,22 @@ fn test_rename_enum() {
|
||||
assert_tokens(
|
||||
&RenameEnum::WonderWoman(0, 1),
|
||||
&[
|
||||
Token::EnumSeqStart("Superhero", "diana_prince", 2),
|
||||
Token::TupleVariant("Superhero", "diana_prince", 2),
|
||||
Token::I8(0),
|
||||
Token::I8(1),
|
||||
Token::EnumSeqEnd,
|
||||
Token::TupleVariantEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_tokens(
|
||||
&RenameEnum::Flash { a: 1 },
|
||||
&[
|
||||
Token::EnumMapStart("Superhero", "barry_allan", 1),
|
||||
Token::StructVariant("Superhero", "barry_allan", 1),
|
||||
|
||||
Token::Str("b"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
|
||||
@ -465,7 +465,7 @@ fn test_rename_enum() {
|
||||
b: String::new(),
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("SuperheroSer", "dick_grayson", 2),
|
||||
Token::StructVariant("SuperheroSer", "dick_grayson", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(0),
|
||||
@ -473,7 +473,7 @@ fn test_rename_enum() {
|
||||
Token::Str("c"),
|
||||
Token::Str(""),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
|
||||
@ -483,7 +483,7 @@ fn test_rename_enum() {
|
||||
b: String::new(),
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("SuperheroDe", "jason_todd", 2),
|
||||
Token::StructVariant("SuperheroDe", "jason_todd", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(0),
|
||||
@ -491,7 +491,7 @@ fn test_rename_enum() {
|
||||
Token::Str("d"),
|
||||
Token::Str(""),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
@ -515,7 +515,7 @@ fn test_skip_serializing_struct() {
|
||||
c: 3,
|
||||
},
|
||||
&[
|
||||
Token::StructStart("SkipSerializingStruct", 2),
|
||||
Token::Struct("SkipSerializingStruct", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
@ -534,7 +534,7 @@ fn test_skip_serializing_struct() {
|
||||
c: 123,
|
||||
},
|
||||
&[
|
||||
Token::StructStart("SkipSerializingStruct", 1),
|
||||
Token::Struct("SkipSerializingStruct", 1),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
@ -565,7 +565,7 @@ fn test_skip_serializing_enum() {
|
||||
c: 3,
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("SkipSerializingEnum", "Struct", 2),
|
||||
Token::StructVariant("SkipSerializingEnum", "Struct", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
@ -573,7 +573,7 @@ fn test_skip_serializing_enum() {
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
|
||||
@ -584,12 +584,12 @@ fn test_skip_serializing_enum() {
|
||||
c: 123,
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("SkipSerializingEnum", "Struct", 1),
|
||||
Token::StructVariant("SkipSerializingEnum", "Struct", 1),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
@ -630,10 +630,10 @@ fn test_elt_not_serialize() {
|
||||
d: NotSerializeEnum::Trouble,
|
||||
},
|
||||
&[
|
||||
Token::StructStart("ContainsNotSerialize", 2),
|
||||
Token::Struct("ContainsNotSerialize", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::Option(true),
|
||||
Token::Some,
|
||||
Token::I8(1),
|
||||
|
||||
Token::Str("d"),
|
||||
@ -660,7 +660,7 @@ fn test_serialize_with_struct() {
|
||||
b: 2,
|
||||
},
|
||||
&[
|
||||
Token::StructStart("SerializeWithStruct", 2),
|
||||
Token::Struct("SerializeWithStruct", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
@ -678,7 +678,7 @@ fn test_serialize_with_struct() {
|
||||
b: 123,
|
||||
},
|
||||
&[
|
||||
Token::StructStart("SerializeWithStruct", 2),
|
||||
Token::Struct("SerializeWithStruct", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
@ -709,7 +709,7 @@ fn test_serialize_with_enum() {
|
||||
b: 2,
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("SerializeWithEnum", "Struct", 2),
|
||||
Token::StructVariant("SerializeWithEnum", "Struct", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
@ -717,7 +717,7 @@ fn test_serialize_with_enum() {
|
||||
Token::Str("b"),
|
||||
Token::Bool(false),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
|
||||
@ -727,7 +727,7 @@ fn test_serialize_with_enum() {
|
||||
b: 123,
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("SerializeWithEnum", "Struct", 2),
|
||||
Token::StructVariant("SerializeWithEnum", "Struct", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
@ -735,7 +735,7 @@ fn test_serialize_with_enum() {
|
||||
Token::Str("b"),
|
||||
Token::Bool(true),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
@ -755,7 +755,7 @@ fn test_deserialize_with_struct() {
|
||||
b: 2,
|
||||
},
|
||||
&[
|
||||
Token::StructStart("DeserializeWithStruct", 2),
|
||||
Token::Struct("DeserializeWithStruct", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
@ -773,7 +773,7 @@ fn test_deserialize_with_struct() {
|
||||
b: 123,
|
||||
},
|
||||
&[
|
||||
Token::StructStart("DeserializeWithStruct", 2),
|
||||
Token::Struct("DeserializeWithStruct", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
@ -803,7 +803,7 @@ fn test_deserialize_with_enum() {
|
||||
b: 2,
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("DeserializeWithEnum", "Struct", 2),
|
||||
Token::StructVariant("DeserializeWithEnum", "Struct", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
@ -811,7 +811,7 @@ fn test_deserialize_with_enum() {
|
||||
Token::Str("b"),
|
||||
Token::Bool(false),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
|
||||
@ -821,7 +821,7 @@ fn test_deserialize_with_enum() {
|
||||
b: 123,
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("DeserializeWithEnum", "Struct", 2),
|
||||
Token::StructVariant("DeserializeWithEnum", "Struct", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
@ -829,7 +829,7 @@ fn test_deserialize_with_enum() {
|
||||
Token::Str("b"),
|
||||
Token::Bool(true),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
@ -838,7 +838,7 @@ fn test_deserialize_with_enum() {
|
||||
fn test_missing_renamed_field_struct() {
|
||||
assert_de_tokens_error::<RenameStruct>(
|
||||
&[
|
||||
Token::StructStart("Superhero", 2),
|
||||
Token::Struct("Superhero", 2),
|
||||
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
@ -850,7 +850,7 @@ fn test_missing_renamed_field_struct() {
|
||||
|
||||
assert_de_tokens_error::<RenameStructSerializeDeserialize>(
|
||||
&[
|
||||
Token::StructStart("SuperheroDe", 2),
|
||||
Token::Struct("SuperheroDe", 2),
|
||||
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
@ -865,21 +865,21 @@ fn test_missing_renamed_field_struct() {
|
||||
fn test_missing_renamed_field_enum() {
|
||||
assert_de_tokens_error::<RenameEnum>(
|
||||
&[
|
||||
Token::EnumMapStart("Superhero", "barry_allan", 1),
|
||||
Token::StructVariant("Superhero", "barry_allan", 1),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
],
|
||||
Error::Message("missing field `b`".to_owned()),
|
||||
);
|
||||
|
||||
assert_de_tokens_error::<RenameEnumSerializeDeserialize<i8>>(
|
||||
&[
|
||||
Token::EnumMapStart("SuperheroDe", "jason_todd", 2),
|
||||
Token::StructVariant("SuperheroDe", "jason_todd", 2),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(0),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
],
|
||||
Error::Message("missing field `d`".to_owned()),
|
||||
);
|
||||
@ -895,17 +895,17 @@ enum InvalidLengthEnum {
|
||||
fn test_invalid_length_enum() {
|
||||
assert_de_tokens_error::<InvalidLengthEnum>(
|
||||
&[
|
||||
Token::EnumSeqStart("InvalidLengthEnum", "A", 3),
|
||||
Token::TupleVariant("InvalidLengthEnum", "A", 3),
|
||||
Token::I32(1),
|
||||
Token::EnumSeqEnd,
|
||||
Token::TupleVariantEnd,
|
||||
],
|
||||
Error::Message("invalid length 1, expected tuple of 3 elements".to_owned()),
|
||||
);
|
||||
assert_de_tokens_error::<InvalidLengthEnum>(
|
||||
&[
|
||||
Token::EnumSeqStart("InvalidLengthEnum", "B", 3),
|
||||
Token::TupleVariant("InvalidLengthEnum", "B", 3),
|
||||
Token::I32(1),
|
||||
Token::EnumSeqEnd,
|
||||
Token::TupleVariantEnd,
|
||||
],
|
||||
Error::Message("invalid length 1, expected tuple of 2 elements".to_owned()),
|
||||
);
|
||||
@ -966,26 +966,26 @@ impl From<Option<u32>> for EnumToU32 {
|
||||
#[test]
|
||||
fn test_from_into_traits() {
|
||||
assert_ser_tokens::<EnumToU32>(&EnumToU32::One,
|
||||
&[Token::Option(true),
|
||||
&[Token::Some,
|
||||
Token::U32(1)
|
||||
]
|
||||
);
|
||||
assert_ser_tokens::<EnumToU32>(&EnumToU32::Nothing,
|
||||
&[Token::Option(false)]
|
||||
&[Token::None]
|
||||
);
|
||||
assert_de_tokens::<EnumToU32>(&EnumToU32::Two,
|
||||
&[Token::Option(true),
|
||||
&[Token::Some,
|
||||
Token::U32(2)
|
||||
]
|
||||
);
|
||||
assert_ser_tokens::<StructFromEnum>(&StructFromEnum(Some(5)),
|
||||
&[Token::Option(false)]
|
||||
&[Token::None]
|
||||
);
|
||||
assert_ser_tokens::<StructFromEnum>(&StructFromEnum(None),
|
||||
&[Token::Option(false)]
|
||||
&[Token::None]
|
||||
);
|
||||
assert_de_tokens::<StructFromEnum>(&StructFromEnum(Some(2)),
|
||||
&[Token::Option(true),
|
||||
&[Token::Some,
|
||||
Token::U32(2)
|
||||
]
|
||||
);
|
||||
|
||||
@ -89,7 +89,7 @@ fn test_tuple() {
|
||||
assert_de_tokens(
|
||||
&("str", &b"bytes"[..]),
|
||||
&[
|
||||
Token::TupleStart(2),
|
||||
Token::Tuple(2),
|
||||
Token::BorrowedStr("str"),
|
||||
Token::BorrowedBytes(b"bytes"),
|
||||
Token::TupleEnd,
|
||||
@ -108,7 +108,7 @@ fn test_struct() {
|
||||
assert_de_tokens(
|
||||
&Borrowing { bs: "str", bb: b"bytes" },
|
||||
&[
|
||||
Token::StructStart("Borrowing", 2),
|
||||
Token::Struct("Borrowing", 2),
|
||||
|
||||
Token::BorrowedStr("bs"),
|
||||
Token::BorrowedStr("str"),
|
||||
@ -132,7 +132,7 @@ fn test_cow() {
|
||||
}
|
||||
|
||||
let tokens = &[
|
||||
Token::StructStart("Cows", 2),
|
||||
Token::Struct("Cows", 2),
|
||||
|
||||
Token::Str("copied"),
|
||||
Token::BorrowedStr("copied"),
|
||||
|
||||
@ -22,11 +22,11 @@ fn test_byte_buf() {
|
||||
assert_de_tokens(&empty, &[Token::Str("")]);
|
||||
assert_de_tokens(&empty, &[Token::String("")]);
|
||||
assert_de_tokens(&empty, &[
|
||||
Token::SeqStart(None),
|
||||
Token::Seq(None),
|
||||
Token::SeqEnd,
|
||||
]);
|
||||
assert_de_tokens(&empty, &[
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
]);
|
||||
|
||||
@ -36,14 +36,14 @@ fn test_byte_buf() {
|
||||
assert_de_tokens(&buf, &[Token::Str("ABC")]);
|
||||
assert_de_tokens(&buf, &[Token::String("ABC")]);
|
||||
assert_de_tokens(&buf, &[
|
||||
Token::SeqStart(None),
|
||||
Token::Seq(None),
|
||||
Token::U8(65),
|
||||
Token::U8(66),
|
||||
Token::U8(67),
|
||||
Token::SeqEnd,
|
||||
]);
|
||||
assert_de_tokens(&buf, &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::Seq(Some(3)),
|
||||
Token::U8(65),
|
||||
Token::U8(66),
|
||||
Token::U8(67),
|
||||
|
||||
@ -151,7 +151,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::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
@ -218,20 +218,20 @@ declare_tests! {
|
||||
}
|
||||
test_option {
|
||||
None::<i32> => &[Token::Unit],
|
||||
None::<i32> => &[Token::Option(false)],
|
||||
None::<i32> => &[Token::None],
|
||||
Some(1) => &[
|
||||
Token::Option(true),
|
||||
Token::Some,
|
||||
Token::I32(1),
|
||||
],
|
||||
}
|
||||
test_result {
|
||||
Ok::<i32, i32>(0) => &[
|
||||
Token::EnumStart("Result"),
|
||||
Token::Enum("Result"),
|
||||
Token::Str("Ok"),
|
||||
Token::I32(0),
|
||||
],
|
||||
Err::<i32, i32>(1) => &[
|
||||
Token::EnumStart("Result"),
|
||||
Token::Enum("Result"),
|
||||
Token::Str("Err"),
|
||||
Token::I32(1),
|
||||
],
|
||||
@ -245,44 +245,44 @@ declare_tests! {
|
||||
Token::UnitStruct("UnitStruct"),
|
||||
],
|
||||
UnitStruct => &[
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
UnitStruct => &[
|
||||
Token::SeqStart(None),
|
||||
Token::Seq(None),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_newtype_struct {
|
||||
NewtypeStruct(1) => &[
|
||||
Token::StructNewType("NewtypeStruct"),
|
||||
Token::NewtypeStruct("NewtypeStruct"),
|
||||
Token::I32(1),
|
||||
],
|
||||
}
|
||||
test_tuple_struct {
|
||||
TupleStruct(1, 2, 3) => &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::Seq(Some(3)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
TupleStruct(1, 2, 3) => &[
|
||||
Token::SeqStart(None),
|
||||
Token::Seq(None),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
TupleStruct(1, 2, 3) => &[
|
||||
Token::TupleStructStart("TupleStruct", 3),
|
||||
Token::TupleStruct("TupleStruct", 3),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
Token::TupleStructEnd,
|
||||
],
|
||||
TupleStruct(1, 2, 3) => &[
|
||||
Token::TupleStructStart("TupleStruct", 3),
|
||||
Token::TupleStruct("TupleStruct", 3),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
@ -291,47 +291,47 @@ declare_tests! {
|
||||
}
|
||||
test_btreeset {
|
||||
BTreeSet::<isize>::new() => &[
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
btreeset![btreeset![], btreeset![1], btreeset![2, 3]] => &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(3)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::Seq(Some(1)),
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqStart(Some(2)),
|
||||
Token::Seq(Some(2)),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::SeqEnd,
|
||||
],
|
||||
BTreeSet::<isize>::new() => &[
|
||||
Token::TupleStructStart("Anything", 0),
|
||||
Token::TupleStruct("Anything", 0),
|
||||
Token::TupleStructEnd,
|
||||
],
|
||||
}
|
||||
test_hashset {
|
||||
HashSet::<isize>::new() => &[
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
hashset![1, 2, 3] => &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::Seq(Some(3)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
HashSet::<isize>::new() => &[
|
||||
Token::TupleStructStart("Anything", 0),
|
||||
Token::TupleStruct("Anything", 0),
|
||||
Token::TupleStructEnd,
|
||||
],
|
||||
hashset![FnvHasher @ 1, 2, 3] => &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::Seq(Some(3)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
@ -340,93 +340,93 @@ declare_tests! {
|
||||
}
|
||||
test_vec {
|
||||
Vec::<isize>::new() => &[
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
vec![vec![], vec![1], vec![2, 3]] => &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(3)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::Seq(Some(1)),
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqStart(Some(2)),
|
||||
Token::Seq(Some(2)),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::SeqEnd,
|
||||
],
|
||||
Vec::<isize>::new() => &[
|
||||
Token::TupleStructStart("Anything", 0),
|
||||
Token::TupleStruct("Anything", 0),
|
||||
Token::TupleStructEnd,
|
||||
],
|
||||
}
|
||||
test_array {
|
||||
[0; 0] => &[
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
[0; 0] => &[
|
||||
Token::SeqArrayStart(0),
|
||||
Token::SeqFixedSize(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
([0; 0], [1], [2, 3]) => &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(3)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::Seq(Some(1)),
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqStart(Some(2)),
|
||||
Token::Seq(Some(2)),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::SeqEnd,
|
||||
],
|
||||
([0; 0], [1], [2, 3]) => &[
|
||||
Token::SeqArrayStart(3),
|
||||
Token::SeqArrayStart(0),
|
||||
Token::SeqFixedSize(3),
|
||||
Token::SeqFixedSize(0),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqArrayStart(1),
|
||||
Token::SeqFixedSize(1),
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqArrayStart(2),
|
||||
Token::SeqFixedSize(2),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::SeqEnd,
|
||||
],
|
||||
[0; 0] => &[
|
||||
Token::TupleStructStart("Anything", 0),
|
||||
Token::TupleStruct("Anything", 0),
|
||||
Token::TupleStructEnd,
|
||||
],
|
||||
}
|
||||
test_tuple {
|
||||
(1,) => &[
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::Seq(Some(1)),
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
(1, 2, 3) => &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::Seq(Some(3)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
(1,) => &[
|
||||
Token::TupleStart(1),
|
||||
Token::Tuple(1),
|
||||
Token::I32(1),
|
||||
Token::TupleEnd,
|
||||
],
|
||||
(1, 2, 3) => &[
|
||||
Token::TupleStart(3),
|
||||
Token::Tuple(3),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
@ -435,17 +435,17 @@ declare_tests! {
|
||||
}
|
||||
test_btreemap {
|
||||
BTreeMap::<isize, isize>::new() => &[
|
||||
Token::MapStart(Some(0)),
|
||||
Token::Map(Some(0)),
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => 2] => &[
|
||||
Token::MapStart(Some(1)),
|
||||
Token::Map(Some(1)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => 2, 3 => 4] => &[
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
|
||||
@ -454,13 +454,13 @@ declare_tests! {
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => &[
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
Token::I32(1),
|
||||
Token::MapStart(Some(0)),
|
||||
Token::Map(Some(0)),
|
||||
Token::MapEnd,
|
||||
|
||||
Token::I32(2),
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
|
||||
@ -470,23 +470,23 @@ declare_tests! {
|
||||
Token::MapEnd,
|
||||
],
|
||||
BTreeMap::<isize, isize>::new() => &[
|
||||
Token::StructStart("Anything", 0),
|
||||
Token::Struct("Anything", 0),
|
||||
Token::StructEnd,
|
||||
],
|
||||
}
|
||||
test_hashmap {
|
||||
HashMap::<isize, isize>::new() => &[
|
||||
Token::MapStart(Some(0)),
|
||||
Token::Map(Some(0)),
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![1 => 2] => &[
|
||||
Token::MapStart(Some(1)),
|
||||
Token::Map(Some(1)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![1 => 2, 3 => 4] => &[
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
|
||||
@ -495,13 +495,13 @@ declare_tests! {
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]] => &[
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
Token::I32(1),
|
||||
Token::MapStart(Some(0)),
|
||||
Token::Map(Some(0)),
|
||||
Token::MapEnd,
|
||||
|
||||
Token::I32(2),
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
|
||||
@ -511,11 +511,11 @@ declare_tests! {
|
||||
Token::MapEnd,
|
||||
],
|
||||
HashMap::<isize, isize>::new() => &[
|
||||
Token::StructStart("Anything", 0),
|
||||
Token::Struct("Anything", 0),
|
||||
Token::StructEnd,
|
||||
],
|
||||
hashmap![FnvHasher @ 1 => 2, 3 => 4] => &[
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
|
||||
@ -526,7 +526,7 @@ declare_tests! {
|
||||
}
|
||||
test_struct {
|
||||
Struct { a: 1, b: 2, c: 0 } => &[
|
||||
Token::MapStart(Some(3)),
|
||||
Token::Map(Some(3)),
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
@ -535,7 +535,7 @@ declare_tests! {
|
||||
Token::MapEnd,
|
||||
],
|
||||
Struct { a: 1, b: 2, c: 0 } => &[
|
||||
Token::StructStart("Struct", 3),
|
||||
Token::Struct("Struct", 3),
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
@ -544,7 +544,7 @@ declare_tests! {
|
||||
Token::StructEnd,
|
||||
],
|
||||
Struct { a: 1, b: 2, c: 0 } => &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::Seq(Some(3)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::SeqEnd,
|
||||
@ -552,7 +552,7 @@ declare_tests! {
|
||||
}
|
||||
test_struct_with_skip {
|
||||
Struct { a: 1, b: 2, c: 0 } => &[
|
||||
Token::MapStart(Some(3)),
|
||||
Token::Map(Some(3)),
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
@ -567,7 +567,7 @@ declare_tests! {
|
||||
Token::MapEnd,
|
||||
],
|
||||
Struct { a: 1, b: 2, c: 0 } => &[
|
||||
Token::StructStart("Struct", 3),
|
||||
Token::Struct("Struct", 3),
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
@ -584,11 +584,11 @@ declare_tests! {
|
||||
}
|
||||
test_struct_skip_all {
|
||||
StructSkipAll { a: 0 } => &[
|
||||
Token::StructStart("StructSkipAll", 0),
|
||||
Token::Struct("StructSkipAll", 0),
|
||||
Token::StructEnd,
|
||||
],
|
||||
StructSkipAll { a: 0 } => &[
|
||||
Token::StructStart("StructSkipAll", 1),
|
||||
Token::Struct("StructSkipAll", 1),
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
@ -599,13 +599,13 @@ declare_tests! {
|
||||
}
|
||||
test_struct_skip_all_deny_unknown {
|
||||
StructSkipAllDenyUnknown { a: 0 } => &[
|
||||
Token::StructStart("StructSkipAllDenyUnknown", 0),
|
||||
Token::Struct("StructSkipAllDenyUnknown", 0),
|
||||
Token::StructEnd,
|
||||
],
|
||||
}
|
||||
test_struct_default {
|
||||
StructDefault { a: 50, b: "overwritten".to_string() } => &[
|
||||
Token::StructStart("StructDefault", 1),
|
||||
Token::Struct("StructDefault", 1),
|
||||
Token::Str("a"),
|
||||
Token::I32(50),
|
||||
|
||||
@ -614,33 +614,33 @@ declare_tests! {
|
||||
Token::StructEnd,
|
||||
],
|
||||
StructDefault { a: 100, b: "default".to_string() } => &[
|
||||
Token::StructStart("StructDefault", 0),
|
||||
Token::Struct("StructDefault", 0),
|
||||
Token::StructEnd,
|
||||
],
|
||||
}
|
||||
test_enum_unit {
|
||||
Enum::Unit => &[
|
||||
Token::EnumUnit("Enum", "Unit"),
|
||||
Token::UnitVariant("Enum", "Unit"),
|
||||
],
|
||||
}
|
||||
test_enum_simple {
|
||||
Enum::Simple(1) => &[
|
||||
Token::EnumNewType("Enum", "Simple"),
|
||||
Token::NewtypeVariant("Enum", "Simple"),
|
||||
Token::I32(1),
|
||||
],
|
||||
}
|
||||
test_enum_seq {
|
||||
Enum::Seq(1, 2, 3) => &[
|
||||
Token::EnumSeqStart("Enum", "Seq", 3),
|
||||
Token::TupleVariant("Enum", "Seq", 3),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
Token::EnumSeqEnd,
|
||||
Token::TupleVariantEnd,
|
||||
],
|
||||
}
|
||||
test_enum_map {
|
||||
Enum::Map { a: 1, b: 2, c: 3 } => &[
|
||||
Token::EnumMapStart("Enum", "Map", 3),
|
||||
Token::StructVariant("Enum", "Map", 3),
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
@ -649,19 +649,19 @@ declare_tests! {
|
||||
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
],
|
||||
}
|
||||
test_enum_unit_usize {
|
||||
Enum::Unit => &[
|
||||
Token::EnumStart("Enum"),
|
||||
Token::Enum("Enum"),
|
||||
Token::U32(0),
|
||||
Token::Unit,
|
||||
],
|
||||
}
|
||||
test_enum_unit_bytes {
|
||||
Enum::Unit => &[
|
||||
Token::EnumStart("Enum"),
|
||||
Token::Enum("Enum"),
|
||||
Token::Bytes(b"Unit"),
|
||||
Token::Unit,
|
||||
],
|
||||
@ -671,7 +671,7 @@ declare_tests! {
|
||||
}
|
||||
test_boxed_slice {
|
||||
Box::new([0, 1, 2]) => &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::Seq(Some(3)),
|
||||
Token::I32(0),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
@ -680,7 +680,7 @@ declare_tests! {
|
||||
}
|
||||
test_duration {
|
||||
Duration::new(1, 2) => &[
|
||||
Token::StructStart("Duration", 2),
|
||||
Token::Struct("Duration", 2),
|
||||
Token::Str("secs"),
|
||||
Token::U64(1),
|
||||
|
||||
@ -689,7 +689,7 @@ declare_tests! {
|
||||
Token::StructEnd,
|
||||
],
|
||||
Duration::new(1, 2) => &[
|
||||
Token::SeqStart(Some(2)),
|
||||
Token::Seq(Some(2)),
|
||||
Token::I64(1),
|
||||
Token::I64(2),
|
||||
Token::SeqEnd,
|
||||
@ -697,7 +697,7 @@ declare_tests! {
|
||||
}
|
||||
test_range {
|
||||
1u32..2u32 => &[
|
||||
Token::StructStart("Range", 2),
|
||||
Token::Struct("Range", 2),
|
||||
Token::Str("start"),
|
||||
Token::U32(1),
|
||||
|
||||
@ -706,7 +706,7 @@ declare_tests! {
|
||||
Token::StructEnd,
|
||||
],
|
||||
1u32..2u32 => &[
|
||||
Token::SeqStart(Some(2)),
|
||||
Token::Seq(Some(2)),
|
||||
Token::U64(1),
|
||||
Token::U64(2),
|
||||
Token::SeqEnd,
|
||||
@ -742,9 +742,9 @@ fn test_osstring() {
|
||||
|
||||
let value = OsString::from_vec(vec![1, 2, 3]);
|
||||
let tokens = [
|
||||
Token::EnumStart("OsString"),
|
||||
Token::Enum("OsString"),
|
||||
Token::Str("Unix"),
|
||||
Token::SeqStart(Some(2)),
|
||||
Token::Seq(Some(2)),
|
||||
Token::U8(1),
|
||||
Token::U8(2),
|
||||
Token::U8(3),
|
||||
@ -762,9 +762,9 @@ fn test_osstring() {
|
||||
|
||||
let value = OsString::from_wide(&[1, 2, 3]);
|
||||
let tokens = [
|
||||
Token::EnumStart("OsString"),
|
||||
Token::Enum("OsString"),
|
||||
Token::Str("Windows"),
|
||||
Token::SeqStart(Some(2)),
|
||||
Token::Seq(Some(2)),
|
||||
Token::U16(1),
|
||||
Token::U16(2),
|
||||
Token::U16(3),
|
||||
@ -816,7 +816,7 @@ fn test_cstr_internal_null_end() {
|
||||
declare_error_tests! {
|
||||
test_unknown_field<StructDenyUnknown> {
|
||||
&[
|
||||
Token::StructStart("StructDenyUnknown", 2),
|
||||
Token::Struct("StructDenyUnknown", 2),
|
||||
Token::Str("a"),
|
||||
Token::I32(0),
|
||||
|
||||
@ -826,39 +826,39 @@ declare_error_tests! {
|
||||
}
|
||||
test_skipped_field_is_unknown<StructDenyUnknown> {
|
||||
&[
|
||||
Token::StructStart("StructDenyUnknown", 2),
|
||||
Token::Struct("StructDenyUnknown", 2),
|
||||
Token::Str("b"),
|
||||
],
|
||||
Error::Message("unknown field `b`, expected `a`".to_owned()),
|
||||
}
|
||||
test_skip_all_deny_unknown<StructSkipAllDenyUnknown> {
|
||||
&[
|
||||
Token::StructStart("StructSkipAllDenyUnknown", 1),
|
||||
Token::Struct("StructSkipAllDenyUnknown", 1),
|
||||
Token::Str("a"),
|
||||
],
|
||||
Error::Message("unknown field `a`, there are no fields".to_owned()),
|
||||
}
|
||||
test_unknown_variant<Enum> {
|
||||
&[
|
||||
Token::EnumUnit("Enum", "Foo"),
|
||||
Token::UnitVariant("Enum", "Foo"),
|
||||
],
|
||||
Error::Message("unknown variant `Foo`, expected one of `Unit`, `Simple`, `Seq`, `Map`".to_owned()),
|
||||
}
|
||||
test_enum_skipped_variant<Enum> {
|
||||
&[
|
||||
Token::EnumUnit("Enum", "Skipped"),
|
||||
Token::UnitVariant("Enum", "Skipped"),
|
||||
],
|
||||
Error::Message("unknown variant `Skipped`, expected one of `Unit`, `Simple`, `Seq`, `Map`".to_owned()),
|
||||
}
|
||||
test_enum_skip_all<EnumSkipAll> {
|
||||
&[
|
||||
Token::EnumUnit("EnumSkipAll", "Skipped"),
|
||||
Token::UnitVariant("EnumSkipAll", "Skipped"),
|
||||
],
|
||||
Error::Message("unknown variant `Skipped`, there are no variants".to_owned()),
|
||||
}
|
||||
test_struct_seq_too_long<Struct> {
|
||||
&[
|
||||
Token::SeqStart(Some(4)),
|
||||
Token::Seq(Some(4)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
@ -867,7 +867,7 @@ declare_error_tests! {
|
||||
}
|
||||
test_duplicate_field_struct<Struct> {
|
||||
&[
|
||||
Token::MapStart(Some(3)),
|
||||
Token::Map(Some(3)),
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
@ -877,7 +877,7 @@ declare_error_tests! {
|
||||
}
|
||||
test_duplicate_field_enum<Enum> {
|
||||
&[
|
||||
Token::EnumMapStart("Enum", "Map", 3),
|
||||
Token::StructVariant("Enum", "Map", 3),
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
@ -887,7 +887,7 @@ declare_error_tests! {
|
||||
}
|
||||
test_enum_out_of_range<Enum> {
|
||||
&[
|
||||
Token::EnumStart("Enum"),
|
||||
Token::Enum("Enum"),
|
||||
Token::U32(4),
|
||||
Token::Unit,
|
||||
],
|
||||
@ -895,7 +895,7 @@ declare_error_tests! {
|
||||
}
|
||||
test_short_tuple<(u8, u8, u8)> {
|
||||
&[
|
||||
Token::TupleStart(1),
|
||||
Token::Tuple(1),
|
||||
Token::U8(1),
|
||||
Token::TupleEnd,
|
||||
],
|
||||
@ -903,7 +903,7 @@ declare_error_tests! {
|
||||
}
|
||||
test_short_array<[u8; 3]> {
|
||||
&[
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::Seq(Some(1)),
|
||||
Token::U8(1),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
@ -923,21 +923,21 @@ declare_error_tests! {
|
||||
}
|
||||
test_unit_from_empty_seq<()> {
|
||||
&[
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
Error::Message("invalid type: sequence, expected unit".into()),
|
||||
}
|
||||
test_unit_from_empty_seq_without_len<()> {
|
||||
&[
|
||||
Token::SeqStart(None),
|
||||
Token::Seq(None),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
Error::Message("invalid type: sequence, expected unit".into()),
|
||||
}
|
||||
test_unit_from_tuple_struct<()> {
|
||||
&[
|
||||
Token::TupleStructStart("Anything", 0),
|
||||
Token::TupleStruct("Anything", 0),
|
||||
Token::TupleStructEnd,
|
||||
],
|
||||
Error::Message("invalid type: sequence, expected unit".into()),
|
||||
|
||||
@ -164,7 +164,7 @@ fn test_ser_named_tuple() {
|
||||
assert_ser_tokens(
|
||||
&SerNamedTuple(&a, &mut b, c),
|
||||
&[
|
||||
Token::TupleStructStart("SerNamedTuple", 3),
|
||||
Token::TupleStruct("SerNamedTuple", 3),
|
||||
Token::I32(5),
|
||||
Token::I32(6),
|
||||
Token::I32(7),
|
||||
@ -178,7 +178,7 @@ fn test_de_named_tuple() {
|
||||
assert_de_tokens(
|
||||
&DeNamedTuple(5, 6, 7),
|
||||
&[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::Seq(Some(3)),
|
||||
Token::I32(5),
|
||||
Token::I32(6),
|
||||
Token::I32(7),
|
||||
@ -189,7 +189,7 @@ fn test_de_named_tuple() {
|
||||
assert_de_tokens(
|
||||
&DeNamedTuple(5, 6, 7),
|
||||
&[
|
||||
Token::TupleStructStart("DeNamedTuple", 3),
|
||||
Token::TupleStruct("DeNamedTuple", 3),
|
||||
Token::I32(5),
|
||||
Token::I32(6),
|
||||
Token::I32(7),
|
||||
@ -211,7 +211,7 @@ fn test_ser_named_map() {
|
||||
c: c,
|
||||
},
|
||||
&[
|
||||
Token::StructStart("SerNamedMap", 3),
|
||||
Token::Struct("SerNamedMap", 3),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I32(5),
|
||||
@ -236,7 +236,7 @@ fn test_de_named_map() {
|
||||
c: 7,
|
||||
},
|
||||
&[
|
||||
Token::StructStart("DeNamedMap", 3),
|
||||
Token::Struct("DeNamedMap", 3),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I32(5),
|
||||
@ -257,7 +257,7 @@ fn test_ser_enum_unit() {
|
||||
assert_ser_tokens(
|
||||
&SerEnum::Unit::<u32, u32, u32>,
|
||||
&[
|
||||
Token::EnumUnit("SerEnum", "Unit"),
|
||||
Token::UnitVariant("SerEnum", "Unit"),
|
||||
]
|
||||
);
|
||||
}
|
||||
@ -277,12 +277,12 @@ fn test_ser_enum_seq() {
|
||||
&mut d,
|
||||
),
|
||||
&[
|
||||
Token::EnumSeqStart("SerEnum", "Seq", 4),
|
||||
Token::TupleVariant("SerEnum", "Seq", 4),
|
||||
Token::I8(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
Token::EnumSeqEnd,
|
||||
Token::TupleVariantEnd,
|
||||
],
|
||||
);
|
||||
}
|
||||
@ -302,7 +302,7 @@ fn test_ser_enum_map() {
|
||||
d: &mut d,
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("SerEnum", "Map", 4),
|
||||
Token::StructVariant("SerEnum", "Map", 4),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
@ -316,7 +316,7 @@ fn test_ser_enum_map() {
|
||||
Token::Str("d"),
|
||||
Token::I32(4),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
],
|
||||
);
|
||||
}
|
||||
@ -326,7 +326,7 @@ fn test_de_enum_unit() {
|
||||
assert_tokens(
|
||||
&DeEnum::Unit::<u32, u32, u32>,
|
||||
&[
|
||||
Token::EnumUnit("DeEnum", "Unit"),
|
||||
Token::UnitVariant("DeEnum", "Unit"),
|
||||
],
|
||||
);
|
||||
}
|
||||
@ -346,12 +346,12 @@ fn test_de_enum_seq() {
|
||||
d,
|
||||
),
|
||||
&[
|
||||
Token::EnumSeqStart("DeEnum", "Seq", 4),
|
||||
Token::TupleVariant("DeEnum", "Seq", 4),
|
||||
Token::I8(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
Token::EnumSeqEnd,
|
||||
Token::TupleVariantEnd,
|
||||
],
|
||||
);
|
||||
}
|
||||
@ -371,7 +371,7 @@ fn test_de_enum_map() {
|
||||
d: d,
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("DeEnum", "Map", 4),
|
||||
Token::StructVariant("DeEnum", "Map", 4),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
@ -385,7 +385,7 @@ fn test_de_enum_map() {
|
||||
Token::Str("d"),
|
||||
Token::I32(4),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
],
|
||||
);
|
||||
}
|
||||
@ -397,7 +397,7 @@ fn test_lifetimes() {
|
||||
assert_ser_tokens(
|
||||
&Lifetimes::LifetimeSeq(&value),
|
||||
&[
|
||||
Token::EnumNewType("Lifetimes", "LifetimeSeq"),
|
||||
Token::NewtypeVariant("Lifetimes", "LifetimeSeq"),
|
||||
Token::I32(5),
|
||||
]
|
||||
);
|
||||
@ -405,7 +405,7 @@ fn test_lifetimes() {
|
||||
assert_ser_tokens(
|
||||
&Lifetimes::NoLifetimeSeq(5),
|
||||
&[
|
||||
Token::EnumNewType("Lifetimes", "NoLifetimeSeq"),
|
||||
Token::NewtypeVariant("Lifetimes", "NoLifetimeSeq"),
|
||||
Token::I32(5),
|
||||
]
|
||||
);
|
||||
@ -413,24 +413,24 @@ fn test_lifetimes() {
|
||||
assert_ser_tokens(
|
||||
&Lifetimes::LifetimeMap { a: &value },
|
||||
&[
|
||||
Token::EnumMapStart("Lifetimes", "LifetimeMap", 1),
|
||||
Token::StructVariant("Lifetimes", "LifetimeMap", 1),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I32(5),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_ser_tokens(
|
||||
&Lifetimes::NoLifetimeMap { a: 5 },
|
||||
&[
|
||||
Token::EnumMapStart("Lifetimes", "NoLifetimeMap", 1),
|
||||
Token::StructVariant("Lifetimes", "NoLifetimeMap", 1),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::I32(5),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
@ -440,7 +440,7 @@ fn test_generic_struct() {
|
||||
assert_tokens(
|
||||
&GenericStruct { x: 5u32 },
|
||||
&[
|
||||
Token::StructStart("GenericStruct", 1),
|
||||
Token::Struct("GenericStruct", 1),
|
||||
|
||||
Token::Str("x"),
|
||||
Token::U32(5),
|
||||
@ -455,7 +455,7 @@ fn test_generic_newtype_struct() {
|
||||
assert_tokens(
|
||||
&GenericNewTypeStruct(5u32),
|
||||
&[
|
||||
Token::StructNewType("GenericNewTypeStruct"),
|
||||
Token::NewtypeStruct("GenericNewTypeStruct"),
|
||||
Token::U32(5),
|
||||
]
|
||||
);
|
||||
@ -466,7 +466,7 @@ fn test_generic_tuple_struct() {
|
||||
assert_tokens(
|
||||
&GenericTupleStruct(5u32, 6u32),
|
||||
&[
|
||||
Token::TupleStructStart("GenericTupleStruct", 2),
|
||||
Token::TupleStruct("GenericTupleStruct", 2),
|
||||
Token::U32(5),
|
||||
Token::U32(6),
|
||||
Token::TupleStructEnd,
|
||||
@ -479,7 +479,7 @@ fn test_generic_enum_unit() {
|
||||
assert_tokens(
|
||||
&GenericEnum::Unit::<u32, u32>,
|
||||
&[
|
||||
Token::EnumUnit("GenericEnum", "Unit"),
|
||||
Token::UnitVariant("GenericEnum", "Unit"),
|
||||
]
|
||||
);
|
||||
}
|
||||
@ -489,7 +489,7 @@ fn test_generic_enum_newtype() {
|
||||
assert_tokens(
|
||||
&GenericEnum::NewType::<u32, u32>(5),
|
||||
&[
|
||||
Token::EnumNewType("GenericEnum", "NewType"),
|
||||
Token::NewtypeVariant("GenericEnum", "NewType"),
|
||||
Token::U32(5),
|
||||
]
|
||||
);
|
||||
@ -500,10 +500,10 @@ fn test_generic_enum_seq() {
|
||||
assert_tokens(
|
||||
&GenericEnum::Seq::<u32, u32>(5, 6),
|
||||
&[
|
||||
Token::EnumSeqStart("GenericEnum", "Seq", 2),
|
||||
Token::TupleVariant("GenericEnum", "Seq", 2),
|
||||
Token::U32(5),
|
||||
Token::U32(6),
|
||||
Token::EnumSeqEnd,
|
||||
Token::TupleVariantEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
@ -513,7 +513,7 @@ fn test_generic_enum_map() {
|
||||
assert_tokens(
|
||||
&GenericEnum::Map::<u32, u32> { x: 5, y: 6 },
|
||||
&[
|
||||
Token::EnumMapStart("GenericEnum", "Map", 2),
|
||||
Token::StructVariant("GenericEnum", "Map", 2),
|
||||
|
||||
Token::Str("x"),
|
||||
Token::U32(5),
|
||||
@ -521,7 +521,7 @@ fn test_generic_enum_map() {
|
||||
Token::Str("y"),
|
||||
Token::U32(6),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
@ -531,7 +531,7 @@ fn test_default_ty_param() {
|
||||
assert_tokens(
|
||||
&DefaultTyParam::<i32> { phantom: PhantomData },
|
||||
&[
|
||||
Token::StructStart("DefaultTyParam", 1),
|
||||
Token::Struct("DefaultTyParam", 1),
|
||||
|
||||
Token::Str("phantom"),
|
||||
Token::UnitStruct("PhantomData"),
|
||||
@ -551,7 +551,7 @@ fn test_enum_state_field() {
|
||||
assert_tokens(
|
||||
&SomeEnum::Key { key: 'a', state: true },
|
||||
&[
|
||||
Token::EnumMapStart("SomeEnum", "Key", 2),
|
||||
Token::StructVariant("SomeEnum", "Key", 2),
|
||||
|
||||
Token::Str("key"),
|
||||
Token::Char('a'),
|
||||
@ -559,7 +559,7 @@ fn test_enum_state_field() {
|
||||
Token::Str("state"),
|
||||
Token::Bool(true),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
@ -584,7 +584,7 @@ fn test_untagged_enum() {
|
||||
assert_tokens(
|
||||
&Untagged::A { a: 1 },
|
||||
&[
|
||||
Token::StructStart("Untagged", 1),
|
||||
Token::Struct("Untagged", 1),
|
||||
|
||||
Token::Str("a"),
|
||||
Token::U8(1),
|
||||
@ -596,7 +596,7 @@ fn test_untagged_enum() {
|
||||
assert_tokens(
|
||||
&Untagged::B { b: 2 },
|
||||
&[
|
||||
Token::StructStart("Untagged", 1),
|
||||
Token::Struct("Untagged", 1),
|
||||
|
||||
Token::Str("b"),
|
||||
Token::U8(2),
|
||||
@ -628,7 +628,7 @@ fn test_untagged_enum() {
|
||||
assert_tokens(
|
||||
&Untagged::F(1, 2),
|
||||
&[
|
||||
Token::TupleStart(2),
|
||||
Token::Tuple(2),
|
||||
Token::U8(1),
|
||||
Token::U8(2),
|
||||
Token::TupleEnd,
|
||||
@ -637,14 +637,14 @@ fn test_untagged_enum() {
|
||||
|
||||
assert_de_tokens_error::<Untagged>(
|
||||
&[
|
||||
Token::Option(false),
|
||||
Token::None,
|
||||
],
|
||||
Error::Message("data did not match any variant of untagged enum Untagged".to_owned()),
|
||||
);
|
||||
|
||||
assert_de_tokens_error::<Untagged>(
|
||||
&[
|
||||
Token::TupleStart(1),
|
||||
Token::Tuple(1),
|
||||
Token::U8(1),
|
||||
Token::TupleEnd,
|
||||
],
|
||||
@ -653,7 +653,7 @@ fn test_untagged_enum() {
|
||||
|
||||
assert_de_tokens_error::<Untagged>(
|
||||
&[
|
||||
Token::TupleStart(3),
|
||||
Token::Tuple(3),
|
||||
Token::U8(1),
|
||||
Token::U8(2),
|
||||
Token::U8(3),
|
||||
@ -691,7 +691,7 @@ fn test_internally_tagged_enum() {
|
||||
assert_tokens(
|
||||
&InternallyTagged::A { a: 1 },
|
||||
&[
|
||||
Token::StructStart("InternallyTagged", 2),
|
||||
Token::Struct("InternallyTagged", 2),
|
||||
|
||||
Token::Str("type"),
|
||||
Token::Str("A"),
|
||||
@ -706,7 +706,7 @@ fn test_internally_tagged_enum() {
|
||||
assert_tokens(
|
||||
&InternallyTagged::B { b: 2 },
|
||||
&[
|
||||
Token::StructStart("InternallyTagged", 2),
|
||||
Token::Struct("InternallyTagged", 2),
|
||||
|
||||
Token::Str("type"),
|
||||
Token::Str("B"),
|
||||
@ -721,7 +721,7 @@ fn test_internally_tagged_enum() {
|
||||
assert_tokens(
|
||||
&InternallyTagged::C,
|
||||
&[
|
||||
Token::StructStart("InternallyTagged", 1),
|
||||
Token::Struct("InternallyTagged", 1),
|
||||
|
||||
Token::Str("type"),
|
||||
Token::Str("C"),
|
||||
@ -733,7 +733,7 @@ fn test_internally_tagged_enum() {
|
||||
assert_tokens(
|
||||
&InternallyTagged::D(BTreeMap::new()),
|
||||
&[
|
||||
Token::MapStart(Some(1)),
|
||||
Token::Map(Some(1)),
|
||||
|
||||
Token::Str("type"),
|
||||
Token::Str("D"),
|
||||
@ -745,7 +745,7 @@ fn test_internally_tagged_enum() {
|
||||
assert_tokens(
|
||||
&InternallyTagged::E(Newtype(BTreeMap::new())),
|
||||
&[
|
||||
Token::MapStart(Some(1)),
|
||||
Token::Map(Some(1)),
|
||||
|
||||
Token::Str("type"),
|
||||
Token::Str("E"),
|
||||
@ -757,7 +757,7 @@ fn test_internally_tagged_enum() {
|
||||
assert_tokens(
|
||||
&InternallyTagged::F(Struct { f: 6 }),
|
||||
&[
|
||||
Token::StructStart("Struct", 2),
|
||||
Token::Struct("Struct", 2),
|
||||
|
||||
Token::Str("type"),
|
||||
Token::Str("F"),
|
||||
@ -771,7 +771,7 @@ fn test_internally_tagged_enum() {
|
||||
|
||||
assert_de_tokens_error::<InternallyTagged>(
|
||||
&[
|
||||
Token::MapStart(Some(0)),
|
||||
Token::Map(Some(0)),
|
||||
Token::MapEnd,
|
||||
],
|
||||
Error::Message("missing field `type`".to_owned()),
|
||||
@ -779,7 +779,7 @@ fn test_internally_tagged_enum() {
|
||||
|
||||
assert_de_tokens_error::<InternallyTagged>(
|
||||
&[
|
||||
Token::MapStart(Some(1)),
|
||||
Token::Map(Some(1)),
|
||||
|
||||
Token::Str("type"),
|
||||
Token::Str("Z"),
|
||||
@ -805,7 +805,7 @@ fn test_adjacently_tagged_enum() {
|
||||
assert_tokens(
|
||||
&AdjacentlyTagged::Unit::<u8>,
|
||||
&[
|
||||
Token::StructStart("AdjacentlyTagged", 1),
|
||||
Token::Struct("AdjacentlyTagged", 1),
|
||||
|
||||
Token::Str("t"),
|
||||
Token::Str("Unit"),
|
||||
@ -818,7 +818,7 @@ fn test_adjacently_tagged_enum() {
|
||||
assert_de_tokens(
|
||||
&AdjacentlyTagged::Unit::<u8>,
|
||||
&[
|
||||
Token::StructStart("AdjacentlyTagged", 1),
|
||||
Token::Struct("AdjacentlyTagged", 1),
|
||||
|
||||
Token::Str("t"),
|
||||
Token::Str("Unit"),
|
||||
@ -834,7 +834,7 @@ fn test_adjacently_tagged_enum() {
|
||||
assert_de_tokens(
|
||||
&AdjacentlyTagged::Unit::<u8>,
|
||||
&[
|
||||
Token::StructStart("AdjacentlyTagged", 1),
|
||||
Token::Struct("AdjacentlyTagged", 1),
|
||||
|
||||
Token::Str("c"),
|
||||
Token::Unit,
|
||||
@ -850,7 +850,7 @@ fn test_adjacently_tagged_enum() {
|
||||
assert_tokens(
|
||||
&AdjacentlyTagged::Newtype::<u8>(1),
|
||||
&[
|
||||
Token::StructStart("AdjacentlyTagged", 2),
|
||||
Token::Struct("AdjacentlyTagged", 2),
|
||||
|
||||
Token::Str("t"),
|
||||
Token::Str("Newtype"),
|
||||
@ -866,7 +866,7 @@ fn test_adjacently_tagged_enum() {
|
||||
assert_de_tokens(
|
||||
&AdjacentlyTagged::Newtype::<u8>(1),
|
||||
&[
|
||||
Token::StructStart("AdjacentlyTagged", 2),
|
||||
Token::Struct("AdjacentlyTagged", 2),
|
||||
|
||||
Token::Str("c"),
|
||||
Token::U8(1),
|
||||
@ -882,13 +882,13 @@ fn test_adjacently_tagged_enum() {
|
||||
assert_tokens(
|
||||
&AdjacentlyTagged::Tuple::<u8>(1, 1),
|
||||
&[
|
||||
Token::StructStart("AdjacentlyTagged", 2),
|
||||
Token::Struct("AdjacentlyTagged", 2),
|
||||
|
||||
Token::Str("t"),
|
||||
Token::Str("Tuple"),
|
||||
|
||||
Token::Str("c"),
|
||||
Token::TupleStart(2),
|
||||
Token::Tuple(2),
|
||||
Token::U8(1),
|
||||
Token::U8(1),
|
||||
Token::TupleEnd,
|
||||
@ -901,10 +901,10 @@ fn test_adjacently_tagged_enum() {
|
||||
assert_de_tokens(
|
||||
&AdjacentlyTagged::Tuple::<u8>(1, 1),
|
||||
&[
|
||||
Token::StructStart("AdjacentlyTagged", 2),
|
||||
Token::Struct("AdjacentlyTagged", 2),
|
||||
|
||||
Token::Str("c"),
|
||||
Token::TupleStart(2),
|
||||
Token::Tuple(2),
|
||||
Token::U8(1),
|
||||
Token::U8(1),
|
||||
Token::TupleEnd,
|
||||
@ -920,13 +920,13 @@ fn test_adjacently_tagged_enum() {
|
||||
assert_tokens(
|
||||
&AdjacentlyTagged::Struct::<u8> { f: 1 },
|
||||
&[
|
||||
Token::StructStart("AdjacentlyTagged", 2),
|
||||
Token::Struct("AdjacentlyTagged", 2),
|
||||
|
||||
Token::Str("t"),
|
||||
Token::Str("Struct"),
|
||||
|
||||
Token::Str("c"),
|
||||
Token::StructStart("Struct", 1),
|
||||
Token::Struct("Struct", 1),
|
||||
Token::Str("f"),
|
||||
Token::U8(1),
|
||||
Token::StructEnd,
|
||||
@ -939,10 +939,10 @@ fn test_adjacently_tagged_enum() {
|
||||
assert_de_tokens(
|
||||
&AdjacentlyTagged::Struct::<u8> { f: 1 },
|
||||
&[
|
||||
Token::StructStart("AdjacentlyTagged", 2),
|
||||
Token::Struct("AdjacentlyTagged", 2),
|
||||
|
||||
Token::Str("c"),
|
||||
Token::StructStart("Struct", 1),
|
||||
Token::Struct("Struct", 1),
|
||||
Token::Str("f"),
|
||||
Token::U8(1),
|
||||
Token::StructEnd,
|
||||
@ -974,7 +974,7 @@ fn test_enum_in_internally_tagged_enum() {
|
||||
assert_tokens(
|
||||
&Outer::Inner(Inner::Unit),
|
||||
&[
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
|
||||
Token::Str("type"),
|
||||
Token::Str("Inner"),
|
||||
@ -989,7 +989,7 @@ fn test_enum_in_internally_tagged_enum() {
|
||||
assert_tokens(
|
||||
&Outer::Inner(Inner::Newtype(1)),
|
||||
&[
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
|
||||
Token::Str("type"),
|
||||
Token::Str("Inner"),
|
||||
@ -1004,13 +1004,13 @@ fn test_enum_in_internally_tagged_enum() {
|
||||
assert_tokens(
|
||||
&Outer::Inner(Inner::Tuple(1, 1)),
|
||||
&[
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
|
||||
Token::Str("type"),
|
||||
Token::Str("Inner"),
|
||||
|
||||
Token::Str("Tuple"),
|
||||
Token::TupleStructStart("Tuple", 2),
|
||||
Token::TupleStruct("Tuple", 2),
|
||||
Token::U8(1),
|
||||
Token::U8(1),
|
||||
Token::TupleStructEnd,
|
||||
@ -1022,13 +1022,13 @@ fn test_enum_in_internally_tagged_enum() {
|
||||
assert_tokens(
|
||||
&Outer::Inner(Inner::Struct { f: 1 }),
|
||||
&[
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
|
||||
Token::Str("type"),
|
||||
Token::Str("Inner"),
|
||||
|
||||
Token::Str("Struct"),
|
||||
Token::StructStart("Struct", 1),
|
||||
Token::Struct("Struct", 1),
|
||||
Token::Str("f"),
|
||||
Token::U8(1),
|
||||
Token::StructEnd,
|
||||
@ -1057,14 +1057,14 @@ fn test_enum_in_untagged_enum() {
|
||||
assert_tokens(
|
||||
&Outer::Inner(Inner::Unit),
|
||||
&[
|
||||
Token::EnumUnit("Inner", "Unit"),
|
||||
Token::UnitVariant("Inner", "Unit"),
|
||||
]
|
||||
);
|
||||
|
||||
assert_tokens(
|
||||
&Outer::Inner(Inner::Newtype(1)),
|
||||
&[
|
||||
Token::EnumNewType("Inner", "Newtype"),
|
||||
Token::NewtypeVariant("Inner", "Newtype"),
|
||||
Token::U8(1),
|
||||
]
|
||||
);
|
||||
@ -1072,22 +1072,22 @@ fn test_enum_in_untagged_enum() {
|
||||
assert_tokens(
|
||||
&Outer::Inner(Inner::Tuple(1, 1)),
|
||||
&[
|
||||
Token::EnumSeqStart("Inner", "Tuple", 2),
|
||||
Token::TupleVariant("Inner", "Tuple", 2),
|
||||
Token::U8(1),
|
||||
Token::U8(1),
|
||||
Token::EnumSeqEnd,
|
||||
Token::TupleVariantEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_tokens(
|
||||
&Outer::Inner(Inner::Struct { f: 1 }),
|
||||
&[
|
||||
Token::EnumMapStart("Inner", "Struct", 1),
|
||||
Token::StructVariant("Inner", "Struct", 1),
|
||||
|
||||
Token::Str("f"),
|
||||
Token::U8(1),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
@ -1124,43 +1124,43 @@ fn test_rename_all() {
|
||||
assert_tokens(
|
||||
&E::Serialize { serialize: true, serialize_seq: true },
|
||||
&[
|
||||
Token::EnumMapStart("E", "serialize", 2),
|
||||
Token::StructVariant("E", "serialize", 2),
|
||||
Token::Str("serialize"),
|
||||
Token::Bool(true),
|
||||
Token::Str("serializeSeq"),
|
||||
Token::Bool(true),
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_tokens(
|
||||
&E::SerializeSeq { serialize: true, serialize_seq: true },
|
||||
&[
|
||||
Token::EnumMapStart("E", "serialize_seq", 2),
|
||||
Token::StructVariant("E", "serialize_seq", 2),
|
||||
Token::Str("serialize"),
|
||||
Token::Bool(true),
|
||||
Token::Str("serialize-seq"),
|
||||
Token::Bool(true),
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_tokens(
|
||||
&E::SerializeMap { serialize: true, serialize_seq: true },
|
||||
&[
|
||||
Token::EnumMapStart("E", "serialize_map", 2),
|
||||
Token::StructVariant("E", "serialize_map", 2),
|
||||
Token::Str("SERIALIZE"),
|
||||
Token::Bool(true),
|
||||
Token::Str("SERIALIZE_SEQ"),
|
||||
Token::Bool(true),
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_tokens(
|
||||
&S { serialize: true, serialize_seq: true },
|
||||
&[
|
||||
Token::StructStart("S", 2),
|
||||
Token::Struct("S", 2),
|
||||
Token::Str("Serialize"),
|
||||
Token::Bool(true),
|
||||
Token::Str("SerializeSeq"),
|
||||
|
||||
@ -102,29 +102,29 @@ declare_tests! {
|
||||
"abc".to_owned() => &[Token::Str("abc")],
|
||||
}
|
||||
test_option {
|
||||
None::<i32> => &[Token::Option(false)],
|
||||
None::<i32> => &[Token::None],
|
||||
Some(1) => &[
|
||||
Token::Option(true),
|
||||
Token::Some,
|
||||
Token::I32(1),
|
||||
],
|
||||
}
|
||||
test_result {
|
||||
Ok::<i32, i32>(0) => &[
|
||||
Token::EnumNewType("Result", "Ok"),
|
||||
Token::NewtypeVariant("Result", "Ok"),
|
||||
Token::I32(0),
|
||||
],
|
||||
Err::<i32, i32>(1) => &[
|
||||
Token::EnumNewType("Result", "Err"),
|
||||
Token::NewtypeVariant("Result", "Err"),
|
||||
Token::I32(1),
|
||||
],
|
||||
}
|
||||
test_slice {
|
||||
&[0][..0] => &[
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
&[1, 2, 3][..] => &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::Seq(Some(3)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
@ -133,11 +133,11 @@ declare_tests! {
|
||||
}
|
||||
test_array {
|
||||
[0; 0] => &[
|
||||
Token::SeqArrayStart(0),
|
||||
Token::SeqFixedSize(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
[1, 2, 3] => &[
|
||||
Token::SeqArrayStart(3),
|
||||
Token::SeqFixedSize(3),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
@ -146,19 +146,19 @@ declare_tests! {
|
||||
}
|
||||
test_vec {
|
||||
Vec::<isize>::new() => &[
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
vec![vec![], vec![1], vec![2, 3]] => &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(3)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::Seq(Some(1)),
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqStart(Some(2)),
|
||||
Token::Seq(Some(2)),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
@ -167,28 +167,28 @@ declare_tests! {
|
||||
}
|
||||
test_hashset {
|
||||
HashSet::<isize>::new() => &[
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::Seq(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
hashset![1] => &[
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::Seq(Some(1)),
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
hashset![FnvHasher @ 1] => &[
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::Seq(Some(1)),
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_tuple {
|
||||
(1,) => &[
|
||||
Token::TupleStart(1),
|
||||
Token::Tuple(1),
|
||||
Token::I32(1),
|
||||
Token::TupleEnd,
|
||||
],
|
||||
(1, 2, 3) => &[
|
||||
Token::TupleStart(3),
|
||||
Token::Tuple(3),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
@ -197,13 +197,13 @@ declare_tests! {
|
||||
}
|
||||
test_btreemap {
|
||||
btreemap![1 => 2] => &[
|
||||
Token::MapStart(Some(1)),
|
||||
Token::Map(Some(1)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => 2, 3 => 4] => &[
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
|
||||
@ -212,13 +212,13 @@ declare_tests! {
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => &[
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
Token::I32(1),
|
||||
Token::MapStart(Some(0)),
|
||||
Token::Map(Some(0)),
|
||||
Token::MapEnd,
|
||||
|
||||
Token::I32(2),
|
||||
Token::MapStart(Some(2)),
|
||||
Token::Map(Some(2)),
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
|
||||
@ -230,17 +230,17 @@ declare_tests! {
|
||||
}
|
||||
test_hashmap {
|
||||
HashMap::<isize, isize>::new() => &[
|
||||
Token::MapStart(Some(0)),
|
||||
Token::Map(Some(0)),
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![1 => 2] => &[
|
||||
Token::MapStart(Some(1)),
|
||||
Token::Map(Some(1)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![FnvHasher @ 1 => 2] => &[
|
||||
Token::MapStart(Some(1)),
|
||||
Token::Map(Some(1)),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
@ -251,7 +251,7 @@ declare_tests! {
|
||||
}
|
||||
test_tuple_struct {
|
||||
TupleStruct(1, 2, 3) => &[
|
||||
Token::TupleStructStart("TupleStruct", 3),
|
||||
Token::TupleStruct("TupleStruct", 3),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::I32(3),
|
||||
@ -260,7 +260,7 @@ declare_tests! {
|
||||
}
|
||||
test_struct {
|
||||
Struct { a: 1, b: 2, c: 3 } => &[
|
||||
Token::StructStart("Struct", 3),
|
||||
Token::Struct("Struct", 3),
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
@ -273,22 +273,22 @@ declare_tests! {
|
||||
],
|
||||
}
|
||||
test_enum {
|
||||
Enum::Unit => &[Token::EnumUnit("Enum", "Unit")],
|
||||
Enum::One(42) => &[Token::EnumNewType("Enum", "One"), Token::I32(42)],
|
||||
Enum::Unit => &[Token::UnitVariant("Enum", "Unit")],
|
||||
Enum::One(42) => &[Token::NewtypeVariant("Enum", "One"), Token::I32(42)],
|
||||
Enum::Seq(1, 2) => &[
|
||||
Token::EnumSeqStart("Enum", "Seq", 2),
|
||||
Token::TupleVariant("Enum", "Seq", 2),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::EnumSeqEnd,
|
||||
Token::TupleVariantEnd,
|
||||
],
|
||||
Enum::Map { a: 1, b: 2 } => &[
|
||||
Token::EnumMapStart("Enum", "Map", 2),
|
||||
Token::StructVariant("Enum", "Map", 2),
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
Token::EnumMapEnd,
|
||||
Token::StructVariantEnd,
|
||||
],
|
||||
}
|
||||
test_box {
|
||||
@ -296,7 +296,7 @@ declare_tests! {
|
||||
}
|
||||
test_boxed_slice {
|
||||
Box::new([0, 1, 2]) => &[
|
||||
Token::SeqArrayStart(3),
|
||||
Token::SeqFixedSize(3),
|
||||
Token::I32(0),
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
@ -305,7 +305,7 @@ declare_tests! {
|
||||
}
|
||||
test_duration {
|
||||
Duration::new(1, 2) => &[
|
||||
Token::StructStart("Duration", 2),
|
||||
Token::Struct("Duration", 2),
|
||||
Token::Str("secs"),
|
||||
Token::U64(1),
|
||||
|
||||
@ -316,7 +316,7 @@ declare_tests! {
|
||||
}
|
||||
test_range {
|
||||
1u32..2u32 => &[
|
||||
Token::StructStart("Range", 2),
|
||||
Token::Struct("Range", 2),
|
||||
Token::Str("start"),
|
||||
Token::U32(1),
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user