Merge pull request #1044 from Marwes/human_readable

Serialize to binary if the serde format is not human readable

serde_test/src/assert.rs

@@ -47,8 +47,20 @@ pub fn assert_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
     T: Serialize + Deserialize<'de> + PartialEq + Debug,
 {
-    assert_ser_tokens(value, tokens);
-    assert_de_tokens(value, tokens);
+    assert_tokens_readable(value, tokens, true);
+}
+
+// Not public API
+#[doc(hidden)]
+/// Runs both `assert_ser_tokens` and `assert_de_tokens`.
+///
+/// See: `assert_tokens`
+pub fn assert_tokens_readable<'de, T>(value: &T, tokens: &'de [Token], human_readable: bool)
+where
+    T: Serialize + Deserialize<'de> + PartialEq + Debug,
+{
+    assert_ser_tokens_readable(value, tokens, human_readable);
+    assert_de_tokens_readable(value, tokens, human_readable);
 }
 
 /// Asserts that `value` serializes to the given `tokens`.
@@ -84,7 +96,19 @@ pub fn assert_ser_tokens<T>(value: &T, tokens: &[Token])
 where
     T: Serialize,
 {
-    let mut ser = Serializer::new(tokens);
+    assert_ser_tokens_readable(value, tokens, true)
+}
+
+// Not public API
+#[doc(hidden)]
+/// Asserts that `value` serializes to the given `tokens`.
+///
+/// See: `assert_ser_tokens`
+pub fn assert_ser_tokens_readable<T>(value: &T, tokens: &[Token], human_readable: bool)
+where
+    T: Serialize,
+{
+    let mut ser = Serializer::readable(tokens, human_readable);
     match value.serialize(&mut ser) {
         Ok(_) => {}
         Err(err) => panic!("value failed to serialize: {}", err),
@@ -183,7 +207,16 @@ pub fn assert_de_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
     T: Deserialize<'de> + PartialEq + Debug,
 {
-    let mut de = Deserializer::new(tokens);
+    assert_de_tokens_readable(value, tokens, true)
+}
+
+// Not public API
+#[doc(hidden)]
+pub fn assert_de_tokens_readable<'de, T>(value: &T, tokens: &'de [Token], human_readable: bool)
+where
+    T: Deserialize<'de> + PartialEq + Debug,
+{
+    let mut de = Deserializer::readable(tokens, human_readable);
     match T::deserialize(&mut de) {
         Ok(v) => assert_eq!(v, *value),
         Err(e) => panic!("tokens failed to deserialize: {}", e),

serde_test/src/de.rs

@@ -16,6 +16,7 @@ use token::Token;
 #[derive(Debug)]
 pub struct Deserializer<'de> {
     tokens: &'de [Token],
+    is_human_readable: bool,
 }
 
 macro_rules! assert_next_token {
@@ -48,7 +49,13 @@ macro_rules! end_of_tokens {
 
 impl<'de> Deserializer<'de> {
     pub fn new(tokens: &'de [Token]) -> Self {
-        Deserializer { tokens: tokens }
+        Deserializer::readable(tokens, true)
+    }
+
+    // Not public API
+    #[doc(hidden)]
+    pub fn readable(tokens: &'de [Token], is_human_readable: bool) -> Self {
+        Deserializer { tokens: tokens, is_human_readable: is_human_readable }
     }
 
     fn peek_token_opt(&self) -> Option<Token> {
@@ -364,6 +371,10 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             _ => self.deserialize_any(visitor),
         }
     }
+
+    fn is_human_readable(&self) -> bool {
+        self.is_human_readable
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////

serde_test/src/lib.rs

@@ -168,8 +168,12 @@ mod token;
 mod assert;
 
 pub use token::Token;
-pub use assert::{assert_tokens, assert_ser_tokens, assert_ser_tokens_error, assert_de_tokens,
-                 assert_de_tokens_error};
+pub use assert::{assert_tokens, assert_ser_tokens, assert_ser_tokens_error,
+                 assert_de_tokens, assert_de_tokens_error};
+
+// Not public API.
+#[doc(hidden)]
+pub use assert::{assert_tokens_readable, assert_de_tokens_readable, assert_ser_tokens_readable};
 
 // Not public API.
 #[doc(hidden)]

serde_test/src/ser.rs

@@ -15,12 +15,19 @@ use token::Token;
 #[derive(Debug)]
 pub struct Serializer<'a> {
     tokens: &'a [Token],
+    is_human_readable: bool,
 }
 
 impl<'a> Serializer<'a> {
     /// Creates the serializer.
     pub fn new(tokens: &'a [Token]) -> Self {
-        Serializer { tokens: tokens }
+        Serializer::readable(tokens, true)
+    }
+
+    // Not public API
+    #[doc(hidden)]
+    pub fn readable(tokens: &'a [Token], is_human_readable: bool) -> Self {
+        Serializer { tokens: tokens, is_human_readable: is_human_readable }
     }
 
     /// Pulls the next token off of the serializer, ignoring it.
@@ -282,6 +289,10 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
             Ok(Variant { ser: self, end: Token::StructVariantEnd })
         }
     }
+
+    fn is_human_readable(&self) -> bool {
+        self.is_human_readable
+    }
 }
 
 pub struct Variant<'s, 'a: 's> {