mirror of
https://github.com/pezkuwichain/serde.git
synced 2026-04-22 17:18:08 +00:00
Rename serde_tests to testing
This commit is contained in:
David Tolnay
@@ -0,0 +1,95 @@
|
||||
#[macro_export]
|
||||
macro_rules! declare_ser_tests {
|
||||
($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
|
||||
$(
|
||||
#[test]
|
||||
fn $name() {
|
||||
$(
|
||||
::token::assert_ser_tokens(&$value, $tokens);
|
||||
)+
|
||||
}
|
||||
)+
|
||||
}
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
macro_rules! btreemap {
|
||||
() => {
|
||||
BTreeMap::new()
|
||||
};
|
||||
($($key:expr => $value:expr),+) => {
|
||||
{
|
||||
let mut map = BTreeMap::new();
|
||||
$(map.insert($key, $value);)+
|
||||
map
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! btreeset {
|
||||
() => {
|
||||
BTreeSet::new()
|
||||
};
|
||||
($($value:expr),+) => {
|
||||
{
|
||||
let mut set = BTreeSet::new();
|
||||
$(set.insert($value);)+
|
||||
set
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! btreemap {
|
||||
() => {
|
||||
BTreeMap::new()
|
||||
};
|
||||
($($key:expr => $value:expr),+) => {
|
||||
{
|
||||
let mut map = BTreeMap::new();
|
||||
$(map.insert($key, $value);)+
|
||||
map
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! hashset {
|
||||
() => {
|
||||
HashSet::new()
|
||||
};
|
||||
($($value:expr),+) => {
|
||||
{
|
||||
let mut set = HashSet::new();
|
||||
$(set.insert($value);)+
|
||||
set
|
||||
}
|
||||
};
|
||||
($hasher:ident @ $($value:expr),+) => {
|
||||
{
|
||||
use std::hash::BuildHasherDefault;
|
||||
let mut set = HashSet::with_hasher(BuildHasherDefault::<$hasher>::default());
|
||||
$(set.insert($value);)+
|
||||
set
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! hashmap {
|
||||
() => {
|
||||
HashMap::new()
|
||||
};
|
||||
($($key:expr => $value:expr),+) => {
|
||||
{
|
||||
let mut map = HashMap::new();
|
||||
$(map.insert($key, $value);)+
|
||||
map
|
||||
}
|
||||
};
|
||||
($hasher:ident @ $($key:expr => $value:expr),+) => {
|
||||
{
|
||||
use std::hash::BuildHasherDefault;
|
||||
let mut map = HashMap::with_hasher(BuildHasherDefault::<$hasher>::default());
|
||||
$(map.insert($key, $value);)+
|
||||
map
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
#![cfg_attr(feature = "nightly", feature(plugin))]
|
||||
#![cfg_attr(feature = "nightly", plugin(clippy))]
|
||||
|
||||
include!(concat!(env!("OUT_DIR"), "/test.rs"));
|
||||
@@ -0,0 +1,11 @@
|
||||
#[macro_use]
|
||||
mod macros;
|
||||
|
||||
mod token;
|
||||
|
||||
mod test_annotations;
|
||||
mod test_bytes;
|
||||
mod test_de;
|
||||
mod test_gen;
|
||||
mod test_macros;
|
||||
mod test_ser;
|
||||
@@ -0,0 +1,950 @@
|
||||
extern crate serde;
|
||||
use self::serde::{Serialize, Serializer, Deserialize, Deserializer};
|
||||
|
||||
use token::{
|
||||
Error,
|
||||
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: &mut S) -> Result<(), S::Error>
|
||||
where S: Serializer;
|
||||
}
|
||||
|
||||
trait DeserializeWith: Sized {
|
||||
fn deserialize_with<D>(de: &mut D) -> Result<Self, D::Error>
|
||||
where D: Deserializer;
|
||||
}
|
||||
|
||||
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: &mut S) -> Result<(), S::Error>
|
||||
where S: Serializer
|
||||
{
|
||||
if *self == 123 {
|
||||
true.serialize(ser)
|
||||
} else {
|
||||
false.serialize(ser)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl DeserializeWith for i32 {
|
||||
fn deserialize_with<D>(de: &mut D) -> Result<Self, D::Error>
|
||||
where D: Deserializer
|
||||
{
|
||||
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 },
|
||||
vec![
|
||||
Token::StructStart("DefaultStruct", Some(3)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a2"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a3"),
|
||||
Token::I32(3),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a4"),
|
||||
Token::I32(4),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a5"),
|
||||
Token::I32(5),
|
||||
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_de_tokens(
|
||||
&DefaultStruct { a1: 1, a2: 0, a3: 123, a4: 0, a5: 123 },
|
||||
vec![
|
||||
Token::StructStart("DefaultStruct", Some(1)),
|
||||
|
||||
Token::StructSep,
|
||||
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 },
|
||||
vec![
|
||||
Token::EnumMapStart("DefaultEnum", "Struct", Some(5)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a2"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a3"),
|
||||
Token::I32(3),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a4"),
|
||||
Token::I32(4),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a5"),
|
||||
Token::I32(5),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_de_tokens(
|
||||
&DefaultEnum::Struct { a1: 1, a2: 0, a3: 123, a4: 0, a5: 123 },
|
||||
vec![
|
||||
Token::EnumMapStart("DefaultEnum", "Struct", Some(5)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
// 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) },
|
||||
vec![
|
||||
Token::StructStart("ContainsNoStdDefault", Some(1)),
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_de_tokens(
|
||||
&ContainsNoStdDefault { a: NoStdDefault(8) },
|
||||
vec![
|
||||
Token::StructStart("ContainsNoStdDefault", Some(1)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a"),
|
||||
Token::StructNewType("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<D>(_: &mut D) -> Result<Self, D::Error>
|
||||
where D: Deserializer
|
||||
{
|
||||
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,
|
||||
},
|
||||
vec![
|
||||
Token::StructStart("ContainsNotDeserialize", Some(3)),
|
||||
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 },
|
||||
vec![
|
||||
Token::StructStart("DefaultStruct", Some(5)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("whoops1"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("whoops2"),
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a2"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("whoops3"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a3"),
|
||||
Token::I32(3),
|
||||
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_de_tokens_error::<DenyUnknown>(
|
||||
vec![
|
||||
Token::StructStart("DenyUnknown", Some(2)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("whoops"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::StructEnd,
|
||||
],
|
||||
Error::UnknownFieldError("whoops".to_owned())
|
||||
);
|
||||
}
|
||||
|
||||
#[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 },
|
||||
vec![
|
||||
Token::StructStart("Superhero", Some(2)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a3"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_ser_tokens(
|
||||
&RenameStructSerializeDeserialize { a1: 1, a2: 2 },
|
||||
&[
|
||||
Token::StructStart("SuperheroSer", Some(2)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a4"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_de_tokens(
|
||||
&RenameStructSerializeDeserialize { a1: 1, a2: 2 },
|
||||
vec![
|
||||
Token::StructStart("SuperheroDe", Some(2)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::StructSep,
|
||||
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,
|
||||
vec![
|
||||
Token::EnumUnit("Superhero", "bruce_wayne"),
|
||||
]
|
||||
);
|
||||
|
||||
assert_tokens(
|
||||
&RenameEnum::Superman(0),
|
||||
vec![
|
||||
Token::EnumNewType("Superhero", "clark_kent"),
|
||||
Token::I8(0),
|
||||
]
|
||||
);
|
||||
|
||||
assert_tokens(
|
||||
&RenameEnum::WonderWoman(0, 1),
|
||||
vec![
|
||||
Token::EnumSeqStart("Superhero", "diana_prince", Some(2)),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::I8(0),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::I8(1),
|
||||
|
||||
Token::EnumSeqEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_tokens(
|
||||
&RenameEnum::Flash { a: 1 },
|
||||
vec![
|
||||
Token::EnumMapStart("Superhero", "barry_allan", Some(1)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_ser_tokens(
|
||||
&RenameEnumSerializeDeserialize::Robin {
|
||||
a: 0,
|
||||
b: String::new(),
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("SuperheroSer", "dick_grayson", Some(2)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(0),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("c"),
|
||||
Token::Str(""),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_de_tokens(
|
||||
&RenameEnumSerializeDeserialize::Robin {
|
||||
a: 0,
|
||||
b: String::new(),
|
||||
},
|
||||
vec![
|
||||
Token::EnumMapStart("SuperheroDe", "jason_todd", Some(2)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(0),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("d"),
|
||||
Token::Str(""),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[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::StructStart("SkipSerializingStruct", Some(2)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_ser_tokens(
|
||||
&SkipSerializingStruct {
|
||||
a: &a,
|
||||
b: 2,
|
||||
c: 123,
|
||||
},
|
||||
&[
|
||||
Token::StructStart("SkipSerializingStruct", Some(1)),
|
||||
|
||||
Token::StructSep,
|
||||
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::EnumMapStart("SkipSerializingEnum", "Struct", Some(2)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_ser_tokens(
|
||||
&SkipSerializingEnum::Struct {
|
||||
a: &a,
|
||||
_b: 2,
|
||||
c: 123,
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(1)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
struct NotSerializeStruct(i8);
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
enum NotSerializeEnum { Trouble }
|
||||
|
||||
impl SerializeWith for NotSerializeEnum {
|
||||
fn serialize_with<S>(&self, ser: &mut S) -> Result<(), 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::StructStart("ContainsNotSerialize", Some(2)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a"),
|
||||
Token::Option(true),
|
||||
Token::I8(1),
|
||||
|
||||
Token::StructSep,
|
||||
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::StructStart("SerializeWithStruct", Some(2)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("b"),
|
||||
Token::Bool(false),
|
||||
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_ser_tokens(
|
||||
&SerializeWithStruct {
|
||||
a: &a,
|
||||
b: 123,
|
||||
},
|
||||
&[
|
||||
Token::StructStart("SerializeWithStruct", Some(2)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::StructSep,
|
||||
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::EnumMapStart("SerializeWithEnum", "Struct", Some(2)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("b"),
|
||||
Token::Bool(false),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_ser_tokens(
|
||||
&SerializeWithEnum::Struct {
|
||||
a: &a,
|
||||
b: 123,
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("SerializeWithEnum", "Struct", Some(2)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("b"),
|
||||
Token::Bool(true),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[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,
|
||||
},
|
||||
vec![
|
||||
Token::StructStart("DeserializeWithStruct", Some(2)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("b"),
|
||||
Token::Bool(false),
|
||||
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_de_tokens(
|
||||
&DeserializeWithStruct {
|
||||
a: 1,
|
||||
b: 123,
|
||||
},
|
||||
vec![
|
||||
Token::StructStart("DeserializeWithStruct", Some(2)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::StructSep,
|
||||
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,
|
||||
},
|
||||
vec![
|
||||
Token::EnumMapStart("DeserializeWithEnum", "Struct", Some(2)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("b"),
|
||||
Token::Bool(false),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_de_tokens(
|
||||
&DeserializeWithEnum::Struct {
|
||||
a: 1,
|
||||
b: 123,
|
||||
},
|
||||
vec![
|
||||
Token::EnumMapStart("DeserializeWithEnum", "Struct", Some(2)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("b"),
|
||||
Token::Bool(true),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_missing_renamed_field_struct() {
|
||||
assert_de_tokens_error::<RenameStruct>(
|
||||
vec![
|
||||
Token::StructStart("Superhero", Some(2)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::StructEnd,
|
||||
],
|
||||
Error::MissingFieldError("a3"),
|
||||
);
|
||||
|
||||
assert_de_tokens_error::<RenameStructSerializeDeserialize>(
|
||||
vec![
|
||||
Token::StructStart("SuperheroDe", Some(2)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::StructEnd,
|
||||
],
|
||||
Error::MissingFieldError("a5"),
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_missing_renamed_field_enum() {
|
||||
assert_de_tokens_error::<RenameEnum>(
|
||||
vec![
|
||||
Token::EnumMapStart("Superhero", "barry_allan", Some(1)),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
],
|
||||
Error::MissingFieldError("b"),
|
||||
);
|
||||
|
||||
assert_de_tokens_error::<RenameEnumSerializeDeserialize<i8>>(
|
||||
vec![
|
||||
Token::EnumMapStart("SuperheroDe", "jason_todd", Some(2)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(0),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
],
|
||||
Error::MissingFieldError("d"),
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,185 @@
|
||||
use std::fmt;
|
||||
use std::error;
|
||||
|
||||
extern crate serde;
|
||||
use self::serde::Serialize;
|
||||
use self::serde::bytes::{ByteBuf, Bytes};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
struct Error;
|
||||
|
||||
impl serde::ser::Error for Error {
|
||||
fn custom<T: Into<String>>(_: T) -> Error { Error }
|
||||
}
|
||||
|
||||
impl serde::de::Error for Error {
|
||||
fn custom<T: Into<String>>(_: T) -> Error { Error }
|
||||
|
||||
fn end_of_stream() -> Error { Error }
|
||||
}
|
||||
|
||||
impl fmt::Display for Error {
|
||||
fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
||||
formatter.write_str(format!("{:?}", self).as_ref())
|
||||
}
|
||||
}
|
||||
|
||||
impl error::Error for Error {
|
||||
fn description(&self) -> &str {
|
||||
"Serde Deserialization Error"
|
||||
}
|
||||
|
||||
fn cause(&self) -> Option<&error::Error> {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
struct BytesSerializer {
|
||||
bytes: Vec<u8>,
|
||||
}
|
||||
|
||||
impl BytesSerializer {
|
||||
fn new(bytes: Vec<u8>) -> Self {
|
||||
BytesSerializer {
|
||||
bytes: bytes,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl serde::Serializer for BytesSerializer {
|
||||
type Error = Error;
|
||||
|
||||
fn serialize_unit(&mut self) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_bool(&mut self, _v: bool) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_i64(&mut self, _v: i64) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_u64(&mut self, _v: u64) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_f32(&mut self, _v: f32) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_f64(&mut self, _v: f64) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_char(&mut self, _v: char) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_str(&mut self, _v: &str) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_none(&mut self) -> Result<(), Error> {
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_some<V>(&mut self, _value: V) -> Result<(), Error>
|
||||
where V: serde::Serialize,
|
||||
{
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_seq<V>(&mut self, _visitor: V) -> Result<(), Error>
|
||||
where V: serde::ser::SeqVisitor,
|
||||
{
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_seq_elt<T>(&mut self, _value: T) -> Result<(), Error>
|
||||
where T: serde::Serialize
|
||||
{
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_map<V>(&mut self, _visitor: V) -> Result<(), Error>
|
||||
where V: serde::ser::MapVisitor,
|
||||
{
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_map_elt<K, V>(&mut self, _key: K, _value: V) -> Result<(), Error>
|
||||
where K: serde::Serialize,
|
||||
V: serde::Serialize,
|
||||
{
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn serialize_bytes(&mut self, bytes: &[u8]) -> Result<(), Error> {
|
||||
assert_eq!(self.bytes, bytes);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
struct BytesDeserializer {
|
||||
bytes: Option<Vec<u8>>,
|
||||
}
|
||||
|
||||
impl BytesDeserializer {
|
||||
fn new(bytes: Vec<u8>) -> Self {
|
||||
BytesDeserializer {
|
||||
bytes: Some(bytes),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl serde::Deserializer for BytesDeserializer {
|
||||
type Error = Error;
|
||||
|
||||
fn deserialize<V>(&mut self, _visitor: V) -> Result<V::Value, Error>
|
||||
where V: serde::de::Visitor,
|
||||
{
|
||||
Err(Error)
|
||||
}
|
||||
|
||||
fn deserialize_bytes<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
|
||||
where V: serde::de::Visitor,
|
||||
{
|
||||
visitor.visit_byte_buf(self.bytes.take().unwrap())
|
||||
}
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[test]
|
||||
fn test_bytes_ser_bytes() {
|
||||
let buf = vec![];
|
||||
let bytes = Bytes::from(&buf);
|
||||
let mut ser = BytesSerializer::new(vec![]);
|
||||
bytes.serialize(&mut ser).unwrap();
|
||||
|
||||
let buf = vec![1, 2, 3];
|
||||
let bytes = Bytes::from(&buf);
|
||||
let mut ser = BytesSerializer::new(vec![1, 2, 3]);
|
||||
bytes.serialize(&mut ser).unwrap();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[test]
|
||||
fn test_byte_buf_de_bytes() {
|
||||
let mut de = BytesDeserializer::new(vec![]);
|
||||
let bytes = serde::Deserialize::deserialize(&mut de);
|
||||
assert_eq!(bytes, Ok(ByteBuf::new()));
|
||||
|
||||
let mut de = BytesDeserializer::new(vec![1, 2, 3]);
|
||||
let bytes = serde::Deserialize::deserialize(&mut de);
|
||||
assert_eq!(bytes, Ok(ByteBuf::from(vec![1, 2, 3])));
|
||||
}
|
||||
@@ -0,0 +1,779 @@
|
||||
use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
|
||||
use std::net;
|
||||
use std::path::PathBuf;
|
||||
|
||||
extern crate fnv;
|
||||
use self::fnv::FnvHasher;
|
||||
|
||||
use token::{
|
||||
Error,
|
||||
Token,
|
||||
assert_de_tokens,
|
||||
assert_de_tokens_ignore,
|
||||
assert_de_tokens_error,
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(Copy, Clone, PartialEq, Debug, Deserialize)]
|
||||
struct UnitStruct;
|
||||
|
||||
#[derive(PartialEq, Debug, Deserialize)]
|
||||
struct TupleStruct(i32, i32, i32);
|
||||
|
||||
#[derive(PartialEq, Debug, Deserialize)]
|
||||
struct Struct {
|
||||
a: i32,
|
||||
b: i32,
|
||||
#[serde(skip_deserializing)]
|
||||
c: i32,
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Debug, Deserialize)]
|
||||
enum Enum {
|
||||
Unit,
|
||||
Simple(i32),
|
||||
Seq(i32, i32, i32),
|
||||
Map { a: i32, b: i32, c: i32 }
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
macro_rules! declare_test {
|
||||
($name:ident { $($value:expr => $tokens:expr,)+ }) => {
|
||||
#[test]
|
||||
fn $name() {
|
||||
$(
|
||||
// Test ser/de roundtripping
|
||||
assert_de_tokens(&$value, $tokens);
|
||||
|
||||
// Test that the tokens are ignorable
|
||||
assert_de_tokens_ignore($tokens);
|
||||
)+
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! declare_tests {
|
||||
($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
|
||||
$(
|
||||
declare_test!($name { $($value => $tokens,)+ });
|
||||
)+
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! declare_error_tests {
|
||||
($($name:ident<$target:ident> { $tokens:expr, $expected:expr, })+) => {
|
||||
$(
|
||||
#[test]
|
||||
fn $name() {
|
||||
assert_de_tokens_error::<$target>($tokens, $expected);
|
||||
}
|
||||
)+
|
||||
}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
declare_tests! {
|
||||
test_bool {
|
||||
true => vec![Token::Bool(true)],
|
||||
false => vec![Token::Bool(false)],
|
||||
}
|
||||
test_isize {
|
||||
0isize => vec![Token::Isize(0)],
|
||||
0isize => vec![Token::I8(0)],
|
||||
0isize => vec![Token::I16(0)],
|
||||
0isize => vec![Token::I32(0)],
|
||||
0isize => vec![Token::I64(0)],
|
||||
0isize => vec![Token::Usize(0)],
|
||||
0isize => vec![Token::U8(0)],
|
||||
0isize => vec![Token::U16(0)],
|
||||
0isize => vec![Token::U32(0)],
|
||||
0isize => vec![Token::U64(0)],
|
||||
0isize => vec![Token::F32(0.)],
|
||||
0isize => vec![Token::F64(0.)],
|
||||
}
|
||||
test_ints {
|
||||
0isize => vec![Token::Isize(0)],
|
||||
0i8 => vec![Token::I8(0)],
|
||||
0i16 => vec![Token::I16(0)],
|
||||
0i32 => vec![Token::I32(0)],
|
||||
0i64 => vec![Token::I64(0)],
|
||||
}
|
||||
test_uints {
|
||||
0usize => vec![Token::Usize(0)],
|
||||
0u8 => vec![Token::U8(0)],
|
||||
0u16 => vec![Token::U16(0)],
|
||||
0u32 => vec![Token::U32(0)],
|
||||
0u64 => vec![Token::U64(0)],
|
||||
}
|
||||
test_floats {
|
||||
0f32 => vec![Token::F32(0.)],
|
||||
0f64 => vec![Token::F64(0.)],
|
||||
}
|
||||
test_char {
|
||||
'a' => vec![Token::Char('a')],
|
||||
'a' => vec![Token::Str("a")],
|
||||
'a' => vec![Token::String("a".to_owned())],
|
||||
}
|
||||
test_string {
|
||||
"abc".to_owned() => vec![Token::Str("abc")],
|
||||
"abc".to_owned() => vec![Token::String("abc".to_owned())],
|
||||
"a".to_owned() => vec![Token::Char('a')],
|
||||
}
|
||||
test_option {
|
||||
None::<i32> => vec![Token::Unit],
|
||||
None::<i32> => vec![Token::Option(false)],
|
||||
Some(1) => vec![Token::I32(1)],
|
||||
Some(1) => vec![
|
||||
Token::Option(true),
|
||||
Token::I32(1),
|
||||
],
|
||||
}
|
||||
test_result {
|
||||
Ok::<i32, i32>(0) => vec![
|
||||
Token::EnumStart("Result"),
|
||||
Token::Str("Ok"),
|
||||
Token::I32(0),
|
||||
],
|
||||
Err::<i32, i32>(1) => vec![
|
||||
Token::EnumStart("Result"),
|
||||
Token::Str("Err"),
|
||||
Token::I32(1),
|
||||
],
|
||||
}
|
||||
test_unit {
|
||||
() => vec![Token::Unit],
|
||||
() => vec![
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
() => vec![
|
||||
Token::SeqStart(None),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
() => vec![
|
||||
Token::TupleStructStart("Anything", Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_unit_struct {
|
||||
UnitStruct => vec![Token::Unit],
|
||||
UnitStruct => vec![
|
||||
Token::UnitStruct("UnitStruct"),
|
||||
],
|
||||
UnitStruct => vec![
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
UnitStruct => vec![
|
||||
Token::SeqStart(None),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_tuple_struct {
|
||||
TupleStruct(1, 2, 3) => vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
TupleStruct(1, 2, 3) => vec![
|
||||
Token::SeqStart(None),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
TupleStruct(1, 2, 3) => vec![
|
||||
Token::TupleStructStart("TupleStruct", Some(3)),
|
||||
Token::TupleStructSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::TupleStructSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::TupleStructSep,
|
||||
Token::I32(3),
|
||||
Token::TupleStructEnd,
|
||||
],
|
||||
TupleStruct(1, 2, 3) => vec![
|
||||
Token::TupleStructStart("TupleStruct", None),
|
||||
Token::TupleStructSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::TupleStructSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::TupleStructSep,
|
||||
Token::I32(3),
|
||||
Token::TupleStructEnd,
|
||||
],
|
||||
}
|
||||
test_btreeset {
|
||||
BTreeSet::<isize>::new() => vec![
|
||||
Token::Unit,
|
||||
],
|
||||
BTreeSet::<isize>::new() => vec![
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
btreeset![btreeset![], btreeset![1], btreeset![2, 3]] => vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(2)),
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::SeqEnd,
|
||||
],
|
||||
BTreeSet::<isize>::new() => vec![
|
||||
Token::UnitStruct("Anything"),
|
||||
],
|
||||
BTreeSet::<isize>::new() => vec![
|
||||
Token::TupleStructStart("Anything", Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_hashset {
|
||||
HashSet::<isize>::new() => vec![
|
||||
Token::Unit,
|
||||
],
|
||||
HashSet::<isize>::new() => vec![
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
hashset![1, 2, 3] => vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
HashSet::<isize>::new() => vec![
|
||||
Token::UnitStruct("Anything"),
|
||||
],
|
||||
HashSet::<isize>::new() => vec![
|
||||
Token::TupleStructStart("Anything", Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
hashset![FnvHasher @ 1, 2, 3] => vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_vec {
|
||||
Vec::<isize>::new() => vec![
|
||||
Token::Unit,
|
||||
],
|
||||
Vec::<isize>::new() => vec![
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
vec![vec![], vec![1], vec![2, 3]] => vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(2)),
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::SeqEnd,
|
||||
],
|
||||
Vec::<isize>::new() => vec![
|
||||
Token::UnitStruct("Anything"),
|
||||
],
|
||||
Vec::<isize>::new() => vec![
|
||||
Token::TupleStructStart("Anything", Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_array {
|
||||
[0; 0] => vec![
|
||||
Token::Unit,
|
||||
],
|
||||
[0; 0] => vec![
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
[0; 0] => vec![
|
||||
Token::SeqArrayStart(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
([0; 0], [1], [2, 3]) => vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(2)),
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::SeqEnd,
|
||||
],
|
||||
([0; 0], [1], [2, 3]) => vec![
|
||||
Token::SeqArrayStart(3),
|
||||
Token::SeqSep,
|
||||
Token::SeqArrayStart(0),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqArrayStart(1),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqArrayStart(2),
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::SeqEnd,
|
||||
],
|
||||
[0; 0] => vec![
|
||||
Token::UnitStruct("Anything"),
|
||||
],
|
||||
[0; 0] => vec![
|
||||
Token::TupleStructStart("Anything", Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_tuple {
|
||||
(1,) => vec![
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
(1, 2, 3) => vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
(1,) => vec![
|
||||
Token::TupleStart(1),
|
||||
Token::TupleSep,
|
||||
Token::I32(1),
|
||||
Token::TupleEnd,
|
||||
],
|
||||
(1, 2, 3) => vec![
|
||||
Token::TupleStart(3),
|
||||
Token::TupleSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::TupleSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::TupleSep,
|
||||
Token::I32(3),
|
||||
Token::TupleEnd,
|
||||
],
|
||||
}
|
||||
test_btreemap {
|
||||
BTreeMap::<isize, isize>::new() => vec![
|
||||
Token::Unit,
|
||||
],
|
||||
BTreeMap::<isize, isize>::new() => vec![
|
||||
Token::MapStart(Some(0)),
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => 2] => vec![
|
||||
Token::MapStart(Some(1)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => 2, 3 => 4] => vec![
|
||||
Token::MapStart(Some(2)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => vec![
|
||||
Token::MapStart(Some(2)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::MapStart(Some(0)),
|
||||
Token::MapEnd,
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(2),
|
||||
Token::MapStart(Some(2)),
|
||||
Token::MapSep,
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(5),
|
||||
Token::I32(6),
|
||||
Token::MapEnd,
|
||||
Token::MapEnd,
|
||||
],
|
||||
BTreeMap::<isize, isize>::new() => vec![
|
||||
Token::UnitStruct("Anything"),
|
||||
],
|
||||
BTreeMap::<isize, isize>::new() => vec![
|
||||
Token::StructStart("Anything", Some(0)),
|
||||
Token::MapEnd,
|
||||
],
|
||||
}
|
||||
test_hashmap {
|
||||
HashMap::<isize, isize>::new() => vec![
|
||||
Token::Unit,
|
||||
],
|
||||
HashMap::<isize, isize>::new() => vec![
|
||||
Token::MapStart(Some(0)),
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![1 => 2] => vec![
|
||||
Token::MapStart(Some(1)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![1 => 2, 3 => 4] => vec![
|
||||
Token::MapStart(Some(2)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]] => vec![
|
||||
Token::MapStart(Some(2)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::MapStart(Some(0)),
|
||||
Token::MapEnd,
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(2),
|
||||
Token::MapStart(Some(2)),
|
||||
Token::MapSep,
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(5),
|
||||
Token::I32(6),
|
||||
Token::MapEnd,
|
||||
Token::MapEnd,
|
||||
],
|
||||
HashMap::<isize, isize>::new() => vec![
|
||||
Token::UnitStruct("Anything"),
|
||||
],
|
||||
HashMap::<isize, isize>::new() => vec![
|
||||
Token::StructStart("Anything", Some(0)),
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![FnvHasher @ 1 => 2, 3 => 4] => vec![
|
||||
Token::MapStart(Some(2)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
Token::MapEnd,
|
||||
],
|
||||
}
|
||||
test_struct {
|
||||
Struct { a: 1, b: 2, c: 0 } => vec![
|
||||
Token::MapStart(Some(3)),
|
||||
Token::MapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
Struct { a: 1, b: 2, c: 0 } => vec![
|
||||
Token::StructStart("Struct", Some(3)),
|
||||
Token::StructSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
Token::StructEnd,
|
||||
],
|
||||
Struct { a: 1, b: 2, c: 0 } => vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_struct_with_skip {
|
||||
Struct { a: 1, b: 2, c: 0 } => vec![
|
||||
Token::MapStart(Some(3)),
|
||||
Token::MapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("d"),
|
||||
Token::I32(4),
|
||||
Token::MapEnd,
|
||||
],
|
||||
Struct { a: 1, b: 2, c: 0 } => vec![
|
||||
Token::StructStart("Struct", Some(3)),
|
||||
Token::StructSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("d"),
|
||||
Token::I32(4),
|
||||
Token::StructEnd,
|
||||
],
|
||||
}
|
||||
test_enum_unit {
|
||||
Enum::Unit => vec![
|
||||
Token::EnumUnit("Enum", "Unit"),
|
||||
],
|
||||
}
|
||||
test_enum_simple {
|
||||
Enum::Simple(1) => vec![
|
||||
Token::EnumNewType("Enum", "Simple"),
|
||||
Token::I32(1),
|
||||
],
|
||||
}
|
||||
test_enum_seq {
|
||||
Enum::Seq(1, 2, 3) => vec![
|
||||
Token::EnumSeqStart("Enum", "Seq", Some(3)),
|
||||
Token::EnumSeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::I32(3),
|
||||
Token::EnumSeqEnd,
|
||||
],
|
||||
}
|
||||
test_enum_map {
|
||||
Enum::Map { a: 1, b: 2, c: 3 } => vec![
|
||||
Token::EnumMapStart("Enum", "Map", Some(3)),
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
Token::EnumMapEnd,
|
||||
],
|
||||
}
|
||||
test_enum_unit_usize {
|
||||
Enum::Unit => vec![
|
||||
Token::EnumStart("Enum"),
|
||||
Token::Usize(0),
|
||||
Token::Unit,
|
||||
],
|
||||
}
|
||||
test_enum_unit_bytes {
|
||||
Enum::Unit => vec![
|
||||
Token::EnumStart("Enum"),
|
||||
Token::Bytes(b"Unit"),
|
||||
Token::Unit,
|
||||
],
|
||||
}
|
||||
test_box {
|
||||
Box::new(0i32) => vec![Token::I32(0)],
|
||||
}
|
||||
test_boxed_slice {
|
||||
Box::new([0, 1, 2]) => vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::I32(0),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_net_ipv4addr {
|
||||
"1.2.3.4".parse::<net::Ipv4Addr>().unwrap() => vec![Token::Str("1.2.3.4")],
|
||||
}
|
||||
test_net_ipv6addr {
|
||||
"::1".parse::<net::Ipv6Addr>().unwrap() => vec![Token::Str("::1")],
|
||||
}
|
||||
test_net_socketaddr {
|
||||
"1.2.3.4:1234".parse::<net::SocketAddr>().unwrap() => vec![Token::Str("1.2.3.4:1234")],
|
||||
"1.2.3.4:1234".parse::<net::SocketAddrV4>().unwrap() => vec![Token::Str("1.2.3.4:1234")],
|
||||
"[::1]:1234".parse::<net::SocketAddrV6>().unwrap() => vec![Token::Str("[::1]:1234")],
|
||||
}
|
||||
test_path_buf {
|
||||
PathBuf::from("/usr/local/lib") => vec![
|
||||
Token::String("/usr/local/lib".to_owned()),
|
||||
],
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "nightly")]
|
||||
#[test]
|
||||
fn test_net_ipaddr() {
|
||||
assert_de_tokens(
|
||||
"1.2.3.4".parse::<net::IpAddr>().unwrap(),
|
||||
vec![Token::Str("1.2.3.4")],
|
||||
);
|
||||
}
|
||||
|
||||
declare_error_tests! {
|
||||
test_unknown_variant<Enum> {
|
||||
vec![
|
||||
Token::EnumUnit("Enum", "Foo"),
|
||||
],
|
||||
Error::UnknownVariantError("Foo".to_owned()),
|
||||
}
|
||||
test_struct_seq_too_long<Struct> {
|
||||
vec![
|
||||
Token::SeqStart(Some(4)),
|
||||
Token::SeqSep, Token::I32(1),
|
||||
Token::SeqSep, Token::I32(2),
|
||||
Token::SeqSep, Token::I32(3),
|
||||
Token::SeqSep, Token::I32(4),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
Error::UnexpectedToken(Token::SeqSep),
|
||||
}
|
||||
test_duplicate_field_struct<Struct> {
|
||||
vec![
|
||||
Token::MapStart(Some(3)),
|
||||
Token::MapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::MapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(3),
|
||||
Token::MapEnd,
|
||||
],
|
||||
Error::DuplicateFieldError("a"),
|
||||
}
|
||||
test_duplicate_field_enum<Enum> {
|
||||
vec![
|
||||
Token::EnumMapStart("Enum", "Map", Some(3)),
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(3),
|
||||
Token::EnumMapEnd,
|
||||
],
|
||||
Error::DuplicateFieldError("a"),
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
// These just test that serde_codegen is able to produce code that compiles
|
||||
// successfully when there are a variety of generics and non-(de)serializable
|
||||
// types involved.
|
||||
|
||||
extern crate serde;
|
||||
use self::serde::ser::{Serialize, Serializer};
|
||||
use self::serde::de::{Deserialize, Deserializer};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct With<T> {
|
||||
t: T,
|
||||
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
|
||||
x: X,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct WithRef<'a, T: 'a> {
|
||||
#[serde(skip_deserializing)]
|
||||
t: Option<&'a T>,
|
||||
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
|
||||
x: X,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct Bounds<T: Serialize + Deserialize> {
|
||||
t: T,
|
||||
option: Option<T>,
|
||||
boxed: Box<T>,
|
||||
option_boxed: Option<Box<T>>,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct NoBounds<T> {
|
||||
t: T,
|
||||
option: Option<T>,
|
||||
boxed: Box<T>,
|
||||
option_boxed: Option<Box<T>>,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
enum EnumWith<T> {
|
||||
Unit,
|
||||
Newtype(
|
||||
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
|
||||
X),
|
||||
Tuple(
|
||||
T,
|
||||
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
|
||||
X),
|
||||
Struct {
|
||||
t: T,
|
||||
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
|
||||
x: X },
|
||||
}
|
||||
|
||||
#[derive(Serialize)]
|
||||
struct MultipleRef<'a, 'b, 'c, T> where T: 'c, 'c: 'b, 'b: 'a {
|
||||
t: T,
|
||||
rrrt: &'a &'b &'c T,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct Newtype(
|
||||
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
|
||||
X
|
||||
);
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct Tuple<T>(
|
||||
T,
|
||||
#[serde(serialize_with="ser_x", deserialize_with="de_x")]
|
||||
X,
|
||||
);
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
enum TreeNode<D> {
|
||||
Split {
|
||||
left: Box<TreeNode<D>>,
|
||||
right: Box<TreeNode<D>>,
|
||||
},
|
||||
Leaf {
|
||||
data: D,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct ListNode<D> {
|
||||
data: D,
|
||||
next: Box<ListNode<D>>,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
#[serde(bound="D: SerializeWith + DeserializeWith")]
|
||||
struct WithTraits1<D, E> {
|
||||
#[serde(serialize_with="SerializeWith::serialize_with",
|
||||
deserialize_with="DeserializeWith::deserialize_with")]
|
||||
d: D,
|
||||
#[serde(serialize_with="SerializeWith::serialize_with",
|
||||
deserialize_with="DeserializeWith::deserialize_with",
|
||||
bound="E: SerializeWith + DeserializeWith")]
|
||||
e: E,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
#[serde(bound(serialize="D: SerializeWith",
|
||||
deserialize="D: DeserializeWith"))]
|
||||
struct WithTraits2<D, E> {
|
||||
#[serde(serialize_with="SerializeWith::serialize_with",
|
||||
deserialize_with="DeserializeWith::deserialize_with")]
|
||||
d: D,
|
||||
#[serde(serialize_with="SerializeWith::serialize_with",
|
||||
bound(serialize="E: SerializeWith"))]
|
||||
#[serde(deserialize_with="DeserializeWith::deserialize_with",
|
||||
bound(deserialize="E: DeserializeWith"))]
|
||||
e: E,
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
trait SerializeWith {
|
||||
fn serialize_with<S: Serializer>(_: &Self, _: &mut S) -> Result<(), S::Error>;
|
||||
}
|
||||
|
||||
trait DeserializeWith: Sized {
|
||||
fn deserialize_with<D: Deserializer>(_: &mut D) -> Result<Self, D::Error>;
|
||||
}
|
||||
|
||||
// Implements neither Serialize nor Deserialize
|
||||
struct X;
|
||||
fn ser_x<S: Serializer>(_: &X, _: &mut S) -> Result<(), S::Error> { panic!() }
|
||||
fn de_x<D: Deserializer>(_: &mut D) -> Result<X, D::Error> { panic!() }
|
||||
|
||||
@@ -0,0 +1,633 @@
|
||||
use std::marker::PhantomData;
|
||||
use token::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens};
|
||||
|
||||
/*
|
||||
trait Trait {
|
||||
type Type;
|
||||
}
|
||||
*/
|
||||
|
||||
// That tests that the derived Serialize implementation doesn't trigger
|
||||
// any warning about `serializer` not being used, in case of empty enums.
|
||||
#[derive(Serialize)]
|
||||
#[allow(dead_code)]
|
||||
#[deny(unused_variables)]
|
||||
enum Void {}
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
||||
struct NamedUnit;
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize)]
|
||||
struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
|
||||
|
||||
#[derive(Debug, PartialEq, Deserialize)]
|
||||
struct DeNamedTuple<A, B, C>(A, B, C);
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize)]
|
||||
struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
|
||||
a: &'a A,
|
||||
b: &'b mut B,
|
||||
c: C,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Deserialize)]
|
||||
struct DeNamedMap<A, B, C> {
|
||||
a: A,
|
||||
b: B,
|
||||
c: C,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize)]
|
||||
enum SerEnum<'a, B: 'a, C: /* Trait + */ 'a, D> where D: /* Trait + */ 'a {
|
||||
Unit,
|
||||
Seq(
|
||||
i8,
|
||||
B,
|
||||
&'a C,
|
||||
//C::Type,
|
||||
&'a mut D,
|
||||
//<D as Trait>::Type,
|
||||
),
|
||||
Map {
|
||||
a: i8,
|
||||
b: B,
|
||||
c: &'a C,
|
||||
//d: C::Type,
|
||||
e: &'a mut D,
|
||||
//f: <D as Trait>::Type,
|
||||
},
|
||||
|
||||
// Make sure we can support more than one variant.
|
||||
_Unit2,
|
||||
_Seq2(
|
||||
i8,
|
||||
B,
|
||||
&'a C,
|
||||
//C::Type,
|
||||
&'a mut D,
|
||||
//<D as Trait>::Type,
|
||||
),
|
||||
_Map2 {
|
||||
a: i8,
|
||||
b: B,
|
||||
c: &'a C,
|
||||
//d: C::Type,
|
||||
e: &'a mut D,
|
||||
//f: <D as Trait>::Type,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
||||
enum DeEnum<B, C: /* Trait */, D> /* where D: Trait */ {
|
||||
Unit,
|
||||
Seq(
|
||||
i8,
|
||||
B,
|
||||
C,
|
||||
//C::Type,
|
||||
D,
|
||||
//<D as Trait>::Type,
|
||||
),
|
||||
Map {
|
||||
a: i8,
|
||||
b: B,
|
||||
c: C,
|
||||
//d: C::Type,
|
||||
e: D,
|
||||
//f: <D as Trait>::Type,
|
||||
},
|
||||
|
||||
// Make sure we can support more than one variant.
|
||||
_Unit2,
|
||||
_Seq2(
|
||||
i8,
|
||||
B,
|
||||
C,
|
||||
//C::Type,
|
||||
D,
|
||||
//<D as Trait>::Type,
|
||||
),
|
||||
_Map2 {
|
||||
a: i8,
|
||||
b: B,
|
||||
c: C,
|
||||
//d: C::Type,
|
||||
e: D,
|
||||
//f: <D as Trait>::Type,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Serialize)]
|
||||
enum Lifetimes<'a> {
|
||||
LifetimeSeq(&'a i32),
|
||||
NoLifetimeSeq(i32),
|
||||
LifetimeMap { a: &'a i32 },
|
||||
NoLifetimeMap { a: i32 },
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct GenericStruct<T> {
|
||||
x: T,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct GenericNewTypeStruct<T>(T);
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct GenericTupleStruct<T, U>(T, U);
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub enum GenericEnum<T, U> {
|
||||
Unit,
|
||||
NewType(T),
|
||||
Seq(T, U),
|
||||
Map { x: T, y: U },
|
||||
}
|
||||
|
||||
trait AssociatedType {
|
||||
type X;
|
||||
}
|
||||
|
||||
impl AssociatedType for i32 {
|
||||
type X = i32;
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
||||
struct DefaultTyParam<T: AssociatedType<X=i32> = i32> {
|
||||
phantom: PhantomData<T>
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_named_unit() {
|
||||
assert_tokens(
|
||||
&NamedUnit,
|
||||
vec![Token::UnitStruct("NamedUnit")]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ser_named_tuple() {
|
||||
let a = 5;
|
||||
let mut b = 6;
|
||||
let c = 7;
|
||||
assert_ser_tokens(
|
||||
&SerNamedTuple(&a, &mut b, c),
|
||||
&[
|
||||
Token::TupleStructStart("SerNamedTuple", Some(3)),
|
||||
Token::TupleStructSep,
|
||||
Token::I32(5),
|
||||
|
||||
Token::TupleStructSep,
|
||||
Token::I32(6),
|
||||
|
||||
Token::TupleStructSep,
|
||||
Token::I32(7),
|
||||
|
||||
Token::TupleStructEnd,
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_de_named_tuple() {
|
||||
assert_de_tokens(
|
||||
&DeNamedTuple(5, 6, 7),
|
||||
vec![
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::I32(5),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(6),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(7),
|
||||
|
||||
Token::SeqEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_de_tokens(
|
||||
&DeNamedTuple(5, 6, 7),
|
||||
vec![
|
||||
Token::TupleStructStart("DeNamedTuple", Some(3)),
|
||||
Token::TupleStructSep,
|
||||
Token::I32(5),
|
||||
|
||||
Token::TupleStructSep,
|
||||
Token::I32(6),
|
||||
|
||||
Token::TupleStructSep,
|
||||
Token::I32(7),
|
||||
|
||||
Token::TupleStructEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ser_named_map() {
|
||||
let a = 5;
|
||||
let mut b = 6;
|
||||
let c = 7;
|
||||
|
||||
assert_ser_tokens(
|
||||
&SerNamedMap {
|
||||
a: &a,
|
||||
b: &mut b,
|
||||
c: c,
|
||||
},
|
||||
&[
|
||||
Token::StructStart("SerNamedMap", Some(3)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(5),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(6),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(7),
|
||||
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_de_named_map() {
|
||||
assert_de_tokens(
|
||||
&DeNamedMap {
|
||||
a: 5,
|
||||
b: 6,
|
||||
c: 7,
|
||||
},
|
||||
vec![
|
||||
Token::StructStart("DeNamedMap", Some(3)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(5),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(6),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(7),
|
||||
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ser_enum_unit() {
|
||||
assert_ser_tokens(
|
||||
&SerEnum::Unit::<u32, u32, u32>,
|
||||
&[
|
||||
Token::EnumUnit("SerEnum", "Unit"),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ser_enum_seq() {
|
||||
let a = 1;
|
||||
let b = 2;
|
||||
let c = 3;
|
||||
//let d = 4;
|
||||
let mut e = 5;
|
||||
//let f = 6;
|
||||
|
||||
assert_ser_tokens(
|
||||
&SerEnum::Seq(
|
||||
a,
|
||||
b,
|
||||
&c,
|
||||
//d,
|
||||
&mut e,
|
||||
//f,
|
||||
),
|
||||
&[
|
||||
Token::EnumSeqStart("SerEnum", "Seq", Some(4)),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::I8(1),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::I32(3),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::I32(5),
|
||||
|
||||
Token::EnumSeqEnd,
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ser_enum_map() {
|
||||
let a = 1;
|
||||
let b = 2;
|
||||
let c = 3;
|
||||
//let d = 4;
|
||||
let mut e = 5;
|
||||
//let f = 6;
|
||||
|
||||
assert_ser_tokens(
|
||||
&SerEnum::Map {
|
||||
a: a,
|
||||
b: b,
|
||||
c: &c,
|
||||
//d: d,
|
||||
e: &mut e,
|
||||
//f: f,
|
||||
},
|
||||
&[
|
||||
Token::EnumMapStart("SerEnum", "Map", Some(4)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("e"),
|
||||
Token::I32(5),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_de_enum_unit() {
|
||||
assert_tokens(
|
||||
&DeEnum::Unit::<u32, u32, u32>,
|
||||
vec![
|
||||
Token::EnumUnit("DeEnum", "Unit"),
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_de_enum_seq() {
|
||||
let a = 1;
|
||||
let b = 2;
|
||||
let c = 3;
|
||||
//let d = 4;
|
||||
let e = 5;
|
||||
//let f = 6;
|
||||
|
||||
assert_tokens(
|
||||
&DeEnum::Seq(
|
||||
a,
|
||||
b,
|
||||
c,
|
||||
//d,
|
||||
e,
|
||||
//f,
|
||||
),
|
||||
vec![
|
||||
Token::EnumSeqStart("DeEnum", "Seq", Some(4)),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::I8(1),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::I32(3),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::I32(5),
|
||||
|
||||
Token::EnumSeqEnd,
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_de_enum_map() {
|
||||
let a = 1;
|
||||
let b = 2;
|
||||
let c = 3;
|
||||
//let d = 4;
|
||||
let e = 5;
|
||||
//let f = 6;
|
||||
|
||||
assert_tokens(
|
||||
&DeEnum::Map {
|
||||
a: a,
|
||||
b: b,
|
||||
c: c,
|
||||
//d: d,
|
||||
e: e,
|
||||
//f: f,
|
||||
},
|
||||
vec![
|
||||
Token::EnumMapStart("DeEnum", "Map", Some(4)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I8(1),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("e"),
|
||||
Token::I32(5),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_lifetimes() {
|
||||
let value = 5;
|
||||
|
||||
assert_ser_tokens(
|
||||
&Lifetimes::LifetimeSeq(&value),
|
||||
&[
|
||||
Token::EnumNewType("Lifetimes", "LifetimeSeq"),
|
||||
Token::I32(5),
|
||||
]
|
||||
);
|
||||
|
||||
assert_ser_tokens(
|
||||
&Lifetimes::NoLifetimeSeq(5),
|
||||
&[
|
||||
Token::EnumNewType("Lifetimes", "NoLifetimeSeq"),
|
||||
Token::I32(5),
|
||||
]
|
||||
);
|
||||
|
||||
assert_ser_tokens(
|
||||
&Lifetimes::LifetimeMap { a: &value },
|
||||
&[
|
||||
Token::EnumMapStart("Lifetimes", "LifetimeMap", Some(1)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(5),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
|
||||
assert_ser_tokens(
|
||||
&Lifetimes::NoLifetimeMap { a: 5 },
|
||||
&[
|
||||
Token::EnumMapStart("Lifetimes", "NoLifetimeMap", Some(1)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(5),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_generic_struct() {
|
||||
assert_tokens(
|
||||
&GenericStruct { x: 5u32 },
|
||||
vec![
|
||||
Token::StructStart("GenericStruct", Some(1)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("x"),
|
||||
Token::U32(5),
|
||||
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_generic_newtype_struct() {
|
||||
assert_tokens(
|
||||
&GenericNewTypeStruct(5u32),
|
||||
vec![
|
||||
Token::StructNewType("GenericNewTypeStruct"),
|
||||
Token::U32(5),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_generic_tuple_struct() {
|
||||
assert_tokens(
|
||||
&GenericTupleStruct(5u32, 6u32),
|
||||
vec![
|
||||
Token::TupleStructStart("GenericTupleStruct", Some(2)),
|
||||
|
||||
Token::TupleStructSep,
|
||||
Token::U32(5),
|
||||
|
||||
Token::TupleStructSep,
|
||||
Token::U32(6),
|
||||
|
||||
Token::TupleStructEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_generic_enum_unit() {
|
||||
assert_tokens(
|
||||
&GenericEnum::Unit::<u32, u32>,
|
||||
vec![
|
||||
Token::EnumUnit("GenericEnum", "Unit"),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_generic_enum_newtype() {
|
||||
assert_tokens(
|
||||
&GenericEnum::NewType::<u32, u32>(5),
|
||||
vec![
|
||||
Token::EnumNewType("GenericEnum", "NewType"),
|
||||
Token::U32(5),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_generic_enum_seq() {
|
||||
assert_tokens(
|
||||
&GenericEnum::Seq::<u32, u32>(5, 6),
|
||||
vec![
|
||||
Token::EnumSeqStart("GenericEnum", "Seq", Some(2)),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::U32(5),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::U32(6),
|
||||
|
||||
Token::EnumSeqEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_generic_enum_map() {
|
||||
assert_tokens(
|
||||
&GenericEnum::Map::<u32, u32> { x: 5, y: 6 },
|
||||
vec![
|
||||
Token::EnumMapStart("GenericEnum", "Map", Some(2)),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("x"),
|
||||
Token::U32(5),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("y"),
|
||||
Token::U32(6),
|
||||
|
||||
Token::EnumMapEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_default_ty_param() {
|
||||
assert_tokens(
|
||||
&DefaultTyParam::<i32> { phantom: PhantomData },
|
||||
vec![
|
||||
Token::StructStart("DefaultTyParam", Some(1)),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("phantom"),
|
||||
Token::UnitStruct("PhantomData"),
|
||||
|
||||
Token::StructEnd,
|
||||
]
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,370 @@
|
||||
use std::collections::{BTreeMap, HashMap, HashSet};
|
||||
use std::net;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::str;
|
||||
|
||||
use token::{self, Token};
|
||||
|
||||
extern crate fnv;
|
||||
use self::fnv::FnvHasher;
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#[derive(Serialize)]
|
||||
struct UnitStruct;
|
||||
|
||||
#[derive(Serialize)]
|
||||
struct TupleStruct(i32, i32, i32);
|
||||
|
||||
#[derive(Serialize)]
|
||||
struct Struct {
|
||||
a: i32,
|
||||
b: i32,
|
||||
c: i32,
|
||||
}
|
||||
|
||||
#[derive(Serialize)]
|
||||
enum Enum {
|
||||
Unit,
|
||||
One(i32),
|
||||
Seq(i32, i32),
|
||||
Map { a: i32, b: i32 },
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
declare_ser_tests! {
|
||||
test_unit {
|
||||
() => &[Token::Unit],
|
||||
}
|
||||
test_bool {
|
||||
true => &[Token::Bool(true)],
|
||||
false => &[Token::Bool(false)],
|
||||
}
|
||||
test_isizes {
|
||||
0isize => &[Token::Isize(0)],
|
||||
0i8 => &[Token::I8(0)],
|
||||
0i16 => &[Token::I16(0)],
|
||||
0i32 => &[Token::I32(0)],
|
||||
0i64 => &[Token::I64(0)],
|
||||
}
|
||||
test_usizes {
|
||||
0usize => &[Token::Usize(0)],
|
||||
0u8 => &[Token::U8(0)],
|
||||
0u16 => &[Token::U16(0)],
|
||||
0u32 => &[Token::U32(0)],
|
||||
0u64 => &[Token::U64(0)],
|
||||
}
|
||||
test_floats {
|
||||
0f32 => &[Token::F32(0.)],
|
||||
0f64 => &[Token::F64(0.)],
|
||||
}
|
||||
test_char {
|
||||
'a' => &[Token::Char('a')],
|
||||
}
|
||||
test_str {
|
||||
"abc" => &[Token::Str("abc")],
|
||||
"abc".to_owned() => &[Token::Str("abc")],
|
||||
}
|
||||
test_option {
|
||||
None::<i32> => &[Token::Option(false)],
|
||||
Some(1) => &[
|
||||
Token::Option(true),
|
||||
Token::I32(1),
|
||||
],
|
||||
}
|
||||
test_result {
|
||||
Ok::<i32, i32>(0) => &[
|
||||
Token::EnumNewType("Result", "Ok"),
|
||||
Token::I32(0),
|
||||
],
|
||||
Err::<i32, i32>(1) => &[
|
||||
Token::EnumNewType("Result", "Err"),
|
||||
Token::I32(1),
|
||||
],
|
||||
}
|
||||
test_slice {
|
||||
&[0][..0] => &[
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
&[1, 2, 3][..] => &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_array {
|
||||
[0; 0] => &[
|
||||
Token::SeqArrayStart(0),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
[1, 2, 3] => &[
|
||||
Token::SeqArrayStart(3),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_vec {
|
||||
Vec::<isize>::new() => &[
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
vec![vec![], vec![1], vec![2, 3]] => &[
|
||||
Token::SeqStart(Some(3)),
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
|
||||
Token::SeqSep,
|
||||
Token::SeqStart(Some(2)),
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::SeqSep,
|
||||
Token::I32(3),
|
||||
Token::SeqEnd,
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_hashset {
|
||||
HashSet::<isize>::new() => &[
|
||||
Token::SeqStart(Some(0)),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
hashset![1] => &[
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
hashset![FnvHasher @ 1] => &[
|
||||
Token::SeqStart(Some(1)),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_tuple {
|
||||
(1,) => &[
|
||||
Token::TupleStart(1),
|
||||
Token::TupleSep,
|
||||
Token::I32(1),
|
||||
Token::TupleEnd,
|
||||
],
|
||||
(1, 2, 3) => &[
|
||||
Token::TupleStart(3),
|
||||
Token::TupleSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::TupleSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::TupleSep,
|
||||
Token::I32(3),
|
||||
Token::TupleEnd,
|
||||
],
|
||||
}
|
||||
test_btreemap {
|
||||
btreemap![1 => 2] => &[
|
||||
Token::MapStart(Some(1)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => 2, 3 => 4] => &[
|
||||
Token::MapStart(Some(2)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
Token::MapEnd,
|
||||
],
|
||||
btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => &[
|
||||
Token::MapStart(Some(2)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::MapStart(Some(0)),
|
||||
Token::MapEnd,
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(2),
|
||||
Token::MapStart(Some(2)),
|
||||
Token::MapSep,
|
||||
Token::I32(3),
|
||||
Token::I32(4),
|
||||
|
||||
Token::MapSep,
|
||||
Token::I32(5),
|
||||
Token::I32(6),
|
||||
Token::MapEnd,
|
||||
Token::MapEnd,
|
||||
],
|
||||
}
|
||||
test_hashmap {
|
||||
HashMap::<isize, isize>::new() => &[
|
||||
Token::MapStart(Some(0)),
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![1 => 2] => &[
|
||||
Token::MapStart(Some(1)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
hashmap![FnvHasher @ 1 => 2] => &[
|
||||
Token::MapStart(Some(1)),
|
||||
Token::MapSep,
|
||||
Token::I32(1),
|
||||
Token::I32(2),
|
||||
Token::MapEnd,
|
||||
],
|
||||
}
|
||||
test_unit_struct {
|
||||
UnitStruct => &[Token::UnitStruct("UnitStruct")],
|
||||
}
|
||||
test_tuple_struct {
|
||||
TupleStruct(1, 2, 3) => &[
|
||||
Token::TupleStructStart("TupleStruct", Some(3)),
|
||||
Token::TupleStructSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::TupleStructSep,
|
||||
Token::I32(2),
|
||||
|
||||
Token::TupleStructSep,
|
||||
Token::I32(3),
|
||||
Token::TupleStructEnd,
|
||||
],
|
||||
}
|
||||
test_struct {
|
||||
Struct { a: 1, b: 2, c: 3 } => &[
|
||||
Token::StructStart("Struct", Some(3)),
|
||||
Token::StructSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
|
||||
Token::StructSep,
|
||||
Token::Str("c"),
|
||||
Token::I32(3),
|
||||
Token::StructEnd,
|
||||
],
|
||||
}
|
||||
test_enum {
|
||||
Enum::Unit => &[Token::EnumUnit("Enum", "Unit")],
|
||||
Enum::One(42) => &[Token::EnumNewType("Enum", "One"), Token::I32(42)],
|
||||
Enum::Seq(1, 2) => &[
|
||||
Token::EnumSeqStart("Enum", "Seq", Some(2)),
|
||||
Token::EnumSeqSep,
|
||||
Token::I32(1),
|
||||
|
||||
Token::EnumSeqSep,
|
||||
Token::I32(2),
|
||||
Token::EnumSeqEnd,
|
||||
],
|
||||
Enum::Map { a: 1, b: 2 } => &[
|
||||
Token::EnumMapStart("Enum", "Map", Some(2)),
|
||||
Token::EnumMapSep,
|
||||
Token::Str("a"),
|
||||
Token::I32(1),
|
||||
|
||||
Token::EnumMapSep,
|
||||
Token::Str("b"),
|
||||
Token::I32(2),
|
||||
Token::EnumMapEnd,
|
||||
],
|
||||
}
|
||||
test_box {
|
||||
Box::new(0i32) => &[Token::I32(0)],
|
||||
}
|
||||
test_boxed_slice {
|
||||
Box::new([0, 1, 2]) => &[
|
||||
Token::SeqArrayStart(3),
|
||||
Token::SeqSep,
|
||||
Token::I32(0),
|
||||
Token::SeqSep,
|
||||
Token::I32(1),
|
||||
Token::SeqSep,
|
||||
Token::I32(2),
|
||||
Token::SeqEnd,
|
||||
],
|
||||
}
|
||||
test_net_ipv4addr {
|
||||
"1.2.3.4".parse::<net::Ipv4Addr>().unwrap() => &[Token::Str("1.2.3.4")],
|
||||
}
|
||||
test_net_ipv6addr {
|
||||
"::1".parse::<net::Ipv6Addr>().unwrap() => &[Token::Str("::1")],
|
||||
}
|
||||
test_net_socketaddr {
|
||||
"1.2.3.4:1234".parse::<net::SocketAddr>().unwrap() => &[Token::Str("1.2.3.4:1234")],
|
||||
"1.2.3.4:1234".parse::<net::SocketAddrV4>().unwrap() => &[Token::Str("1.2.3.4:1234")],
|
||||
"[::1]:1234".parse::<net::SocketAddrV6>().unwrap() => &[Token::Str("[::1]:1234")],
|
||||
}
|
||||
test_path {
|
||||
Path::new("/usr/local/lib") => &[
|
||||
Token::Str("/usr/local/lib"),
|
||||
],
|
||||
}
|
||||
test_path_buf {
|
||||
PathBuf::from("/usr/local/lib") => &[
|
||||
Token::Str("/usr/local/lib"),
|
||||
],
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "nightly")]
|
||||
#[test]
|
||||
fn test_net_ipaddr() {
|
||||
assert_ser_tokens(
|
||||
"1.2.3.4".parse::<net::IpAddr>().unwrap(),
|
||||
&[Token::Str("1.2.3.4")],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_cannot_serialize_paths() {
|
||||
let path = unsafe {
|
||||
str::from_utf8_unchecked(b"Hello \xF0\x90\x80World")
|
||||
};
|
||||
token::assert_ser_tokens_error(
|
||||
&Path::new(path),
|
||||
&[Token::Str("Hello �World")],
|
||||
token::Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
|
||||
|
||||
let mut path_buf = PathBuf::new();
|
||||
path_buf.push(path);
|
||||
|
||||
token::assert_ser_tokens_error(
|
||||
&path_buf,
|
||||
&[Token::Str("Hello �World")],
|
||||
token::Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user