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

Merge pull request #1084 from Marwes/serde_test_readable_

Browse Source 
Add an API for making tests for readable/compact representations
This commit is contained in:
David Tolnay
2017-11-06 22:05:29 -08:00
committed by GitHub
parent b24ad76880 aad7a7987f
commit f6ac232580
10 changed files with 749 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test_suite/tests/test_de.rs
+15 -19
View File
@@ -29,7 +29,7 @@ extern crate fnv;
use self::fnv::FnvHasher;
extern crate serde_test;
use self::serde_test::{Token, assert_de_tokens, assert_de_tokens_error, assert_de_tokens_readable};
use self::serde_test::{assert_de_tokens, assert_de_tokens_error, Configure, Token};
#[macro_use]
mod macros;
@@ -49,16 +49,14 @@ struct TupleStruct(i32, i32, i32);
struct Struct {
a: i32,
b: i32,
#[serde(skip_deserializing)]
c: i32,
#[serde(skip_deserializing)] c: i32,
}
#[derive(PartialEq, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
struct StructDenyUnknown {
a: i32,
#[serde(skip_deserializing)]
b: i32,
#[serde(skip_deserializing)] b: i32,
}
#[derive(PartialEq, Debug, Deserialize)]
@@ -79,15 +77,13 @@ impl Default for StructDefault<String> {
#[derive(PartialEq, Debug, Deserialize)]
struct StructSkipAll {
#[serde(skip_deserializing)]
a: i32,
#[serde(skip_deserializing)] a: i32,
}
#[derive(PartialEq, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
struct StructSkipAllDenyUnknown {
#[serde(skip_deserializing)]
a: i32,
#[serde(skip_deserializing)] a: i32,
}
#[derive(PartialEq, Debug, Deserialize)]
@@ -112,7 +108,7 @@ enum EnumSkipAll {
macro_rules! declare_tests {
(
readable: $readable:tt
$readable:tt
$($name:ident { $($value:expr => $tokens:expr,)+ })+
) => {
$(
@@ -120,7 +116,7 @@ macro_rules! declare_tests {
fn $name() {
$(
// Test ser/de roundtripping
assert_de_tokens_readable(&$value, $tokens, Some($readable));
assert_de_tokens(&$value.$readable(), $tokens);
// Test that the tokens are ignorable
assert_de_tokens_ignore($tokens);
@@ -168,13 +164,11 @@ fn assert_de_tokens_ignore(ignorable_tokens: &[Token]) {
Token::Map { len: Some(2) },
Token::Str("a"),
Token::I32(1),
Token::Str("ignored"),
]
.into_iter()
.chain(ignorable_tokens.to_vec().into_iter())
.chain(vec![Token::MapEnd].into_iter())
.collect();
].into_iter()
.chain(ignorable_tokens.to_vec().into_iter())
.chain(vec![Token::MapEnd].into_iter())
.collect();
let mut de = serde_test::Deserializer::new(&concated_tokens);
let base = IgnoreBase::deserialize(&mut de).unwrap();
@@ -774,7 +768,8 @@ declare_tests! {
}
declare_tests! {
readable: true
readable
test_net_ipv4addr_readable {
"1.2.3.4".parse::<net::Ipv4Addr>().unwrap() => &[Token::Str("1.2.3.4")],
}
@@ -792,7 +787,8 @@ declare_tests! {
}
declare_tests! {
readable: false
compact
test_net_ipv4addr_compact {
net::Ipv4Addr::from(*b"1234") => &seq![
Token::Tuple { len: 4 },
test_suite/tests/test_identifier.rs
+2 -5
View File
@@ -9,10 +9,8 @@
#[macro_use]
extern crate serde_derive;
extern crate serde;
extern crate serde_test;
use serde_test::{Token, assert_de_tokens};
use serde_test::{assert_de_tokens, Token};
#[test]
fn test_variant_identifier() {
@@ -51,8 +49,7 @@ fn test_unit_fallthrough() {
enum F {
Aaa,
Bbb,
#[serde(other)]
Other,
#[serde(other)] Other,
}
assert_de_tokens(&F::Other, &[Token::Str("x")]);
test_suite/tests/test_remote.rs
+19 -45
View File
@@ -9,8 +9,6 @@
#[macro_use]
extern crate serde_derive;
extern crate serde;
mod remote {
pub struct Unit;
@@ -87,32 +85,23 @@ mod remote {
#[derive(Serialize, Deserialize)]
struct Test {
#[serde(with = "UnitDef")]
unit: remote::Unit,
#[serde(with = "UnitDef")] unit: remote::Unit,
#[serde(with = "PrimitivePrivDef")]
primitive_priv: remote::PrimitivePriv,
#[serde(with = "PrimitivePrivDef")] primitive_priv: remote::PrimitivePriv,
#[serde(with = "PrimitivePubDef")]
primitive_pub: remote::PrimitivePub,
#[serde(with = "PrimitivePubDef")] primitive_pub: remote::PrimitivePub,
#[serde(with = "NewtypePrivDef")]
newtype_priv: remote::NewtypePriv,
#[serde(with = "NewtypePrivDef")] newtype_priv: remote::NewtypePriv,
#[serde(with = "NewtypePubDef")]
newtype_pub: remote::NewtypePub,
#[serde(with = "NewtypePubDef")] newtype_pub: remote::NewtypePub,
#[serde(with = "TuplePrivDef")]
tuple_priv: remote::TuplePriv,
#[serde(with = "TuplePrivDef")] tuple_priv: remote::TuplePriv,
#[serde(with = "TuplePubDef")]
tuple_pub: remote::TuplePub,
#[serde(with = "TuplePubDef")] tuple_pub: remote::TuplePub,
#[serde(with = "StructPrivDef")]
struct_priv: remote::StructPriv,
#[serde(with = "StructPrivDef")] struct_priv: remote::StructPriv,
#[serde(with = "StructPubDef")]
struct_pub: remote::StructPub,
#[serde(with = "StructPubDef")] struct_pub: remote::StructPub,
}
#[derive(Serialize, Deserialize)]
@@ -121,10 +110,7 @@ struct UnitDef;
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::PrimitivePriv")]
struct PrimitivePrivDef(
#[serde(getter = "remote::PrimitivePriv::get")]
u8
);
struct PrimitivePrivDef(#[serde(getter = "remote::PrimitivePriv::get")] u8);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::PrimitivePub")]
@@ -133,53 +119,41 @@ struct PrimitivePubDef(u8);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::NewtypePriv")]
struct NewtypePrivDef(
#[serde(getter = "remote::NewtypePriv::get", with = "UnitDef")]
remote::Unit
#[serde(getter = "remote::NewtypePriv::get", with = "UnitDef")] remote::Unit,
);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::NewtypePub")]
struct NewtypePubDef(
#[serde(with = "UnitDef")]
remote::Unit
);
struct NewtypePubDef(#[serde(with = "UnitDef")] remote::Unit);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::TuplePriv")]
struct TuplePrivDef(
#[serde(getter = "remote::TuplePriv::first")]
u8,
#[serde(getter = "remote::TuplePriv::second", with = "UnitDef")]
remote::Unit
#[serde(getter = "remote::TuplePriv::first")] u8,
#[serde(getter = "remote::TuplePriv::second", with = "UnitDef")] remote::Unit,
);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::TuplePub")]
struct TuplePubDef(
u8,
#[serde(with = "UnitDef")]
remote::Unit
);
struct TuplePubDef(u8, #[serde(with = "UnitDef")] remote::Unit);
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::StructPriv")]
struct StructPrivDef {
#[serde(getter = "remote::StructPriv::a")]
a: u8,
#[serde(getter = "remote::StructPriv::a")] a: u8,
#[serde(getter = "remote::StructPriv::b")]
#[serde(with= "UnitDef")]
#[serde(with = "UnitDef")]
b: remote::Unit,
}
#[derive(Serialize, Deserialize)]
#[serde(remote = "remote::StructPub")]
struct StructPubDef {
#[allow(dead_code)]
a: u8,
#[allow(dead_code)] a: u8,
#[allow(dead_code)]
#[serde(with= "UnitDef")]
#[serde(with = "UnitDef")]
b: remote::Unit,
}
test_suite/tests/test_roundtrip.rs
+5 -9
View File
@@ -7,7 +7,7 @@
// except according to those terms.
extern crate serde_test;
use self::serde_test::{Token, assert_tokens_readable};
use self::serde_test::{assert_tokens, Configure, Token};
use std::net;
@@ -17,9 +17,8 @@ mod macros;
#[test]
fn ip_addr_roundtrip() {
assert_tokens_readable(
&net::IpAddr::from(*b"1234"),
assert_tokens(
&net::IpAddr::from(*b"1234").compact(),
&seq![
Token::NewtypeVariant { name: "IpAddr", variant: "V4" },
@@ -27,15 +26,13 @@ fn ip_addr_roundtrip() {
seq b"1234".iter().map(|&b| Token::U8(b)),
Token::TupleEnd,
],
Some(false),
);
}
#[test]
fn socked_addr_roundtrip() {
assert_tokens_readable(
&net::SocketAddr::from((*b"1234567890123456", 1234)),
assert_tokens(
&net::SocketAddr::from((*b"1234567890123456", 1234)).compact(),
&seq![
Token::NewtypeVariant { name: "SocketAddr", variant: "V6" },
@@ -48,6 +45,5 @@ fn socked_addr_roundtrip() {
Token::U16(1234),
Token::TupleEnd,
],
Some(false),
);
}
test_suite/tests/test_ser.rs
+12 -21
View File
@@ -21,11 +21,8 @@ use std::num::Wrapping;
#[cfg(unix)]
use std::str;
extern crate serde;
extern crate serde_test;
use self::serde_test::{Token, assert_ser_tokens, assert_ser_tokens_error,
assert_ser_tokens_readable};
use self::serde_test::{assert_ser_tokens, assert_ser_tokens_error, Configure, Token};
extern crate fnv;
use self::fnv::FnvHasher;
@@ -54,28 +51,24 @@ enum Enum {
One(i32),
Seq(i32, i32),
Map { a: i32, b: i32 },
#[serde(skip_serializing)]
SkippedUnit,
#[serde(skip_serializing)]
SkippedOne(i32),
#[serde(skip_serializing)]
SkippedSeq(i32, i32),
#[serde(skip_serializing)]
SkippedMap { _a: i32, _b: i32 },
#[serde(skip_serializing)] SkippedUnit,
#[serde(skip_serializing)] SkippedOne(i32),
#[serde(skip_serializing)] SkippedSeq(i32, i32),
#[serde(skip_serializing)] SkippedMap { _a: i32, _b: i32 },
}
//////////////////////////////////////////////////////////////////////////
macro_rules! declare_tests {
(
readable: $readable:tt
$readable:tt
$($name:ident { $($value:expr => $tokens:expr,)+ })+
) => {
$(
#[test]
fn $name() {
$(
assert_ser_tokens_readable(&$value, $tokens, Some($readable));
assert_ser_tokens(&$value.$readable(), $tokens);
)+
}
)+
@@ -408,7 +401,8 @@ declare_tests! {
}
declare_tests! {
readable: true
readable
test_net_ipv4addr_readable {
"1.2.3.4".parse::<net::Ipv4Addr>().unwrap() => &[Token::Str("1.2.3.4")],
}
@@ -426,7 +420,8 @@ declare_tests! {
}
declare_tests! {
readable: false
compact
test_net_ipv4addr_compact {
net::Ipv4Addr::from(*b"1234") => &seq![
Token::Tuple { len: 4 },
@@ -524,11 +519,7 @@ fn test_cannot_serialize_paths() {
let mut path_buf = PathBuf::new();
path_buf.push(path);
assert_ser_tokens_error(
&path_buf,
&[],
"path contains invalid UTF-8 characters",
);
assert_ser_tokens_error(&path_buf, &[], "path contains invalid UTF-8 characters");
}
#[test]