1187 lines
26 KiB
Rust
1187 lines
26 KiB
Rust
// Copyright 2017 Serde Developers
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
#![cfg_attr(feature = "cargo-clippy", allow(cast_lossless))]
|
|
|
|
#[macro_use]
|
|
extern crate serde_derive;
|
|
|
|
extern crate serde;
|
|
use self::serde::{Serialize, Serializer, Deserialize, Deserializer};
|
|
use self::serde::de::{self, Unexpected};
|
|
|
|
extern crate serde_test;
|
|
use self::serde_test::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens,
|
|
assert_de_tokens_error};
|
|
|
|
trait MyDefault: Sized {
|
|
fn my_default() -> Self;
|
|
}
|
|
|
|
trait ShouldSkip: Sized {
|
|
fn should_skip(&self) -> bool;
|
|
}
|
|
|
|
trait SerializeWith: Sized {
|
|
fn serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer;
|
|
}
|
|
|
|
trait DeserializeWith: Sized {
|
|
fn deserialize_with<'de, D>(de: D) -> Result<Self, D::Error>
|
|
where
|
|
D: Deserializer<'de>;
|
|
}
|
|
|
|
impl MyDefault for i32 {
|
|
fn my_default() -> Self {
|
|
123
|
|
}
|
|
}
|
|
|
|
impl ShouldSkip for i32 {
|
|
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,
|
|
{
|
|
if *self == 123 {
|
|
true.serialize(ser)
|
|
} else {
|
|
false.serialize(ser)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl DeserializeWith for i32 {
|
|
fn deserialize_with<'de, D>(de: D) -> Result<Self, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
if try!(Deserialize::deserialize(de)) {
|
|
Ok(123)
|
|
} else {
|
|
Ok(2)
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
struct DefaultStruct<A, B, C, D, E>
|
|
where
|
|
C: MyDefault,
|
|
E: MyDefault,
|
|
{
|
|
a1: A,
|
|
#[serde(default)]
|
|
a2: B,
|
|
#[serde(default="MyDefault::my_default")]
|
|
a3: C,
|
|
#[serde(skip_deserializing)]
|
|
a4: D,
|
|
#[serde(skip_deserializing, default="MyDefault::my_default")]
|
|
a5: E,
|
|
}
|
|
|
|
#[test]
|
|
fn test_default_struct() {
|
|
assert_de_tokens(
|
|
&DefaultStruct {
|
|
a1: 1,
|
|
a2: 2,
|
|
a3: 3,
|
|
a4: 0,
|
|
a5: 123,
|
|
},
|
|
&[
|
|
Token::Struct { name: "DefaultStruct", len: 3 },
|
|
|
|
Token::Str("a1"),
|
|
Token::I32(1),
|
|
|
|
Token::Str("a2"),
|
|
Token::I32(2),
|
|
|
|
Token::Str("a3"),
|
|
Token::I32(3),
|
|
|
|
Token::Str("a4"),
|
|
Token::I32(4),
|
|
|
|
Token::Str("a5"),
|
|
Token::I32(5),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
|
|
assert_de_tokens(
|
|
&DefaultStruct {
|
|
a1: 1,
|
|
a2: 0,
|
|
a3: 123,
|
|
a4: 0,
|
|
a5: 123,
|
|
},
|
|
&[
|
|
Token::Struct { name: "DefaultStruct", len: 3 },
|
|
|
|
Token::Str("a1"),
|
|
Token::I32(1),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
enum DefaultEnum<A, B, C, D, E>
|
|
where
|
|
C: MyDefault,
|
|
E: MyDefault,
|
|
{
|
|
Struct {
|
|
a1: A,
|
|
#[serde(default)]
|
|
a2: B,
|
|
#[serde(default="MyDefault::my_default")]
|
|
a3: C,
|
|
#[serde(skip_deserializing)]
|
|
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,
|
|
},
|
|
&[
|
|
Token::StructVariant { name: "DefaultEnum", variant: "Struct", len: 3 },
|
|
|
|
Token::Str("a1"),
|
|
Token::I32(1),
|
|
|
|
Token::Str("a2"),
|
|
Token::I32(2),
|
|
|
|
Token::Str("a3"),
|
|
Token::I32(3),
|
|
|
|
Token::Str("a4"),
|
|
Token::I32(4),
|
|
|
|
Token::Str("a5"),
|
|
Token::I32(5),
|
|
|
|
Token::StructVariantEnd,
|
|
],
|
|
);
|
|
|
|
assert_de_tokens(
|
|
&DefaultEnum::Struct {
|
|
a1: 1,
|
|
a2: 0,
|
|
a3: 123,
|
|
a4: 0,
|
|
a5: 123,
|
|
},
|
|
&[
|
|
Token::StructVariant { name: "DefaultEnum", variant: "Struct", len: 3 },
|
|
|
|
Token::Str("a1"),
|
|
Token::I32(1),
|
|
|
|
Token::StructVariantEnd,
|
|
],
|
|
);
|
|
}
|
|
|
|
// Does not implement std::default::Default.
|
|
#[derive(Debug, PartialEq, Deserialize)]
|
|
struct NoStdDefault(i8);
|
|
|
|
impl MyDefault for NoStdDefault {
|
|
fn my_default() -> Self {
|
|
NoStdDefault(123)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Deserialize)]
|
|
struct ContainsNoStdDefault<A: MyDefault> {
|
|
#[serde(default="MyDefault::my_default")]
|
|
a: A,
|
|
}
|
|
|
|
// Tests that a struct field does not need to implement std::default::Default if
|
|
// it is annotated with `default=...`.
|
|
#[test]
|
|
fn test_no_std_default() {
|
|
assert_de_tokens(
|
|
&ContainsNoStdDefault { a: NoStdDefault(123) },
|
|
&[Token::Struct { name: "ContainsNoStdDefault", len: 1 }, Token::StructEnd],
|
|
);
|
|
|
|
assert_de_tokens(
|
|
&ContainsNoStdDefault { a: NoStdDefault(8) },
|
|
&[
|
|
Token::Struct { name: "ContainsNoStdDefault", len: 1 },
|
|
|
|
Token::Str("a"),
|
|
Token::NewtypeStruct { name: "NoStdDefault" },
|
|
Token::I8(8),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
}
|
|
|
|
// Does not implement Deserialize.
|
|
#[derive(Debug, PartialEq)]
|
|
struct NotDeserializeStruct(i8);
|
|
|
|
impl Default for NotDeserializeStruct {
|
|
fn default() -> Self {
|
|
NotDeserializeStruct(123)
|
|
}
|
|
}
|
|
|
|
impl DeserializeWith for NotDeserializeStruct {
|
|
fn deserialize_with<'de, D>(_: D) -> Result<Self, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
panic!()
|
|
}
|
|
}
|
|
|
|
// Does not implement Deserialize.
|
|
#[derive(Debug, PartialEq)]
|
|
enum NotDeserializeEnum {
|
|
Trouble,
|
|
}
|
|
|
|
impl MyDefault for NotDeserializeEnum {
|
|
fn my_default() -> Self {
|
|
NotDeserializeEnum::Trouble
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Deserialize)]
|
|
struct ContainsNotDeserialize<A, B, C: DeserializeWith, E: MyDefault> {
|
|
#[serde(skip_deserializing)]
|
|
a: A,
|
|
#[serde(skip_deserializing, default)]
|
|
b: B,
|
|
#[serde(deserialize_with="DeserializeWith::deserialize_with", default)]
|
|
c: C,
|
|
#[serde(skip_deserializing, default="MyDefault::my_default")]
|
|
e: E,
|
|
}
|
|
|
|
// Tests that a struct field does not need to implement Deserialize if it is
|
|
// annotated with skip_deserializing, whether using the std Default or a
|
|
// custom default.
|
|
#[test]
|
|
fn test_elt_not_deserialize() {
|
|
assert_de_tokens(
|
|
&ContainsNotDeserialize {
|
|
a: NotDeserializeStruct(123),
|
|
b: NotDeserializeStruct(123),
|
|
c: NotDeserializeStruct(123),
|
|
e: NotDeserializeEnum::Trouble,
|
|
},
|
|
&[Token::Struct { name: "ContainsNotDeserialize", len: 1 }, Token::StructEnd],
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct DenyUnknown {
|
|
a1: i32,
|
|
}
|
|
|
|
#[test]
|
|
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,
|
|
},
|
|
&[
|
|
Token::Struct { name: "DefaultStruct", len: 3 },
|
|
|
|
Token::Str("whoops1"),
|
|
Token::I32(2),
|
|
|
|
Token::Str("a1"),
|
|
Token::I32(1),
|
|
|
|
Token::Str("whoops2"),
|
|
Token::Seq { len: Some(1) },
|
|
Token::I32(2),
|
|
Token::SeqEnd,
|
|
|
|
Token::Str("a2"),
|
|
Token::I32(2),
|
|
|
|
Token::Str("whoops3"),
|
|
Token::I32(2),
|
|
|
|
Token::Str("a3"),
|
|
Token::I32(3),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
|
|
assert_de_tokens_error::<DenyUnknown>(
|
|
&[
|
|
Token::Struct { name: "DenyUnknown", len: 1 },
|
|
|
|
Token::Str("a1"),
|
|
Token::I32(1),
|
|
|
|
Token::Str("whoops"),
|
|
],
|
|
"unknown field `whoops`, expected `a1`",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
#[serde(rename="Superhero")]
|
|
struct RenameStruct {
|
|
a1: i32,
|
|
#[serde(rename="a3")]
|
|
a2: i32,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
#[serde(rename(serialize="SuperheroSer", deserialize="SuperheroDe"))]
|
|
struct RenameStructSerializeDeserialize {
|
|
a1: i32,
|
|
#[serde(rename(serialize="a4", deserialize="a5"))]
|
|
a2: i32,
|
|
}
|
|
|
|
#[test]
|
|
fn test_rename_struct() {
|
|
assert_tokens(
|
|
&RenameStruct { a1: 1, a2: 2 },
|
|
&[
|
|
Token::Struct { name: "Superhero", len: 2 },
|
|
|
|
Token::Str("a1"),
|
|
Token::I32(1),
|
|
|
|
Token::Str("a3"),
|
|
Token::I32(2),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
|
|
assert_ser_tokens(
|
|
&RenameStructSerializeDeserialize { a1: 1, a2: 2 },
|
|
&[
|
|
Token::Struct { name: "SuperheroSer", len: 2 },
|
|
|
|
Token::Str("a1"),
|
|
Token::I32(1),
|
|
|
|
Token::Str("a4"),
|
|
Token::I32(2),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
|
|
assert_de_tokens(
|
|
&RenameStructSerializeDeserialize { a1: 1, a2: 2 },
|
|
&[
|
|
Token::Struct { name: "SuperheroDe", len: 2 },
|
|
|
|
Token::Str("a1"),
|
|
Token::I32(1),
|
|
|
|
Token::Str("a5"),
|
|
Token::I32(2),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
#[serde(rename="Superhero")]
|
|
enum RenameEnum {
|
|
#[serde(rename="bruce_wayne")]
|
|
Batman,
|
|
#[serde(rename="clark_kent")]
|
|
Superman(i8),
|
|
#[serde(rename="diana_prince")]
|
|
WonderWoman(i8, i8),
|
|
#[serde(rename="barry_allan")]
|
|
Flash {
|
|
#[serde(rename="b")]
|
|
a: i32,
|
|
},
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Deserialize, Serialize)]
|
|
#[serde(rename(serialize="SuperheroSer", deserialize="SuperheroDe"))]
|
|
enum RenameEnumSerializeDeserialize<A> {
|
|
#[serde(rename(serialize="dick_grayson", deserialize="jason_todd"))]
|
|
Robin {
|
|
a: i8,
|
|
#[serde(rename(serialize="c"))]
|
|
#[serde(rename(deserialize="d"))]
|
|
b: A,
|
|
},
|
|
}
|
|
|
|
#[test]
|
|
fn test_rename_enum() {
|
|
assert_tokens(
|
|
&RenameEnum::Batman,
|
|
&[Token::UnitVariant { name: "Superhero", variant: "bruce_wayne" }],
|
|
);
|
|
|
|
assert_tokens(
|
|
&RenameEnum::Superman(0),
|
|
&[
|
|
Token::NewtypeVariant { name: "Superhero", variant: "clark_kent" },
|
|
Token::I8(0),
|
|
],
|
|
);
|
|
|
|
assert_tokens(
|
|
&RenameEnum::WonderWoman(0, 1),
|
|
&[
|
|
Token::TupleVariant { name: "Superhero", variant: "diana_prince", len: 2 },
|
|
Token::I8(0),
|
|
Token::I8(1),
|
|
Token::TupleVariantEnd,
|
|
],
|
|
);
|
|
|
|
assert_tokens(
|
|
&RenameEnum::Flash { a: 1 },
|
|
&[
|
|
Token::StructVariant { name: "Superhero", variant: "barry_allan", len: 1 },
|
|
|
|
Token::Str("b"),
|
|
Token::I32(1),
|
|
|
|
Token::StructVariantEnd,
|
|
],
|
|
);
|
|
|
|
assert_ser_tokens(
|
|
&RenameEnumSerializeDeserialize::Robin {
|
|
a: 0,
|
|
b: String::new(),
|
|
},
|
|
&[
|
|
Token::StructVariant { name: "SuperheroSer", variant: "dick_grayson", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(0),
|
|
|
|
Token::Str("c"),
|
|
Token::Str(""),
|
|
|
|
Token::StructVariantEnd,
|
|
],
|
|
);
|
|
|
|
assert_de_tokens(
|
|
&RenameEnumSerializeDeserialize::Robin {
|
|
a: 0,
|
|
b: String::new(),
|
|
},
|
|
&[
|
|
Token::StructVariant { name: "SuperheroDe", variant: "jason_todd", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(0),
|
|
|
|
Token::Str("d"),
|
|
Token::Str(""),
|
|
|
|
Token::StructVariantEnd,
|
|
],
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Serialize)]
|
|
struct SkipSerializingStruct<'a, B, C>
|
|
where
|
|
C: ShouldSkip,
|
|
{
|
|
a: &'a i8,
|
|
#[serde(skip_serializing)]
|
|
b: B,
|
|
#[serde(skip_serializing_if="ShouldSkip::should_skip")]
|
|
c: C,
|
|
}
|
|
|
|
#[test]
|
|
fn test_skip_serializing_struct() {
|
|
let a = 1;
|
|
assert_ser_tokens(
|
|
&SkipSerializingStruct { a: &a, b: 2, c: 3 },
|
|
&[
|
|
Token::Struct { name: "SkipSerializingStruct", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::Str("c"),
|
|
Token::I32(3),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
|
|
assert_ser_tokens(
|
|
&SkipSerializingStruct {
|
|
a: &a,
|
|
b: 2,
|
|
c: 123,
|
|
},
|
|
&[
|
|
Token::Struct { name: "SkipSerializingStruct", len: 1 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
struct SkipStruct<B>
|
|
{
|
|
a: i8,
|
|
#[serde(skip)]
|
|
b: B,
|
|
}
|
|
|
|
#[test]
|
|
fn test_skip_struct() {
|
|
assert_ser_tokens(
|
|
&SkipStruct { a: 1, b: 2 },
|
|
&[
|
|
Token::Struct { name: "SkipStruct", len: 1 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
|
|
assert_de_tokens(
|
|
&SkipStruct { a: 1, b: 0 },
|
|
&[
|
|
Token::Struct { name: "SkipStruct", len: 1 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Serialize)]
|
|
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 },
|
|
&[
|
|
Token::StructVariant { name: "SkipSerializingEnum", variant: "Struct", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::Str("c"),
|
|
Token::I32(3),
|
|
|
|
Token::StructVariantEnd,
|
|
],
|
|
);
|
|
|
|
assert_ser_tokens(
|
|
&SkipSerializingEnum::Struct {
|
|
a: &a,
|
|
_b: 2,
|
|
c: 123,
|
|
},
|
|
&[
|
|
Token::StructVariant { name: "SkipSerializingEnum", variant: "Struct", len: 1 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::StructVariantEnd,
|
|
],
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
struct NotSerializeStruct(i8);
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
enum NotSerializeEnum {
|
|
Trouble,
|
|
}
|
|
|
|
impl SerializeWith for NotSerializeEnum {
|
|
fn serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
"trouble".serialize(ser)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Serialize)]
|
|
struct ContainsNotSerialize<'a, B, C, D>
|
|
where
|
|
B: 'a,
|
|
D: SerializeWith,
|
|
{
|
|
a: &'a Option<i8>,
|
|
#[serde(skip_serializing)]
|
|
b: &'a B,
|
|
#[serde(skip_serializing)]
|
|
c: Option<C>,
|
|
#[serde(serialize_with="SerializeWith::serialize_with")]
|
|
d: D,
|
|
}
|
|
|
|
#[test]
|
|
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,
|
|
},
|
|
&[
|
|
Token::Struct { name: "ContainsNotSerialize", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::Some,
|
|
Token::I8(1),
|
|
|
|
Token::Str("d"),
|
|
Token::Str("trouble"),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Serialize)]
|
|
struct SerializeWithStruct<'a, B>
|
|
where
|
|
B: SerializeWith,
|
|
{
|
|
a: &'a i8,
|
|
#[serde(serialize_with="SerializeWith::serialize_with")]
|
|
b: B,
|
|
}
|
|
|
|
#[test]
|
|
fn test_serialize_with_struct() {
|
|
let a = 1;
|
|
assert_ser_tokens(
|
|
&SerializeWithStruct { a: &a, b: 2 },
|
|
&[
|
|
Token::Struct { name: "SerializeWithStruct", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::Str("b"),
|
|
Token::Bool(false),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
|
|
assert_ser_tokens(
|
|
&SerializeWithStruct { a: &a, b: 123 },
|
|
&[
|
|
Token::Struct { name: "SerializeWithStruct", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::Str("b"),
|
|
Token::Bool(true),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Serialize)]
|
|
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 },
|
|
&[
|
|
Token::StructVariant { name: "SerializeWithEnum", variant: "Struct", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::Str("b"),
|
|
Token::Bool(false),
|
|
|
|
Token::StructVariantEnd,
|
|
],
|
|
);
|
|
|
|
assert_ser_tokens(
|
|
&SerializeWithEnum::Struct { a: &a, b: 123 },
|
|
&[
|
|
Token::StructVariant { name: "SerializeWithEnum", variant: "Struct", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::Str("b"),
|
|
Token::Bool(true),
|
|
|
|
Token::StructVariantEnd,
|
|
],
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
enum WithVariant {
|
|
#[serde(serialize_with="serialize_unit_variant_as_i8")]
|
|
#[serde(deserialize_with="deserialize_i8_as_unit_variant")]
|
|
Unit,
|
|
|
|
#[serde(serialize_with="SerializeWith::serialize_with")]
|
|
#[serde(deserialize_with="DeserializeWith::deserialize_with")]
|
|
Newtype(i32),
|
|
|
|
#[serde(serialize_with="serialize_variant_as_string")]
|
|
#[serde(deserialize_with="deserialize_string_as_variant")]
|
|
Tuple(String, u8),
|
|
|
|
#[serde(serialize_with="serialize_variant_as_string")]
|
|
#[serde(deserialize_with="deserialize_string_as_variant")]
|
|
Struct {
|
|
f1: String,
|
|
f2: u8,
|
|
},
|
|
}
|
|
|
|
fn serialize_unit_variant_as_i8<S>(serializer: S) -> Result<S::Ok, S::Error>
|
|
where S: Serializer,
|
|
{
|
|
serializer.serialize_i8(0)
|
|
}
|
|
|
|
fn deserialize_i8_as_unit_variant<'de, D>(deserializer: D) -> Result<(), D::Error>
|
|
where D: Deserializer<'de>,
|
|
{
|
|
let n = i8::deserialize(deserializer)?;
|
|
match n {
|
|
0 => Ok(()),
|
|
_ => Err(de::Error::invalid_value(Unexpected::Signed(n as i64), &"0")),
|
|
}
|
|
}
|
|
|
|
fn serialize_variant_as_string<S>(f1: &str,
|
|
f2: &u8,
|
|
serializer: S)
|
|
-> Result<S::Ok, S::Error>
|
|
where S: Serializer,
|
|
{
|
|
serializer.serialize_str(format!("{};{:?}", f1, f2).as_str())
|
|
}
|
|
|
|
fn deserialize_string_as_variant<'de, D>(deserializer: D) -> Result<(String, u8), D::Error>
|
|
where D: Deserializer<'de>,
|
|
{
|
|
let s = String::deserialize(deserializer)?;
|
|
let mut pieces = s.split(';');
|
|
let f1 = match pieces.next() {
|
|
Some(x) => x,
|
|
None => return Err(de::Error::invalid_length(0, &"2")),
|
|
};
|
|
let f2 = match pieces.next() {
|
|
Some(x) => x,
|
|
None => return Err(de::Error::invalid_length(1, &"2")),
|
|
};
|
|
let f2 = match f2.parse() {
|
|
Ok(n) => n,
|
|
Err(_) => {
|
|
return Err(de::Error::invalid_value(Unexpected::Str(f2), &"an 8-bit signed integer"));
|
|
}
|
|
};
|
|
Ok((f1.into(), f2))
|
|
}
|
|
|
|
#[test]
|
|
fn test_serialize_with_variant() {
|
|
assert_ser_tokens(
|
|
&WithVariant::Unit,
|
|
&[
|
|
Token::NewtypeVariant { name: "WithVariant", variant: "Unit" },
|
|
Token::I8(0),
|
|
],
|
|
);
|
|
|
|
assert_ser_tokens(
|
|
&WithVariant::Newtype(123),
|
|
&[
|
|
Token::NewtypeVariant { name: "WithVariant", variant: "Newtype" },
|
|
Token::Bool(true),
|
|
],
|
|
);
|
|
|
|
assert_ser_tokens(
|
|
&WithVariant::Tuple("hello".into(), 0),
|
|
&[
|
|
Token::NewtypeVariant { name: "WithVariant", variant: "Tuple" },
|
|
Token::Str("hello;0"),
|
|
],
|
|
);
|
|
|
|
assert_ser_tokens(
|
|
&WithVariant::Struct { f1: "world".into(), f2: 1 },
|
|
&[
|
|
Token::NewtypeVariant { name: "WithVariant", variant: "Struct" },
|
|
Token::Str("world;1"),
|
|
],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_deserialize_with_variant() {
|
|
assert_de_tokens(
|
|
&WithVariant::Unit,
|
|
&[
|
|
Token::NewtypeVariant { name: "WithVariant", variant: "Unit" },
|
|
Token::I8(0),
|
|
],
|
|
);
|
|
|
|
assert_de_tokens(
|
|
&WithVariant::Newtype(123),
|
|
&[
|
|
Token::NewtypeVariant { name: "WithVariant", variant: "Newtype" },
|
|
Token::Bool(true),
|
|
],
|
|
);
|
|
|
|
assert_de_tokens(
|
|
&WithVariant::Tuple("hello".into(), 0),
|
|
&[
|
|
Token::NewtypeVariant { name: "WithVariant", variant: "Tuple" },
|
|
Token::Str("hello;0"),
|
|
],
|
|
);
|
|
|
|
assert_de_tokens(
|
|
&WithVariant::Struct { f1: "world".into(), f2: 1 },
|
|
&[
|
|
Token::NewtypeVariant { name: "WithVariant", variant: "Struct" },
|
|
Token::Str("world;1"),
|
|
],
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Deserialize)]
|
|
struct DeserializeWithStruct<B>
|
|
where
|
|
B: DeserializeWith,
|
|
{
|
|
a: i8,
|
|
#[serde(deserialize_with="DeserializeWith::deserialize_with")]
|
|
b: B,
|
|
}
|
|
|
|
#[test]
|
|
fn test_deserialize_with_struct() {
|
|
assert_de_tokens(
|
|
&DeserializeWithStruct { a: 1, b: 2 },
|
|
&[
|
|
Token::Struct { name: "DeserializeWithStruct", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::Str("b"),
|
|
Token::Bool(false),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
|
|
assert_de_tokens(
|
|
&DeserializeWithStruct { a: 1, b: 123 },
|
|
&[
|
|
Token::Struct { name: "DeserializeWithStruct", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::Str("b"),
|
|
Token::Bool(true),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Deserialize)]
|
|
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 },
|
|
&[
|
|
Token::StructVariant { name: "DeserializeWithEnum", variant: "Struct", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::Str("b"),
|
|
Token::Bool(false),
|
|
|
|
Token::StructVariantEnd,
|
|
],
|
|
);
|
|
|
|
assert_de_tokens(
|
|
&DeserializeWithEnum::Struct { a: 1, b: 123 },
|
|
&[
|
|
Token::StructVariant { name: "DeserializeWithEnum", variant: "Struct", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(1),
|
|
|
|
Token::Str("b"),
|
|
Token::Bool(true),
|
|
|
|
Token::StructVariantEnd,
|
|
],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_missing_renamed_field_struct() {
|
|
assert_de_tokens_error::<RenameStruct>(
|
|
&[
|
|
Token::Struct { name: "Superhero", len: 2 },
|
|
|
|
Token::Str("a1"),
|
|
Token::I32(1),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
"missing field `a3`",
|
|
);
|
|
|
|
assert_de_tokens_error::<RenameStructSerializeDeserialize>(
|
|
&[
|
|
Token::Struct { name: "SuperheroDe", len: 2 },
|
|
|
|
Token::Str("a1"),
|
|
Token::I32(1),
|
|
|
|
Token::StructEnd,
|
|
],
|
|
"missing field `a5`",
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_missing_renamed_field_enum() {
|
|
assert_de_tokens_error::<RenameEnum>(
|
|
&[
|
|
Token::StructVariant { name: "Superhero", variant: "barry_allan", len: 1 },
|
|
|
|
Token::StructVariantEnd,
|
|
],
|
|
"missing field `b`",
|
|
);
|
|
|
|
assert_de_tokens_error::<RenameEnumSerializeDeserialize<i8>>(
|
|
&[
|
|
Token::StructVariant { name: "SuperheroDe", variant: "jason_todd", len: 2 },
|
|
|
|
Token::Str("a"),
|
|
Token::I8(0),
|
|
|
|
Token::StructVariantEnd,
|
|
],
|
|
"missing field `d`",
|
|
);
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Deserialize)]
|
|
enum InvalidLengthEnum {
|
|
A(i32, i32, i32),
|
|
B(
|
|
#[serde(skip_deserializing)]
|
|
i32,
|
|
i32,
|
|
i32
|
|
),
|
|
}
|
|
|
|
#[test]
|
|
fn test_invalid_length_enum() {
|
|
assert_de_tokens_error::<InvalidLengthEnum>(
|
|
&[
|
|
Token::TupleVariant { name: "InvalidLengthEnum", variant: "A", len: 3 },
|
|
Token::I32(1),
|
|
Token::TupleVariantEnd,
|
|
],
|
|
"invalid length 1, expected tuple of 3 elements",
|
|
);
|
|
assert_de_tokens_error::<InvalidLengthEnum>(
|
|
&[
|
|
Token::TupleVariant { name: "InvalidLengthEnum", variant: "B", len: 3 },
|
|
Token::I32(1),
|
|
Token::TupleVariantEnd,
|
|
],
|
|
"invalid length 1, expected tuple of 2 elements",
|
|
);
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize, PartialEq, Debug)]
|
|
#[serde(into="EnumToU32", from="EnumToU32")]
|
|
struct StructFromEnum(Option<u32>);
|
|
|
|
impl Into<EnumToU32> for StructFromEnum {
|
|
fn into(self) -> EnumToU32 {
|
|
match self {
|
|
StructFromEnum(v) => v.into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<EnumToU32> for StructFromEnum {
|
|
fn from(v: EnumToU32) -> Self {
|
|
StructFromEnum(v.into())
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Serialize, Deserialize, PartialEq, Debug)]
|
|
#[serde(into="Option<u32>", from="Option<u32>")]
|
|
enum EnumToU32 {
|
|
One,
|
|
Two,
|
|
Three,
|
|
Four,
|
|
Nothing,
|
|
}
|
|
|
|
impl Into<Option<u32>> for EnumToU32 {
|
|
fn into(self) -> Option<u32> {
|
|
match self {
|
|
EnumToU32::One => Some(1),
|
|
EnumToU32::Two => Some(2),
|
|
EnumToU32::Three => Some(3),
|
|
EnumToU32::Four => Some(4),
|
|
EnumToU32::Nothing => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<Option<u32>> for EnumToU32 {
|
|
fn from(v: Option<u32>) -> Self {
|
|
match v {
|
|
Some(1) => EnumToU32::One,
|
|
Some(2) => EnumToU32::Two,
|
|
Some(3) => EnumToU32::Three,
|
|
Some(4) => EnumToU32::Four,
|
|
_ => 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)]);
|
|
}
|