Panic by default in serde_test is_human_readable

The serde_test Serializer and Deserializer panic in is_human_readable unless the
readableness has been set explicitly through one of the hidden functions. This
is to force types that have distinct readable/compact representations to be
tested explicitly in one or the other, rather than with a plain assert_tokens
which arbitrarily picks one.

We need to follow up by designing a better API in serde_test to expose this
publicly. For now serde_test cannot be used to test types that rely on
is_human_readable. (The hidden functions are meant for our test suite only.)

serde_test/src/assert.rs

@@ -47,7 +47,7 @@ pub fn assert_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
     T: Serialize + Deserialize<'de> + PartialEq + Debug,
 {
-    assert_tokens_readable(value, tokens, true);
+    assert_tokens_readable(value, tokens, None);
 }
 
 // Not public API
@@ -55,7 +55,7 @@ where
 /// 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)
+pub fn assert_tokens_readable<'de, T>(value: &T, tokens: &'de [Token], human_readable: Option<bool>)
 where
     T: Serialize + Deserialize<'de> + PartialEq + Debug,
 {
@@ -96,7 +96,7 @@ pub fn assert_ser_tokens<T>(value: &T, tokens: &[Token])
 where
     T: Serialize,
 {
-    assert_ser_tokens_readable(value, tokens, true)
+    assert_ser_tokens_readable(value, tokens, None)
 }
 
 // Not public API
@@ -104,7 +104,7 @@ where
 /// 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)
+pub fn assert_ser_tokens_readable<T>(value: &T, tokens: &[Token], human_readable: Option<bool>)
 where
     T: Serialize,
 {
@@ -207,12 +207,12 @@ pub fn assert_de_tokens<'de, T>(value: &T, tokens: &'de [Token])
 where
     T: Deserialize<'de> + PartialEq + Debug,
 {
-    assert_de_tokens_readable(value, tokens, true)
+    assert_de_tokens_readable(value, tokens, None)
 }
 
 // Not public API
 #[doc(hidden)]
-pub fn assert_de_tokens_readable<'de, T>(value: &T, tokens: &'de [Token], human_readable: bool)
+pub fn assert_de_tokens_readable<'de, T>(value: &T, tokens: &'de [Token], human_readable: Option<bool>)
 where
     T: Deserialize<'de> + PartialEq + Debug,
 {

serde_test/src/de.rs

@@ -16,7 +16,7 @@ use token::Token;
 #[derive(Debug)]
 pub struct Deserializer<'de> {
     tokens: &'de [Token],
-    is_human_readable: bool,
+    is_human_readable: Option<bool>,
 }
 
 macro_rules! assert_next_token {
@@ -49,12 +49,12 @@ macro_rules! end_of_tokens {
 
 impl<'de> Deserializer<'de> {
     pub fn new(tokens: &'de [Token]) -> Self {
-        Deserializer::readable(tokens, true)
+        Deserializer::readable(tokens, None)
     }
 
     // Not public API
     #[doc(hidden)]
-    pub fn readable(tokens: &'de [Token], is_human_readable: bool) -> Self {
+    pub fn readable(tokens: &'de [Token], is_human_readable: Option<bool>) -> Self {
         Deserializer { tokens: tokens, is_human_readable: is_human_readable }
     }
 
@@ -373,7 +373,15 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     }
 
     fn is_human_readable(&self) -> bool {
-        self.is_human_readable
+        match self.is_human_readable {
+            Some(is) => is,
+            None => {
+                panic!("There is no serde_test API currently for testing types \
+                        that have different human-readable and compact \
+                        representation. See \
+                        https://github.com/serde-rs/serde/issues/1065.");
+            }
+        }
     }
 }
 

serde_test/src/ser.rs

@@ -15,18 +15,18 @@ use token::Token;
 #[derive(Debug)]
 pub struct Serializer<'a> {
     tokens: &'a [Token],
-    is_human_readable: bool,
+    is_human_readable: Option<bool>,
 }
 
 impl<'a> Serializer<'a> {
     /// Creates the serializer.
     pub fn new(tokens: &'a [Token]) -> Self {
-        Serializer::readable(tokens, true)
+        Serializer::readable(tokens, None)
     }
 
     // Not public API
     #[doc(hidden)]
-    pub fn readable(tokens: &'a [Token], is_human_readable: bool) -> Self {
+    pub fn readable(tokens: &'a [Token], is_human_readable: Option<bool>) -> Self {
         Serializer { tokens: tokens, is_human_readable: is_human_readable }
     }
 
@@ -291,7 +291,15 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
     }
 
     fn is_human_readable(&self) -> bool {
-        self.is_human_readable
+        match self.is_human_readable {
+            Some(is) => is,
+            None => {
+                panic!("There is no serde_test API currently for testing types \
+                        that have different human-readable and compact \
+                        representation. See \
+                        https://github.com/serde-rs/serde/issues/1065.");
+            }
+        }
     }
 }