From 4b2e012e0ac6bd86a431b9bf1e7464ff63977ac1 Mon Sep 17 00:00:00 2001 From: Hennadii Chernyshchyk Date: Wed, 23 Nov 2022 02:15:27 +0200 Subject: [PATCH 1/4] Add assert_de_tokens_seed --- serde_test/src/assert.rs | 40 ++++++++++++++++++++++++++++++++++++++++ serde_test/src/lib.rs | 4 ++-- 2 files changed, 42 insertions(+), 2 deletions(-) diff --git a/serde_test/src/assert.rs b/serde_test/src/assert.rs index 9be153d74..1113a0dd1 100644 --- a/serde_test/src/assert.rs +++ b/serde_test/src/assert.rs @@ -1,3 +1,4 @@ +use serde::de::DeserializeSeed; use serde::{Deserialize, Serialize}; use de::Deserializer; @@ -221,3 +222,42 @@ where panic!("{} remaining tokens", de.remaining()); } } + +/// Same as [`assert_de_tokens`], but for [`DeserializeSeed`]. +#[cfg_attr(not(no_track_caller), track_caller)] +pub fn assert_de_seed_tokens<'de, T, D>(value: &T, tokens: &'de [Token], seed: D) +where + T: PartialEq + Debug, + D: DeserializeSeed<'de, Value = T>, +{ + let mut de = Deserializer::new(tokens); + match seed.deserialize(&mut de) { + Ok(v) => assert_eq!(v, *value), + Err(e) => panic!("tokens failed to deserialize: {}", e), + }; + + if de.remaining() > 0 { + panic!("{} remaining tokens", de.remaining()); + } +} + +/// Same as [`assert_de_tokens_error`], but for [`DeserializeSeed`]. +#[cfg_attr(not(no_track_caller), track_caller)] +pub fn assert_de_seed_tokens_error<'de, T, D>(tokens: &'de [Token], seed: D, error: &str) +where + T: PartialEq + Debug, + D: DeserializeSeed<'de, Value = T>, +{ + let mut de = Deserializer::new(tokens); + match seed.deserialize(&mut de) { + Ok(_) => panic!("tokens deserialized successfully"), + Err(e) => assert_eq!(e, *error), + }; + + // There may be one token left if a peek caused the error + de.next_token_opt(); + + if de.remaining() > 0 { + panic!("{} remaining tokens", de.remaining()); + } +} diff --git a/serde_test/src/lib.rs b/serde_test/src/lib.rs index 02f0d1f1d..8e0fd18fd 100644 --- a/serde_test/src/lib.rs +++ b/serde_test/src/lib.rs @@ -180,8 +180,8 @@ mod configure; mod token; pub use assert::{ - assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, assert_ser_tokens_error, - assert_tokens, + assert_de_seed_tokens, assert_de_seed_tokens_error, assert_de_tokens, assert_de_tokens_error, + assert_ser_tokens, assert_ser_tokens_error, assert_tokens, }; pub use token::Token; From 725375099bedeac6c42217aef73919e4bfbaad24 Mon Sep 17 00:00:00 2001 From: Hennadii Chernyshchyk Date: Sun, 11 Dec 2022 14:16:34 +0200 Subject: [PATCH 2/4] Add examples for assert_de_seed_* --- serde_test/src/assert.rs | 77 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) diff --git a/serde_test/src/assert.rs b/serde_test/src/assert.rs index 1113a0dd1..160a47e31 100644 --- a/serde_test/src/assert.rs +++ b/serde_test/src/assert.rs @@ -224,6 +224,43 @@ where } /// Same as [`assert_de_tokens`], but for [`DeserializeSeed`]. +/// +/// ```edition2018 +/// # use serde::{de::{DeserializeSeed, Visitor}, Deserializer}; +/// # use serde_test::{assert_de_seed_tokens, Token}; +/// +/// #[derive(Debug, PartialEq)] +/// struct Example { +/// a: u8, +/// b: u8, +/// } +/// +/// struct ExampleDeserializer(u8); +/// +/// impl<'de> DeserializeSeed<'de> for ExampleDeserializer { +/// type Value = Example; +/// +/// fn deserialize>(self, deserializer: D) -> Result { +/// deserializer.deserialize_u8(self) +/// } +/// } +/// +/// impl<'de> Visitor<'de> for ExampleDeserializer { +/// type Value = Example; +/// +/// fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result { +/// formatter.write_str("Example") +/// } +/// +/// fn visit_u8(self, v: u8) -> Result { +/// Ok(Self::Value { a: v, b: self.0 }) +/// } +/// } +/// +/// let example = Example { b: 0, a: 0 }; +/// let seed = ExampleDeserializer(0); +/// assert_de_seed_tokens(&example, &[Token::U8(0)], seed); +/// ``` #[cfg_attr(not(no_track_caller), track_caller)] pub fn assert_de_seed_tokens<'de, T, D>(value: &T, tokens: &'de [Token], seed: D) where @@ -242,6 +279,46 @@ where } /// Same as [`assert_de_tokens_error`], but for [`DeserializeSeed`]. +/// +/// ```edition2018 +/// # use serde::{de::{DeserializeSeed, Visitor}, Deserializer}; +/// # use serde_test::{assert_de_seed_tokens_error, Token}; +/// +/// #[derive(Debug, PartialEq)] +/// struct Example { +/// a: u8, +/// b: u8, +/// } +/// +/// struct ExampleDeserializer(u8); +/// +/// impl<'de> DeserializeSeed<'de> for ExampleDeserializer { +/// type Value = Example; +/// +/// fn deserialize>(self, deserializer: D) -> Result { +/// deserializer.deserialize_u8(self) +/// } +/// } +/// +/// impl<'de> Visitor<'de> for ExampleDeserializer { +/// type Value = Example; +/// +/// fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result { +/// formatter.write_str("Example") +/// } +/// +/// fn visit_u8(self, v: u8) -> Result { +/// Ok(Self::Value { a: v, b: self.0 }) +/// } +/// } +/// +/// let seed = ExampleDeserializer(0); +/// assert_de_seed_tokens_error( +/// &[Token::I8(0)], +/// seed, +/// "invalid type: integer `0`, expected Example" +/// ); +/// ``` #[cfg_attr(not(no_track_caller), track_caller)] pub fn assert_de_seed_tokens_error<'de, T, D>(tokens: &'de [Token], seed: D, error: &str) where From 09be8c12b64fb263605afa50d3337e2cf0f7a305 Mon Sep 17 00:00:00 2001 From: Hennadii Chernyshchyk Date: Sun, 11 Dec 2022 14:24:57 +0200 Subject: [PATCH 3/4] Pass seed first --- serde_test/src/assert.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/serde_test/src/assert.rs b/serde_test/src/assert.rs index 160a47e31..201e03e7e 100644 --- a/serde_test/src/assert.rs +++ b/serde_test/src/assert.rs @@ -259,10 +259,10 @@ where /// /// let example = Example { b: 0, a: 0 }; /// let seed = ExampleDeserializer(0); -/// assert_de_seed_tokens(&example, &[Token::U8(0)], seed); +/// assert_de_seed_tokens(&example, seed, &[Token::U8(0)]); /// ``` #[cfg_attr(not(no_track_caller), track_caller)] -pub fn assert_de_seed_tokens<'de, T, D>(value: &T, tokens: &'de [Token], seed: D) +pub fn assert_de_seed_tokens<'de, T, D>(value: &T, seed: D, tokens: &'de [Token]) where T: PartialEq + Debug, D: DeserializeSeed<'de, Value = T>, @@ -314,13 +314,13 @@ where /// /// let seed = ExampleDeserializer(0); /// assert_de_seed_tokens_error( -/// &[Token::I8(0)], /// seed, +/// &[Token::I8(0)], /// "invalid type: integer `0`, expected Example" /// ); /// ``` #[cfg_attr(not(no_track_caller), track_caller)] -pub fn assert_de_seed_tokens_error<'de, T, D>(tokens: &'de [Token], seed: D, error: &str) +pub fn assert_de_seed_tokens_error<'de, T, D>(seed: D, tokens: &'de [Token], error: &str) where T: PartialEq + Debug, D: DeserializeSeed<'de, Value = T>, From 1a58dda9fe303a5507edcba10c0d88793db61fdc Mon Sep 17 00:00:00 2001 From: Hennadii Chernyshchyk Date: Sun, 11 Dec 2022 14:25:15 +0200 Subject: [PATCH 4/4] Apply formatting --- serde_test/src/assert.rs | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/serde_test/src/assert.rs b/serde_test/src/assert.rs index 201e03e7e..1d8ee6384 100644 --- a/serde_test/src/assert.rs +++ b/serde_test/src/assert.rs @@ -228,30 +228,30 @@ where /// ```edition2018 /// # use serde::{de::{DeserializeSeed, Visitor}, Deserializer}; /// # use serde_test::{assert_de_seed_tokens, Token}; -/// +/// /// #[derive(Debug, PartialEq)] /// struct Example { /// a: u8, /// b: u8, /// } -/// +/// /// struct ExampleDeserializer(u8); -/// +/// /// impl<'de> DeserializeSeed<'de> for ExampleDeserializer { /// type Value = Example; -/// +/// /// fn deserialize>(self, deserializer: D) -> Result { /// deserializer.deserialize_u8(self) /// } /// } -/// +/// /// impl<'de> Visitor<'de> for ExampleDeserializer { /// type Value = Example; -/// +/// /// fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result { /// formatter.write_str("Example") /// } -/// +/// /// fn visit_u8(self, v: u8) -> Result { /// Ok(Self::Value { a: v, b: self.0 }) /// } @@ -283,30 +283,30 @@ where /// ```edition2018 /// # use serde::{de::{DeserializeSeed, Visitor}, Deserializer}; /// # use serde_test::{assert_de_seed_tokens_error, Token}; -/// +/// /// #[derive(Debug, PartialEq)] /// struct Example { /// a: u8, /// b: u8, /// } -/// +/// /// struct ExampleDeserializer(u8); -/// +/// /// impl<'de> DeserializeSeed<'de> for ExampleDeserializer { /// type Value = Example; -/// +/// /// fn deserialize>(self, deserializer: D) -> Result { /// deserializer.deserialize_u8(self) /// } /// } -/// +/// /// impl<'de> Visitor<'de> for ExampleDeserializer { /// type Value = Example; -/// +/// /// fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result { /// formatter.write_str("Example") /// } -/// +/// /// fn visit_u8(self, v: u8) -> Result { /// Ok(Self::Value { a: v, b: self.0 }) /// }