Add asserts for DeserializeSeed

serde_test/src/assert.rs

@@ -1,3 +1,4 @@
+use serde::de::DeserializeSeed;
 use serde::{Deserialize, Serialize};
 
 use de::Deserializer;
@@ -221,3 +222,119 @@ where
  panic!("{} remaining tokens", de.remaining());
  }
 }
+
+/// 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<D: Deserializer<'de>>(self, deserializer: D) -> Result<Self::Value, D::Error> {
+/// 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<E>(self, v: u8) -> Result<Self::Value, E> {
+/// Ok(Self::Value { a: v, b: self.0 })
+/// }
+/// }
+///
+/// let example = Example { b: 0, a: 0 };
+/// let seed = ExampleDeserializer(0);
+/// 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, seed: D, tokens: &'de [Token])
+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`].
+///
+/// ```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<D: Deserializer<'de>>(self, deserializer: D) -> Result<Self::Value, D::Error> {
+/// 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<E>(self, v: u8) -> Result<Self::Value, E> {
+/// Ok(Self::Value { a: v, b: self.0 })
+/// }
+/// }
+///
+/// let seed = ExampleDeserializer(0);
+/// assert_de_seed_tokens_error(
+/// 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>(seed: D, tokens: &'de [Token], 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());
+ }
+}

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;