diff --git a/test_suite/tests/test_annotations.rs b/test_suite/tests/test_annotations.rs index f332bcba..f2604d45 100644 --- a/test_suite/tests/test_annotations.rs +++ b/test_suite/tests/test_annotations.rs @@ -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 { 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::( &[ - 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 { 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::( &[ - 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::( &[ - 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::( &[ - 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::>( &[ - 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::( &[ - 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::( &[ - Token::TupleVariant("InvalidLengthEnum", "B", 3), + Token::TupleVariant { name: "InvalidLengthEnum", variant: "B", len: 3 }, Token::I32(1), Token::TupleVariantEnd, ], diff --git a/test_suite/tests/test_borrow.rs b/test_suite/tests/test_borrow.rs index f23f3f37..fdbff33a 100644 --- a/test_suite/tests/test_borrow.rs +++ b/test_suite/tests/test_borrow.rs @@ -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"), diff --git a/test_suite/tests/test_de.rs b/test_suite/tests/test_de.rs index 55859172..c5ab4baa 100644 --- a/test_suite/tests/test_de.rs +++ b/test_suite/tests/test_de.rs @@ -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 = 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::(0) => &[ - Token::Enum("Result"), + Token::Enum { name: "Result" }, Token::Str("Ok"), Token::I32(0), ], Err::(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::::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::::new() => &[ - Token::TupleStruct("Anything", 0), + Token::TupleStruct { name: "Anything", len: 0 }, Token::TupleStructEnd, ], } test_hashset { HashSet::::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::::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::::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::::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::::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::::new() => &[ - Token::Struct("Anything", 0), + Token::Struct { name: "Anything", len: 0 }, Token::StructEnd, ], } test_hashmap { HashMap::::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::::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 { &[ - 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 { &[ - Token::Struct("StructDenyUnknown", 2), + Token::Struct { name: "StructDenyUnknown", len: 2 }, Token::Str("b"), ], "unknown field `b`, expected `a`", } test_skip_all_deny_unknown { &[ - Token::Struct("StructSkipAllDenyUnknown", 1), + Token::Struct { name: "StructSkipAllDenyUnknown", len: 1 }, Token::Str("a"), ], "unknown field `a`, there are no fields", } test_unknown_variant { &[ - Token::UnitVariant("Enum", "Foo"), + Token::UnitVariant { name: "Enum", variant: "Foo" }, ], "unknown variant `Foo`, expected one of `Unit`, `Simple`, `Seq`, `Map`", } test_enum_skipped_variant { &[ - Token::UnitVariant("Enum", "Skipped"), + Token::UnitVariant { name: "Enum", variant: "Skipped" }, ], "unknown variant `Skipped`, expected one of `Unit`, `Simple`, `Seq`, `Map`", } test_enum_skip_all { &[ - Token::UnitVariant("EnumSkipAll", "Skipped"), + Token::UnitVariant { name: "EnumSkipAll", variant: "Skipped" }, ], "unknown variant `Skipped`, there are no variants", } test_duplicate_field_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 { &[ - 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 { &[ - 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> { &[ - 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> { &[ - 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> { &[ - 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> { &[ - 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> { &[ - 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 { &[ - Token::Seq(Some(0)), + Token::Seq { len: Some(0) }, Token::SeqEnd, ], "invalid type: sequence, expected unit struct UnitStruct", diff --git a/test_suite/tests/test_macros.rs b/test_suite/tests/test_macros.rs index 4e33b266..d4144ab3 100644 --- a/test_suite/tests/test_macros.rs +++ b/test_suite/tests/test_macros.rs @@ -115,7 +115,7 @@ struct DefaultTyParam = 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::, - &[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::, - &[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::, - &[Token::UnitVariant("GenericEnum", "Unit")], + &[Token::UnitVariant { name: "GenericEnum", variant: "Unit" }], ); } @@ -428,7 +428,7 @@ fn test_generic_enum_newtype() { assert_tokens( &GenericEnum::NewType::(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::(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:: { 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:: { 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::( @@ -559,13 +559,13 @@ fn test_untagged_enum() { ); assert_de_tokens_error::( - &[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::( &[ - 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::( - &[Token::Map(Some(0)), Token::MapEnd], + &[Token::Map { len: Some(0) }, Token::MapEnd], "missing field `type`", ); assert_de_tokens_error::( &[ - 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::, &[ - 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::, &[ - 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::, &[ - 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::(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::(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::(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::(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:: { 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:: { 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"), diff --git a/test_suite/tests/test_ser.rs b/test_suite/tests/test_ser.rs index eb51babb..ae10b26b 100644 --- a/test_suite/tests/test_ser.rs +++ b/test_suite/tests/test_ser.rs @@ -115,21 +115,21 @@ declare_tests! { } test_result { Ok::(0) => &[ - Token::NewtypeVariant("Result", "Ok"), + Token::NewtypeVariant { name: "Result", variant: "Ok" }, Token::I32(0), ], Err::(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::::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::::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::::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),