pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-04-22 20:38:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Format in rfc style

Browse Source
This commit is contained in:
David Tolnay
2017-04-13 12:28:23 -07:00
parent c5bd760133
commit ea8fb97beb
25 changed files with 2822 additions and 2131 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test_suite/tests/test_annotations.rs
+181 -172
View File
@@ -5,14 +5,8 @@ extern crate serde;
use self::serde::{Serialize, Serializer, Deserialize, Deserializer};
extern crate serde_test;
use self::serde_test::{
Error,
Token,
assert_tokens,
assert_ser_tokens,
assert_de_tokens,
assert_de_tokens_error
};
use self::serde_test::{Error, Token, assert_tokens, assert_ser_tokens, assert_de_tokens,
assert_de_tokens_error};
trait MyDefault: Sized {
fn my_default() -> Self;
@@ -24,25 +18,32 @@ trait ShouldSkip: Sized {
trait SerializeWith: Sized {
fn serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error>
where S: Serializer;
where
S: Serializer;
}
trait DeserializeWith: Sized {
fn deserialize_with<'de, D>(de: D) -> Result<Self, D::Error>
where D: Deserializer<'de>;
where
D: Deserializer<'de>;
}
impl MyDefault for i32 {
fn my_default() -> Self { 123 }
fn my_default() -> Self {
123
}
}
impl ShouldSkip for i32 {
fn should_skip(&self) -> bool { *self == 123 }
fn should_skip(&self) -> bool {
*self == 123
}
}
impl SerializeWith for i32 {
fn serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
if *self == 123 {
true.serialize(ser)
@@ -54,7 +55,8 @@ impl SerializeWith for i32 {
impl DeserializeWith for i32 {
fn deserialize_with<'de, D>(de: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
if try!(Deserialize::deserialize(de)) {
Ok(123)
@@ -66,8 +68,9 @@ impl DeserializeWith for i32 {
#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct DefaultStruct<A, B, C, D, E>
where C: MyDefault,
E: MyDefault,
where
C: MyDefault,
E: MyDefault,
{
a1: A,
#[serde(default)]
@@ -83,7 +86,13 @@ struct DefaultStruct<A, B, C, D, E>
#[test]
fn test_default_struct() {
assert_de_tokens(
&DefaultStruct { a1: 1, a2: 2, a3: 3, a4: 0, a5: 123 },
&DefaultStruct {
a1: 1,
a2: 2,
a3: 3,
a4: 0,
a5: 123,
},
&[
Token::Struct("DefaultStruct", 3),
@@ -103,11 +112,17 @@ fn test_default_struct() {
Token::I32(5),
Token::StructEnd,
]
],
);
assert_de_tokens(
&DefaultStruct { a1: 1, a2: 0, a3: 123, a4: 0, a5: 123 },
&DefaultStruct {
a1: 1,
a2: 0,
a3: 123,
a4: 0,
a5: 123,
},
&[
Token::Struct("DefaultStruct", 1),
@@ -115,14 +130,15 @@ fn test_default_struct() {
Token::I32(1),
Token::StructEnd,
]
],
);
}
#[derive(Debug, PartialEq, Serialize, Deserialize)]
enum DefaultEnum<A, B, C, D, E>
where C: MyDefault,
E: MyDefault
where
C: MyDefault,
E: MyDefault,
{
Struct {
a1: A,
@@ -134,13 +150,19 @@ enum DefaultEnum<A, B, C, D, E>
a4: D,
#[serde(skip_deserializing, default="MyDefault::my_default")]
a5: E,
}
},
}
#[test]
fn test_default_enum() {
assert_de_tokens(
&DefaultEnum::Struct { a1: 1, a2: 2, a3: 3, a4: 0, a5: 123 },
&DefaultEnum::Struct {
a1: 1,
a2: 2,
a3: 3,
a4: 0,
a5: 123,
},
&[
Token::StructVariant("DefaultEnum", "Struct", 3),
@@ -160,11 +182,17 @@ fn test_default_enum() {
Token::I32(5),
Token::StructVariantEnd,
]
],
);
assert_de_tokens(
&DefaultEnum::Struct { a1: 1, a2: 0, a3: 123, a4: 0, a5: 123 },
&DefaultEnum::Struct {
a1: 1,
a2: 0,
a3: 123,
a4: 0,
a5: 123,
},
&[
Token::StructVariant("DefaultEnum", "Struct", 3),
@@ -172,7 +200,7 @@ fn test_default_enum() {
Token::I32(1),
Token::StructVariantEnd,
]
],
);
}
@@ -198,10 +226,7 @@ struct ContainsNoStdDefault<A: MyDefault> {
fn test_no_std_default() {
assert_de_tokens(
&ContainsNoStdDefault { a: NoStdDefault(123) },
&[
Token::Struct("ContainsNoStdDefault", 1),
Token::StructEnd,
]
&[Token::Struct("ContainsNoStdDefault", 1), Token::StructEnd],
);
assert_de_tokens(
@@ -214,7 +239,7 @@ fn test_no_std_default() {
Token::I8(8),
Token::StructEnd,
]
],
);
}
@@ -230,7 +255,8 @@ impl Default for NotDeserializeStruct {
impl DeserializeWith for NotDeserializeStruct {
fn deserialize_with<'de, D>(_: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
panic!()
}
@@ -238,7 +264,9 @@ impl DeserializeWith for NotDeserializeStruct {
// Does not implement Deserialize.
#[derive(Debug, PartialEq)]
enum NotDeserializeEnum { Trouble }
enum NotDeserializeEnum {
Trouble,
}
impl MyDefault for NotDeserializeEnum {
fn my_default() -> Self {
@@ -265,15 +293,12 @@ struct ContainsNotDeserialize<A, B, C: DeserializeWith, E: MyDefault> {
fn test_elt_not_deserialize() {
assert_de_tokens(
&ContainsNotDeserialize {
a: NotDeserializeStruct(123),
b: NotDeserializeStruct(123),
c: NotDeserializeStruct(123),
e: NotDeserializeEnum::Trouble,
},
&[
Token::Struct("ContainsNotDeserialize", 3),
Token::StructEnd,
]
a: NotDeserializeStruct(123),
b: NotDeserializeStruct(123),
c: NotDeserializeStruct(123),
e: NotDeserializeEnum::Trouble,
},
&[Token::Struct("ContainsNotDeserialize", 3), Token::StructEnd],
);
}
@@ -287,7 +312,13 @@ struct DenyUnknown {
fn test_ignore_unknown() {
// 'Default' allows unknown. Basic smoke test of ignore...
assert_de_tokens(
&DefaultStruct { a1: 1, a2: 2, a3: 3, a4: 0, a5: 123 },
&DefaultStruct {
a1: 1,
a2: 2,
a3: 3,
a4: 0,
a5: 123,
},
&[
Token::Struct("DefaultStruct", 5),
@@ -312,7 +343,7 @@ fn test_ignore_unknown() {
Token::I32(3),
Token::StructEnd,
]
],
);
assert_de_tokens_error::<DenyUnknown>(
@@ -324,7 +355,7 @@ fn test_ignore_unknown() {
Token::Str("whoops"),
],
Error::Message("unknown field `whoops`, expected `a1`".to_owned())
Error::Message("unknown field `whoops`, expected `a1`".to_owned()),
);
}
@@ -358,7 +389,7 @@ fn test_rename_struct() {
Token::I32(2),
Token::StructEnd,
]
],
);
assert_ser_tokens(
@@ -373,7 +404,7 @@ fn test_rename_struct() {
Token::I32(2),
Token::StructEnd,
]
],
);
assert_de_tokens(
@@ -388,7 +419,7 @@ fn test_rename_struct() {
Token::I32(2),
Token::StructEnd,
]
],
);
}
@@ -424,9 +455,7 @@ enum RenameEnumSerializeDeserialize<A> {
fn test_rename_enum() {
assert_tokens(
&RenameEnum::Batman,
&[
Token::UnitVariant("Superhero", "bruce_wayne"),
]
&[Token::UnitVariant("Superhero", "bruce_wayne")],
);
assert_tokens(
@@ -434,7 +463,7 @@ fn test_rename_enum() {
&[
Token::NewtypeVariant("Superhero", "clark_kent"),
Token::I8(0),
]
],
);
assert_tokens(
@@ -444,7 +473,7 @@ fn test_rename_enum() {
Token::I8(0),
Token::I8(1),
Token::TupleVariantEnd,
]
],
);
assert_tokens(
@@ -456,14 +485,14 @@ fn test_rename_enum() {
Token::I32(1),
Token::StructVariantEnd,
]
],
);
assert_ser_tokens(
&RenameEnumSerializeDeserialize::Robin {
a: 0,
b: String::new(),
},
a: 0,
b: String::new(),
},
&[
Token::StructVariant("SuperheroSer", "dick_grayson", 2),
@@ -474,14 +503,14 @@ fn test_rename_enum() {
Token::Str(""),
Token::StructVariantEnd,
]
],
);
assert_de_tokens(
&RenameEnumSerializeDeserialize::Robin {
a: 0,
b: String::new(),
},
a: 0,
b: String::new(),
},
&[
Token::StructVariant("SuperheroDe", "jason_todd", 2),
@@ -492,12 +521,15 @@ fn test_rename_enum() {
Token::Str(""),
Token::StructVariantEnd,
]
],
);
}
#[derive(Debug, PartialEq, Serialize)]
struct SkipSerializingStruct<'a, B, C> where C: ShouldSkip {
struct SkipSerializingStruct<'a, B, C>
where
C: ShouldSkip,
{
a: &'a i8,
#[serde(skip_serializing)]
b: B,
@@ -509,11 +541,7 @@ struct SkipSerializingStruct<'a, B, C> where C: ShouldSkip {
fn test_skip_serializing_struct() {
let a = 1;
assert_ser_tokens(
&SkipSerializingStruct {
a: &a,
b: 2,
c: 3,
},
&SkipSerializingStruct { a: &a, b: 2, c: 3 },
&[
Token::Struct("SkipSerializingStruct", 2),
@@ -524,15 +552,15 @@ fn test_skip_serializing_struct() {
Token::I32(3),
Token::StructEnd,
]
],
);
assert_ser_tokens(
&SkipSerializingStruct {
a: &a,
b: 2,
c: 123,
},
a: &a,
b: 2,
c: 123,
},
&[
Token::Struct("SkipSerializingStruct", 1),
@@ -540,30 +568,29 @@ fn test_skip_serializing_struct() {
Token::I8(1),
Token::StructEnd,
]
],
);
}
#[derive(Debug, PartialEq, Serialize)]
enum SkipSerializingEnum<'a, B, C> where C: ShouldSkip {
enum SkipSerializingEnum<'a, B, C>
where
C: ShouldSkip,
{
Struct {
a: &'a i8,
#[serde(skip_serializing)]
_b: B,
#[serde(skip_serializing_if="ShouldSkip::should_skip")]
c: C,
}
},
}
#[test]
fn test_skip_serializing_enum() {
let a = 1;
assert_ser_tokens(
&SkipSerializingEnum::Struct {
a: &a,
_b: 2,
c: 3,
},
&SkipSerializingEnum::Struct { a: &a, _b: 2, c: 3 },
&[
Token::StructVariant("SkipSerializingEnum", "Struct", 2),
@@ -574,15 +601,15 @@ fn test_skip_serializing_enum() {
Token::I32(3),
Token::StructVariantEnd,
]
],
);
assert_ser_tokens(
&SkipSerializingEnum::Struct {
a: &a,
_b: 2,
c: 123,
},
a: &a,
_b: 2,
c: 123,
},
&[
Token::StructVariant("SkipSerializingEnum", "Struct", 1),
@@ -590,7 +617,7 @@ fn test_skip_serializing_enum() {
Token::I8(1),
Token::StructVariantEnd,
]
],
);
}
@@ -598,18 +625,25 @@ fn test_skip_serializing_enum() {
struct NotSerializeStruct(i8);
#[derive(Debug, PartialEq)]
enum NotSerializeEnum { Trouble }
enum NotSerializeEnum {
Trouble,
}
impl SerializeWith for NotSerializeEnum {
fn serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
"trouble".serialize(ser)
}
}
#[derive(Debug, PartialEq, Serialize)]
struct ContainsNotSerialize<'a, B, C, D> where B: 'a, D: SerializeWith {
struct ContainsNotSerialize<'a, B, C, D>
where
B: 'a,
D: SerializeWith,
{
a: &'a Option<i8>,
#[serde(skip_serializing)]
b: &'a B,
@@ -624,11 +658,11 @@ fn test_elt_not_serialize() {
let a = 1;
assert_ser_tokens(
&ContainsNotSerialize {
a: &Some(a),
b: &NotSerializeStruct(2),
c: Some(NotSerializeEnum::Trouble),
d: NotSerializeEnum::Trouble,
},
a: &Some(a),
b: &NotSerializeStruct(2),
c: Some(NotSerializeEnum::Trouble),
d: NotSerializeEnum::Trouble,
},
&[
Token::Struct("ContainsNotSerialize", 2),
@@ -640,12 +674,15 @@ fn test_elt_not_serialize() {
Token::Str("trouble"),
Token::StructEnd,
]
],
);
}
#[derive(Debug, PartialEq, Serialize)]
struct SerializeWithStruct<'a, B> where B: SerializeWith {
struct SerializeWithStruct<'a, B>
where
B: SerializeWith,
{
a: &'a i8,
#[serde(serialize_with="SerializeWith::serialize_with")]
b: B,
@@ -655,10 +692,7 @@ struct SerializeWithStruct<'a, B> where B: SerializeWith {
fn test_serialize_with_struct() {
let a = 1;
assert_ser_tokens(
&SerializeWithStruct {
a: &a,
b: 2,
},
&SerializeWithStruct { a: &a, b: 2 },
&[
Token::Struct("SerializeWithStruct", 2),
@@ -669,14 +703,11 @@ fn test_serialize_with_struct() {
Token::Bool(false),
Token::StructEnd,
]
],
);
assert_ser_tokens(
&SerializeWithStruct {
a: &a,
b: 123,
},
&SerializeWithStruct { a: &a, b: 123 },
&[
Token::Struct("SerializeWithStruct", 2),
@@ -687,27 +718,27 @@ fn test_serialize_with_struct() {
Token::Bool(true),
Token::StructEnd,
]
],
);
}
#[derive(Debug, PartialEq, Serialize)]
enum SerializeWithEnum<'a, B> where B: SerializeWith {
enum SerializeWithEnum<'a, B>
where
B: SerializeWith,
{
Struct {
a: &'a i8,
#[serde(serialize_with="SerializeWith::serialize_with")]
b: B,
}
},
}
#[test]
fn test_serialize_with_enum() {
let a = 1;
assert_ser_tokens(
&SerializeWithEnum::Struct {
a: &a,
b: 2,
},
&SerializeWithEnum::Struct { a: &a, b: 2 },
&[
Token::StructVariant("SerializeWithEnum", "Struct", 2),
@@ -718,14 +749,11 @@ fn test_serialize_with_enum() {
Token::Bool(false),
Token::StructVariantEnd,
]
],
);
assert_ser_tokens(
&SerializeWithEnum::Struct {
a: &a,
b: 123,
},
&SerializeWithEnum::Struct { a: &a, b: 123 },
&[
Token::StructVariant("SerializeWithEnum", "Struct", 2),
@@ -736,12 +764,15 @@ fn test_serialize_with_enum() {
Token::Bool(true),
Token::StructVariantEnd,
]
],
);
}
#[derive(Debug, PartialEq, Deserialize)]
struct DeserializeWithStruct<B> where B: DeserializeWith {
struct DeserializeWithStruct<B>
where
B: DeserializeWith,
{
a: i8,
#[serde(deserialize_with="DeserializeWith::deserialize_with")]
b: B,
@@ -750,10 +781,7 @@ struct DeserializeWithStruct<B> where B: DeserializeWith {
#[test]
fn test_deserialize_with_struct() {
assert_de_tokens(
&DeserializeWithStruct {
a: 1,
b: 2,
},
&DeserializeWithStruct { a: 1, b: 2 },
&[
Token::Struct("DeserializeWithStruct", 2),
@@ -764,14 +792,11 @@ fn test_deserialize_with_struct() {
Token::Bool(false),
Token::StructEnd,
]
],
);
assert_de_tokens(
&DeserializeWithStruct {
a: 1,
b: 123,
},
&DeserializeWithStruct { a: 1, b: 123 },
&[
Token::Struct("DeserializeWithStruct", 2),
@@ -782,26 +807,26 @@ fn test_deserialize_with_struct() {
Token::Bool(true),
Token::StructEnd,
]
],
);
}
#[derive(Debug, PartialEq, Deserialize)]
enum DeserializeWithEnum<B> where B: DeserializeWith {
enum DeserializeWithEnum<B>
where
B: DeserializeWith,
{
Struct {
a: i8,
#[serde(deserialize_with="DeserializeWith::deserialize_with")]
b: B,
}
},
}
#[test]
fn test_deserialize_with_enum() {
assert_de_tokens(
&DeserializeWithEnum::Struct {
a: 1,
b: 2,
},
&DeserializeWithEnum::Struct { a: 1, b: 2 },
&[
Token::StructVariant("DeserializeWithEnum", "Struct", 2),
@@ -812,14 +837,11 @@ fn test_deserialize_with_enum() {
Token::Bool(false),
Token::StructVariantEnd,
]
],
);
assert_de_tokens(
&DeserializeWithEnum::Struct {
a: 1,
b: 123,
},
&DeserializeWithEnum::Struct { a: 1, b: 123 },
&[
Token::StructVariant("DeserializeWithEnum", "Struct", 2),
@@ -830,7 +852,7 @@ fn test_deserialize_with_enum() {
Token::Bool(true),
Token::StructVariantEnd,
]
],
);
}
@@ -888,7 +910,12 @@ fn test_missing_renamed_field_enum() {
#[derive(Debug, PartialEq, Deserialize)]
enum InvalidLengthEnum {
A(i32, i32, i32),
B(#[serde(skip_deserializing)] i32, i32, i32),
B(
#[serde(skip_deserializing)]
i32,
i32,
i32
),
}
#[test]
@@ -918,7 +945,7 @@ struct StructFromEnum(Option<u32>);
impl Into<EnumToU32> for StructFromEnum {
fn into(self) -> EnumToU32 {
match self {
StructFromEnum(v) => v.into()
StructFromEnum(v) => v.into(),
}
}
}
@@ -936,7 +963,7 @@ enum EnumToU32 {
Two,
Three,
Four,
Nothing
Nothing,
}
impl Into<Option<u32>> for EnumToU32 {
@@ -946,7 +973,7 @@ impl Into<Option<u32>> for EnumToU32 {
EnumToU32::Two => Some(2),
EnumToU32::Three => Some(3),
EnumToU32::Four => Some(4),
EnumToU32::Nothing => None
EnumToU32::Nothing => None,
}
}
}
@@ -958,35 +985,17 @@ impl From<Option<u32>> for EnumToU32 {
Some(2) => EnumToU32::Two,
Some(3) => EnumToU32::Three,
Some(4) => EnumToU32::Four,
_ => EnumToU32::Nothing
_ => EnumToU32::Nothing,
}
}
}
#[test]
fn test_from_into_traits() {
assert_ser_tokens::<EnumToU32>(&EnumToU32::One,
&[Token::Some,
Token::U32(1)
]
);
assert_ser_tokens::<EnumToU32>(&EnumToU32::Nothing,
&[Token::None]
);
assert_de_tokens::<EnumToU32>(&EnumToU32::Two,
&[Token::Some,
Token::U32(2)
]
);
assert_ser_tokens::<StructFromEnum>(&StructFromEnum(Some(5)),
&[Token::None]
);
assert_ser_tokens::<StructFromEnum>(&StructFromEnum(None),
&[Token::None]
);
assert_de_tokens::<StructFromEnum>(&StructFromEnum(Some(2)),
&[Token::Some,
Token::U32(2)
]
);
assert_ser_tokens::<EnumToU32>(&EnumToU32::One, &[Token::Some, Token::U32(1)]);
assert_ser_tokens::<EnumToU32>(&EnumToU32::Nothing, &[Token::None]);
assert_de_tokens::<EnumToU32>(&EnumToU32::Two, &[Token::Some, Token::U32(2)]);
assert_ser_tokens::<StructFromEnum>(&StructFromEnum(Some(5)), &[Token::None]);
assert_ser_tokens::<StructFromEnum>(&StructFromEnum(None), &[Token::None]);
assert_de_tokens::<StructFromEnum>(&StructFromEnum(Some(2)), &[Token::Some, Token::U32(2)]);
}
test_suite/tests/test_borrow.rs
+22 -45
View File
@@ -5,82 +5,54 @@ extern crate serde;
use serde::{Deserialize, Deserializer};
extern crate serde_test;
use serde_test::{
Error,
Token,
assert_de_tokens,
assert_de_tokens_error,
};
use serde_test::{Error, Token, assert_de_tokens, assert_de_tokens_error};
use std::borrow::Cow;
#[test]
fn test_borrowed_str() {
assert_de_tokens(
&"borrowed",
&[
Token::BorrowedStr("borrowed"),
]
);
assert_de_tokens(&"borrowed", &[Token::BorrowedStr("borrowed")]);
}
#[test]
fn test_borrowed_str_from_string() {
assert_de_tokens_error::<&str>(
&[
Token::String("borrowed"),
],
Error::Message("invalid type: string \"borrowed\", expected a borrowed string".to_owned()),
&[Token::String("borrowed")],
Error::Message("invalid type: string \"borrowed\", expected a borrowed string".to_owned(),),
);
}
#[test]
fn test_borrowed_str_from_str() {
assert_de_tokens_error::<&str>(
&[
Token::Str("borrowed"),
],
Error::Message("invalid type: string \"borrowed\", expected a borrowed string".to_owned()),
&[Token::Str("borrowed")],
Error::Message("invalid type: string \"borrowed\", expected a borrowed string".to_owned(),),
);
}
#[test]
fn test_string_from_borrowed_str() {
assert_de_tokens(
&"owned".to_owned(),
&[
Token::BorrowedStr("owned"),
]
);
assert_de_tokens(&"owned".to_owned(), &[Token::BorrowedStr("owned")]);
}
#[test]
fn test_borrowed_bytes() {
assert_de_tokens(
&&b"borrowed"[..],
&[
Token::BorrowedBytes(b"borrowed"),
]
);
assert_de_tokens(&&b"borrowed"[..], &[Token::BorrowedBytes(b"borrowed")]);
}
#[test]
fn test_borrowed_bytes_from_bytebuf() {
assert_de_tokens_error::<&[u8]>(
&[
Token::ByteBuf(b"borrowed"),
],
Error::Message("invalid type: byte array, expected a borrowed byte array".to_owned()),
&[Token::ByteBuf(b"borrowed")],
Error::Message("invalid type: byte array, expected a borrowed byte array".to_owned(),),
);
}
#[test]
fn test_borrowed_bytes_from_bytes() {
assert_de_tokens_error::<&[u8]>(
&[
Token::Bytes(b"borrowed"),
],
Error::Message("invalid type: byte array, expected a borrowed byte array".to_owned()),
&[Token::Bytes(b"borrowed")],
Error::Message("invalid type: byte array, expected a borrowed byte array".to_owned(),),
);
}
@@ -93,7 +65,7 @@ fn test_tuple() {
Token::BorrowedStr("str"),
Token::BorrowedBytes(b"bytes"),
Token::TupleEnd,
]
],
);
}
@@ -106,7 +78,10 @@ fn test_struct() {
}
assert_de_tokens(
&Borrowing { bs: "str", bb: b"bytes" },
&Borrowing {
bs: "str",
bb: b"bytes",
},
&[
Token::Struct("Borrowing", 2),
@@ -117,7 +92,7 @@ fn test_struct() {
Token::BorrowedBytes(b"bytes"),
Token::StructEnd,
]
],
);
}
@@ -170,7 +145,8 @@ fn test_lifetimes() {
// Tests that `'de: 'a` is not required by the Deserialize impl.
fn _cows_lifetimes<'de: 'b, 'a, 'b, D>(deserializer: D) -> Cows<'a, 'b>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
Deserialize::deserialize(deserializer).unwrap()
}
@@ -183,7 +159,8 @@ fn test_lifetimes() {
// Tests that `'de: 'a` is not required by the Deserialize impl.
fn _wrap_lifetimes<'de: 'b, 'a, 'b, D>(deserializer: D) -> Wrap<'a, 'b>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
Deserialize::deserialize(deserializer).unwrap()
}
test_suite/tests/test_de.rs
+26 -35
View File
@@ -20,12 +20,7 @@ extern crate fnv;
use self::fnv::FnvHasher;
extern crate serde_test;
use self::serde_test::{
Error,
Token,
assert_de_tokens,
assert_de_tokens_error,
};
use self::serde_test::{Error, Token, assert_de_tokens, assert_de_tokens_error};
#[macro_use]
mod macros;
@@ -146,23 +141,21 @@ fn assert_de_tokens_ignore(ignorable_tokens: &[Token]) {
a: i32,
}
let expected = IgnoreBase{a: 1};
let expected = IgnoreBase { a: 1 };
// Embed the tokens to be ignored in the normal token
// stream for an IgnoreBase type
let concated_tokens : Vec<Token> = vec![
Token::Map(Some(2)),
Token::Str("a"),
Token::I32(1),
let concated_tokens: Vec<Token> = vec![
Token::Map(Some(2)),
Token::Str("a"),
Token::I32(1),
Token::Str("ignored")
]
.into_iter()
.chain(ignorable_tokens.to_vec().into_iter())
.chain(vec![
Token::MapEnd,
].into_iter())
.collect();
Token::Str("ignored"),
]
.into_iter()
.chain(ignorable_tokens.to_vec().into_iter())
.chain(vec![Token::MapEnd].into_iter())
.collect();
let mut de = serde_test::Deserializer::new(&concated_tokens);
let v: Result<IgnoreBase, Error> = Deserialize::deserialize(&mut de);
@@ -735,9 +728,9 @@ fn test_osstring() {
Token::Enum("OsString"),
Token::Str("Unix"),
Token::Seq(Some(2)),
Token::U8(1),
Token::U8(2),
Token::U8(3),
Token::U8(1),
Token::U8(2),
Token::U8(3),
Token::SeqEnd,
];
@@ -755,9 +748,9 @@ fn test_osstring() {
Token::Enum("OsString"),
Token::Str("Windows"),
Token::Seq(Some(2)),
Token::U16(1),
Token::U16(2),
Token::U16(3),
Token::U16(1),
Token::U16(2),
Token::U16(3),
Token::SeqEnd,
];
@@ -768,8 +761,10 @@ fn test_osstring() {
#[cfg(feature = "unstable")]
#[test]
fn test_cstr() {
assert_de_tokens::<Box<CStr>>(&CString::new("abc").unwrap().into_boxed_c_str(),
&[Token::Bytes(b"abc")]);
assert_de_tokens::<Box<CStr>>(
&CString::new("abc").unwrap().into_boxed_c_str(),
&[Token::Bytes(b"abc")],
);
}
#[cfg(feature = "unstable")]
@@ -785,10 +780,8 @@ fn test_net_ipaddr() {
#[test]
fn test_cstr_internal_null() {
assert_de_tokens_error::<Box<CStr>>(
&[
Token::Bytes(b"a\0c"),
],
Error::Message("nul byte found in provided data at position: 1".into())
&[Token::Bytes(b"a\0c")],
Error::Message("nul byte found in provided data at position: 1".into()),
);
}
@@ -796,10 +789,8 @@ fn test_cstr_internal_null() {
#[test]
fn test_cstr_internal_null_end() {
assert_de_tokens_error::<Box<CStr>>(
&[
Token::Bytes(b"ac\0"),
],
Error::Message("nul byte found in provided data at position: 2".into())
&[Token::Bytes(b"ac\0")],
Error::Message("nul byte found in provided data at position: 2".into()),
);
}
test_suite/tests/test_gen.rs
+31 -13
View File
@@ -82,20 +82,28 @@ fn test_gen() {
Unit,
Newtype(
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
X),
X
),
Tuple(
T,
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
X),
X
),
Struct {
t: T,
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
x: X },
x: X,
},
}
assert::<EnumWith<i32>>();
#[derive(Serialize)]
struct MultipleRef<'a, 'b, 'c, T> where T: 'c, 'c: 'b, 'b: 'a {
struct MultipleRef<'a, 'b, 'c, T>
where
T: 'c,
'c: 'b,
'b: 'a,
{
t: T,
rrrt: &'a &'b &'c T,
}
@@ -112,7 +120,7 @@ fn test_gen() {
struct Tuple<T>(
T,
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
X,
X
);
assert::<Tuple<i32>>();
@@ -122,9 +130,7 @@ fn test_gen() {
left: Box<TreeNode<D>>,
right: Box<TreeNode<D>>,
},
Leaf {
data: D,
},
Leaf { data: D },
}
assert::<TreeNode<i32>>();
@@ -218,7 +224,7 @@ fn test_gen() {
#[cfg(feature = "unstable")]
#[derive(Serialize, Deserialize)]
struct NonAsciiIdents {
σ: f64
σ: f64,
}
#[derive(Serialize, Deserialize)]
@@ -251,11 +257,17 @@ fn test_gen() {
struct EmptyTupleDenyUnknown();
#[derive(Serialize, Deserialize)]
struct TupleSkipAll(#[serde(skip_deserializing)] u8);
struct TupleSkipAll(
#[serde(skip_deserializing)]
u8
);
#[derive(Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct TupleSkipAllDenyUnknown(#[serde(skip_deserializing)] u8);
struct TupleSkipAllDenyUnknown(
#[serde(skip_deserializing)]
u8
);
#[derive(Serialize, Deserialize)]
enum EmptyEnum {}
@@ -280,7 +292,10 @@ fn test_gen() {
#[serde(skip_deserializing)]
f: u8,
},
TupleSkip(#[serde(skip_deserializing)] u8),
TupleSkip(
#[serde(skip_deserializing)]
u8
),
}
#[cfg(feature = "unstable")]
@@ -293,7 +308,10 @@ fn test_gen() {
#[serde(skip_deserializing)]
f: u8,
},
TupleSkip(#[serde(skip_deserializing)] u8),
TupleSkip(
#[serde(skip_deserializing)]
u8
),
}
#[derive(Serialize, Deserialize)]
test_suite/tests/test_macros.rs
+117 -213
View File
@@ -2,14 +2,8 @@
extern crate serde_derive;
extern crate serde_test;
use self::serde_test::{
Error,
Token,
assert_tokens,
assert_ser_tokens,
assert_de_tokens,
assert_de_tokens_error,
};
use self::serde_test::{Error, Token, assert_tokens, assert_ser_tokens, assert_de_tokens,
assert_de_tokens_error};
use std::collections::BTreeMap;
use std::marker::PhantomData;
@@ -45,67 +39,30 @@ struct DeNamedMap<A, B, C> {
}
#[derive(Debug, PartialEq, Serialize)]
enum SerEnum<'a, B: 'a, C: 'a, D> where D: 'a {
enum SerEnum<'a, B: 'a, C: 'a, D>
where
D: 'a,
{
Unit,
Seq(
i8,
B,
&'a C,
&'a mut D,
),
Map {
a: i8,
b: B,
c: &'a C,
d: &'a mut D,
},
Seq(i8, B, &'a C, &'a mut D),
Map { a: i8, b: B, c: &'a C, d: &'a mut D },
// Make sure we can support more than one variant.
_Unit2,
_Seq2(
i8,
B,
&'a C,
&'a mut D,
),
_Map2 {
a: i8,
b: B,
c: &'a C,
d: &'a mut D,
},
_Seq2(i8, B, &'a C, &'a mut D),
_Map2 { a: i8, b: B, c: &'a C, d: &'a mut D },
}
#[derive(Debug, PartialEq, Serialize, Deserialize)]
enum DeEnum<B, C, D> {
Unit,
Seq(
i8,
B,
C,
D,
),
Map {
a: i8,
b: B,
c: C,
d: D,
},
Seq(i8, B, C, D),
Map { a: i8, b: B, c: C, d: D },
// Make sure we can support more than one variant.
_Unit2,
_Seq2(
i8,
B,
C,
D,
),
_Map2 {
a: i8,
b: B,
c: C,
d: D,
},
_Seq2(i8, B, C, D),
_Map2 { a: i8, b: B, c: C, d: D },
}
#[derive(Serialize)]
@@ -144,16 +101,13 @@ impl AssociatedType for i32 {
}
#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct DefaultTyParam<T: AssociatedType<X=i32> = i32> {
phantom: PhantomData<T>
struct DefaultTyParam<T: AssociatedType<X = i32> = i32> {
phantom: PhantomData<T>,
}
#[test]
fn test_named_unit() {
assert_tokens(
&NamedUnit,
&[Token::UnitStruct("NamedUnit")]
);
assert_tokens(&NamedUnit, &[Token::UnitStruct("NamedUnit")]);
}
#[test]
@@ -183,7 +137,7 @@ fn test_de_named_tuple() {
Token::I32(6),
Token::I32(7),
Token::SeqEnd,
]
],
);
assert_de_tokens(
@@ -194,7 +148,7 @@ fn test_de_named_tuple() {
Token::I32(6),
Token::I32(7),
Token::TupleStructEnd,
]
],
);
}
@@ -206,10 +160,10 @@ fn test_ser_named_map() {
assert_ser_tokens(
&SerNamedMap {
a: &a,
b: &mut b,
c: c,
},
a: &a,
b: &mut b,
c: c,
},
&[
Token::Struct("SerNamedMap", 3),
@@ -223,18 +177,14 @@ fn test_ser_named_map() {
Token::I32(7),
Token::StructEnd,
]
],
);
}
#[test]
fn test_de_named_map() {
assert_de_tokens(
&DeNamedMap {
a: 5,
b: 6,
c: 7,
},
&DeNamedMap { a: 5, b: 6, c: 7 },
&[
Token::Struct("DeNamedMap", 3),
@@ -248,7 +198,7 @@ fn test_de_named_map() {
Token::I32(7),
Token::StructEnd,
]
],
);
}
@@ -256,9 +206,7 @@ fn test_de_named_map() {
fn test_ser_enum_unit() {
assert_ser_tokens(
&SerEnum::Unit::<u32, u32, u32>,
&[
Token::UnitVariant("SerEnum", "Unit"),
]
&[Token::UnitVariant("SerEnum", "Unit")],
);
}
@@ -270,12 +218,7 @@ fn test_ser_enum_seq() {
let mut d = 4;
assert_ser_tokens(
&SerEnum::Seq(
a,
b,
&c,
&mut d,
),
&SerEnum::Seq(a, b, &c, &mut d),
&[
Token::TupleVariant("SerEnum", "Seq", 4),
Token::I8(1),
@@ -296,11 +239,11 @@ fn test_ser_enum_map() {
assert_ser_tokens(
&SerEnum::Map {
a: a,
b: b,
c: &c,
d: &mut d,
},
a: a,
b: b,
c: &c,
d: &mut d,
},
&[
Token::StructVariant("SerEnum", "Map", 4),
@@ -325,9 +268,7 @@ fn test_ser_enum_map() {
fn test_de_enum_unit() {
assert_tokens(
&DeEnum::Unit::<u32, u32, u32>,
&[
Token::UnitVariant("DeEnum", "Unit"),
],
&[Token::UnitVariant("DeEnum", "Unit")],
);
}
@@ -339,12 +280,7 @@ fn test_de_enum_seq() {
let d = 4;
assert_tokens(
&DeEnum::Seq(
a,
b,
c,
d,
),
&DeEnum::Seq(a, b, c, d),
&[
Token::TupleVariant("DeEnum", "Seq", 4),
Token::I8(1),
@@ -365,11 +301,11 @@ fn test_de_enum_map() {
assert_tokens(
&DeEnum::Map {
a: a,
b: b,
c: c,
d: d,
},
a: a,
b: b,
c: c,
d: d,
},
&[
Token::StructVariant("DeEnum", "Map", 4),
@@ -399,7 +335,7 @@ fn test_lifetimes() {
&[
Token::NewtypeVariant("Lifetimes", "LifetimeSeq"),
Token::I32(5),
]
],
);
assert_ser_tokens(
@@ -407,7 +343,7 @@ fn test_lifetimes() {
&[
Token::NewtypeVariant("Lifetimes", "NoLifetimeSeq"),
Token::I32(5),
]
],
);
assert_ser_tokens(
@@ -419,7 +355,7 @@ fn test_lifetimes() {
Token::I32(5),
Token::StructVariantEnd,
]
],
);
assert_ser_tokens(
@@ -431,7 +367,7 @@ fn test_lifetimes() {
Token::I32(5),
Token::StructVariantEnd,
]
],
);
}
@@ -446,7 +382,7 @@ fn test_generic_struct() {
Token::U32(5),
Token::StructEnd,
]
],
);
}
@@ -454,10 +390,7 @@ fn test_generic_struct() {
fn test_generic_newtype_struct() {
assert_tokens(
&GenericNewTypeStruct(5u32),
&[
Token::NewtypeStruct("GenericNewTypeStruct"),
Token::U32(5),
]
&[Token::NewtypeStruct("GenericNewTypeStruct"), Token::U32(5)],
);
}
@@ -470,7 +403,7 @@ fn test_generic_tuple_struct() {
Token::U32(5),
Token::U32(6),
Token::TupleStructEnd,
]
],
);
}
@@ -478,9 +411,7 @@ fn test_generic_tuple_struct() {
fn test_generic_enum_unit() {
assert_tokens(
&GenericEnum::Unit::<u32, u32>,
&[
Token::UnitVariant("GenericEnum", "Unit"),
]
&[Token::UnitVariant("GenericEnum", "Unit")],
);
}
@@ -491,7 +422,7 @@ fn test_generic_enum_newtype() {
&[
Token::NewtypeVariant("GenericEnum", "NewType"),
Token::U32(5),
]
],
);
}
@@ -504,7 +435,7 @@ fn test_generic_enum_seq() {
Token::U32(5),
Token::U32(6),
Token::TupleVariantEnd,
]
],
);
}
@@ -522,7 +453,7 @@ fn test_generic_enum_map() {
Token::U32(6),
Token::StructVariantEnd,
]
],
);
}
@@ -537,7 +468,7 @@ fn test_default_ty_param() {
Token::UnitStruct("PhantomData"),
Token::StructEnd,
]
],
);
}
@@ -549,7 +480,10 @@ fn test_enum_state_field() {
}
assert_tokens(
&SomeEnum::Key { key: 'a', state: true },
&SomeEnum::Key {
key: 'a',
state: true,
},
&[
Token::StructVariant("SomeEnum", "Key", 2),
@@ -560,7 +494,7 @@ fn test_enum_state_field() {
Token::Bool(true),
Token::StructVariantEnd,
]
],
);
}
@@ -569,12 +503,8 @@ fn test_untagged_enum() {
#[derive(Debug, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
enum Untagged {
A {
a: u8,
},
B {
b: u8,
},
A { a: u8 },
B { b: u8 },
C,
D(u8),
E(String),
@@ -590,7 +520,7 @@ fn test_untagged_enum() {
Token::U8(1),
Token::StructEnd,
]
],
);
assert_tokens(
@@ -602,53 +532,27 @@ fn test_untagged_enum() {
Token::U8(2),
Token::StructEnd,
]
],
);
assert_tokens(
&Untagged::C,
&[
Token::Unit,
]
);
assert_tokens(&Untagged::C, &[Token::Unit]);
assert_tokens(
&Untagged::D(4),
&[
Token::U8(4),
]
);
assert_tokens(
&Untagged::E("e".to_owned()),
&[
Token::Str("e"),
]
);
assert_tokens(&Untagged::D(4), &[Token::U8(4)]);
assert_tokens(&Untagged::E("e".to_owned()), &[Token::Str("e")]);
assert_tokens(
&Untagged::F(1, 2),
&[
Token::Tuple(2),
Token::U8(1),
Token::U8(2),
Token::TupleEnd,
]
&[Token::Tuple(2), Token::U8(1), Token::U8(2), Token::TupleEnd],
);
assert_de_tokens_error::<Untagged>(
&[
Token::None,
],
Error::Message("data did not match any variant of untagged enum Untagged".to_owned()),
&[Token::None],
Error::Message("data did not match any variant of untagged enum Untagged".to_owned(),),
);
assert_de_tokens_error::<Untagged>(
&[
Token::Tuple(1),
Token::U8(1),
Token::TupleEnd,
],
Error::Message("data did not match any variant of untagged enum Untagged".to_owned()),
&[Token::Tuple(1), Token::U8(1), Token::TupleEnd],
Error::Message("data did not match any variant of untagged enum Untagged".to_owned(),),
);
assert_de_tokens_error::<Untagged>(
@@ -659,7 +563,7 @@ fn test_untagged_enum() {
Token::U8(3),
Token::TupleEnd,
],
Error::Message("data did not match any variant of untagged enum Untagged".to_owned()),
Error::Message("data did not match any variant of untagged enum Untagged".to_owned(),),
);
}
@@ -676,12 +580,8 @@ fn test_internally_tagged_enum() {
#[derive(Debug, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
enum InternallyTagged {
A {
a: u8,
},
B {
b: u8,
},
A { a: u8 },
B { b: u8 },
C,
D(BTreeMap<String, String>),
E(Newtype),
@@ -700,7 +600,7 @@ fn test_internally_tagged_enum() {
Token::U8(1),
Token::StructEnd,
]
],
);
assert_tokens(
@@ -715,7 +615,7 @@ fn test_internally_tagged_enum() {
Token::U8(2),
Token::StructEnd,
]
],
);
assert_tokens(
@@ -727,7 +627,7 @@ fn test_internally_tagged_enum() {
Token::Str("C"),
Token::StructEnd,
]
],
);
assert_tokens(
@@ -739,7 +639,7 @@ fn test_internally_tagged_enum() {
Token::Str("D"),
Token::MapEnd,
]
],
);
assert_tokens(
@@ -751,7 +651,7 @@ fn test_internally_tagged_enum() {
Token::Str("E"),
Token::MapEnd,
]
],
);
assert_tokens(
@@ -766,14 +666,11 @@ fn test_internally_tagged_enum() {
Token::U8(6),
Token::StructEnd,
]
],
);
assert_de_tokens_error::<InternallyTagged>(
&[
Token::Map(Some(0)),
Token::MapEnd,
],
&[Token::Map(Some(0)), Token::MapEnd],
Error::Message("missing field `type`".to_owned()),
);
@@ -786,7 +683,7 @@ fn test_internally_tagged_enum() {
Token::MapEnd,
],
Error::Message("unknown variant `Z`, expected one of `A`, `B`, `C`, `D`, `E`, `F`".to_owned()),
Error::Message("unknown variant `Z`, expected one of `A`, `B`, `C`, `D`, `E`, `F`".to_owned(),),
);
}
@@ -811,7 +708,7 @@ fn test_adjacently_tagged_enum() {
Token::Str("Unit"),
Token::StructEnd,
]
],
);
// unit with tag first
@@ -827,7 +724,7 @@ fn test_adjacently_tagged_enum() {
Token::Unit,
Token::StructEnd,
]
],
);
// unit with content first
@@ -843,7 +740,7 @@ fn test_adjacently_tagged_enum() {
Token::Str("Unit"),
Token::StructEnd,
]
],
);
// newtype with tag first
@@ -859,7 +756,7 @@ fn test_adjacently_tagged_enum() {
Token::U8(1),
Token::StructEnd,
]
],
);
// newtype with content first
@@ -875,7 +772,7 @@ fn test_adjacently_tagged_enum() {
Token::Str("Newtype"),
Token::StructEnd,
]
],
);
// tuple with tag first
@@ -894,7 +791,7 @@ fn test_adjacently_tagged_enum() {
Token::TupleEnd,
Token::StructEnd,
]
],
);
// tuple with content first
@@ -913,7 +810,7 @@ fn test_adjacently_tagged_enum() {
Token::Str("Tuple"),
Token::StructEnd,
]
],
);
// struct with tag first
@@ -932,7 +829,7 @@ fn test_adjacently_tagged_enum() {
Token::StructEnd,
Token::StructEnd,
]
],
);
// struct with content first
@@ -951,7 +848,7 @@ fn test_adjacently_tagged_enum() {
Token::Str("Struct"),
Token::StructEnd,
]
],
);
}
@@ -983,7 +880,7 @@ fn test_enum_in_internally_tagged_enum() {
Token::Unit,
Token::MapEnd,
]
],
);
assert_tokens(
@@ -998,7 +895,7 @@ fn test_enum_in_internally_tagged_enum() {
Token::U8(1),
Token::MapEnd,
]
],
);
assert_tokens(
@@ -1016,7 +913,7 @@ fn test_enum_in_internally_tagged_enum() {
Token::TupleStructEnd,
Token::MapEnd,
]
],
);
assert_tokens(
@@ -1034,7 +931,7 @@ fn test_enum_in_internally_tagged_enum() {
Token::StructEnd,
Token::MapEnd,
]
],
);
}
@@ -1056,17 +953,12 @@ fn test_enum_in_untagged_enum() {
assert_tokens(
&Outer::Inner(Inner::Unit),
&[
Token::UnitVariant("Inner", "Unit"),
]
&[Token::UnitVariant("Inner", "Unit")],
);
assert_tokens(
&Outer::Inner(Inner::Newtype(1)),
&[
Token::NewtypeVariant("Inner", "Newtype"),
Token::U8(1),
]
&[Token::NewtypeVariant("Inner", "Newtype"), Token::U8(1)],
);
assert_tokens(
@@ -1076,7 +968,7 @@ fn test_enum_in_untagged_enum() {
Token::U8(1),
Token::U8(1),
Token::TupleVariantEnd,
]
],
);
assert_tokens(
@@ -1088,7 +980,7 @@ fn test_enum_in_untagged_enum() {
Token::U8(1),
Token::StructVariantEnd,
]
],
);
}
@@ -1122,7 +1014,10 @@ fn test_rename_all() {
}
assert_tokens(
&E::Serialize { serialize: true, serialize_seq: true },
&E::Serialize {
serialize: true,
serialize_seq: true,
},
&[
Token::StructVariant("E", "serialize", 2),
Token::Str("serialize"),
@@ -1130,11 +1025,14 @@ fn test_rename_all() {
Token::Str("serializeSeq"),
Token::Bool(true),
Token::StructVariantEnd,
]
],
);
assert_tokens(
&E::SerializeSeq { serialize: true, serialize_seq: true },
&E::SerializeSeq {
serialize: true,
serialize_seq: true,
},
&[
Token::StructVariant("E", "serialize_seq", 2),
Token::Str("serialize"),
@@ -1142,11 +1040,14 @@ fn test_rename_all() {
Token::Str("serialize-seq"),
Token::Bool(true),
Token::StructVariantEnd,
]
],
);
assert_tokens(
&E::SerializeMap { serialize: true, serialize_seq: true },
&E::SerializeMap {
serialize: true,
serialize_seq: true,
},
&[
Token::StructVariant("E", "serialize_map", 2),
Token::Str("SERIALIZE"),
@@ -1154,11 +1055,14 @@ fn test_rename_all() {
Token::Str("SERIALIZE_SEQ"),
Token::Bool(true),
Token::StructVariantEnd,
]
],
);
assert_tokens(
&S { serialize: true, serialize_seq: true },
&S {
serialize: true,
serialize_seq: true,
},
&[
Token::Struct("S", 2),
Token::Str("Serialize"),
@@ -1166,6 +1070,6 @@ fn test_rename_all() {
Token::Str("SerializeSeq"),
Token::Bool(true),
Token::StructEnd,
]
],
);
}
test_suite/tests/test_remote.rs
+23 -7
View File
@@ -23,7 +23,7 @@ mod remote {
b: Unit,
}
pub struct StructPub {
pub struct StructPub {
pub a: u8,
pub b: Unit,
}
@@ -113,7 +113,10 @@ struct UnitDef;
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::PrimitivePriv")]
struct PrimitivePrivDef(#[serde(getter = "remote::PrimitivePriv::get")] u8);
struct PrimitivePrivDef(
#[serde(getter = "remote::PrimitivePriv::get")]
u8
);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::PrimitivePub")]
@@ -121,21 +124,34 @@ struct PrimitivePubDef(u8);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::NewtypePriv")]
struct NewtypePrivDef(#[serde(getter = "remote::NewtypePriv::get", with = "UnitDef")] remote::Unit);
struct NewtypePrivDef(
#[serde(getter = "remote::NewtypePriv::get", with = "UnitDef")]
remote::Unit
);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::NewtypePub")]
struct NewtypePubDef(#[serde(with = "UnitDef")] remote::Unit);
struct NewtypePubDef(
#[serde(with = "UnitDef")]
remote::Unit
);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::TuplePriv")]
struct TuplePrivDef(
#[serde(getter = "remote::TuplePriv::first")] u8,
#[serde(getter = "remote::TuplePriv::second", with = "UnitDef")] remote::Unit);
#[serde(getter = "remote::TuplePriv::first")]
u8,
#[serde(getter = "remote::TuplePriv::second", with = "UnitDef")]
remote::Unit
);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::TuplePub")]
struct TuplePubDef(u8, #[serde(with = "UnitDef")] remote::Unit);
struct TuplePubDef(
u8,
#[serde(with = "UnitDef")]
remote::Unit
);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::StructPriv")]
test_suite/tests/test_ser.rs
+14 -15
View File
@@ -13,12 +13,7 @@ use std::str;
extern crate serde;
extern crate serde_test;
use self::serde_test::{
Error,
Token,
assert_ser_tokens,
assert_ser_tokens_error,
};
use self::serde_test::{Error, Token, assert_ser_tokens, assert_ser_tokens_error};
extern crate fnv;
use self::fnv::FnvHasher;
@@ -372,13 +367,12 @@ fn test_net_ipaddr() {
#[test]
#[cfg(unix)]
fn test_cannot_serialize_paths() {
let path = unsafe {
str::from_utf8_unchecked(b"Hello \xF0\x90\x80World")
};
let path = unsafe { str::from_utf8_unchecked(b"Hello \xF0\x90\x80World") };
assert_ser_tokens_error(
&Path::new(path),
&[],
Error::Message("path contains invalid UTF-8 characters".to_owned()));
Error::Message("path contains invalid UTF-8 characters".to_owned()),
);
let mut path_buf = PathBuf::new();
path_buf.push(path);
@@ -386,7 +380,8 @@ fn test_cannot_serialize_paths() {
assert_ser_tokens_error(
&path_buf,
&[],
Error::Message("path contains invalid UTF-8 characters".to_owned()));
Error::Message("path contains invalid UTF-8 characters".to_owned()),
);
}
#[test]
@@ -394,17 +389,21 @@ fn test_enum_skipped() {
assert_ser_tokens_error(
&Enum::SkippedUnit,
&[],
Error::Message("the enum variant Enum::SkippedUnit cannot be serialized".to_owned()));
Error::Message("the enum variant Enum::SkippedUnit cannot be serialized".to_owned(),),
);
assert_ser_tokens_error(
&Enum::SkippedOne(42),
&[],
Error::Message("the enum variant Enum::SkippedOne cannot be serialized".to_owned()));
Error::Message("the enum variant Enum::SkippedOne cannot be serialized".to_owned(),),
);
assert_ser_tokens_error(
&Enum::SkippedSeq(1, 2),
&[],
Error::Message("the enum variant Enum::SkippedSeq cannot be serialized".to_owned()));
Error::Message("the enum variant Enum::SkippedSeq cannot be serialized".to_owned(),),
);
assert_ser_tokens_error(
&Enum::SkippedMap { _a: 1, _b: 2 },
&[],
Error::Message("the enum variant Enum::SkippedMap cannot be serialized".to_owned()));
Error::Message("the enum variant Enum::SkippedMap cannot be serialized".to_owned(),),
);
}