Merge pull request #111 from oli-obk/master

tuple enums with single element should not be a json-array

serde_tests/tests/test_bytes.rs

@@ -39,6 +39,15 @@ impl serde::Serializer for BytesSerializer {
         Err(Error)
     }
 
+    fn visit_enum_simple<T>(&mut self,
+                            _name: &str,
+                            _variant: &str,
+                            _value: T,
+                            ) -> Result<(), Error>
+    {
+        Err(Error)
+    }
+
     fn visit_bool(&mut self, _v: bool) -> Result<(), Error> {
         Err(Error)
     }

serde_tests/tests/test_json.rs

@@ -28,7 +28,7 @@ enum Animal {
     Dog,
     Frog(String, Vec<isize>),
     Cat { age: usize, name: String },
-
+    AntHive(Vec<String>),
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -534,6 +534,10 @@ fn test_write_enum() {
             Animal::Cat { age: 5, name: "Kate".to_string() },
             "{\"Cat\":{\"age\":5,\"name\":\"Kate\"}}"
         ),
+        (
+            Animal::AntHive(vec!["Bob".to_string(), "Stuart".to_string()]),
+            "{\"AntHive\":[\"Bob\",\"Stuart\"]}",
+        ),
     ]);
 
     test_pretty_encode_ok(&[
@@ -976,6 +980,10 @@ fn test_parse_enum() {
             " { \"Cat\" : { \"age\" : 5 , \"name\" : \"Kate\" } } ",
             Animal::Cat { age: 5, name: "Kate".to_string() },
         ),
+        (
+            " { \"AntHive\" : [\"Bob\", \"Stuart\"] } ",
+            Animal::AntHive(vec!["Bob".to_string(), "Stuart".to_string()]),
+        ),
     ]);
 
     test_parse_ok(vec![

serde_tests/tests/test_macros.rs

@@ -473,13 +473,13 @@ fn test_lifetimes() {
     let lifetime = Lifetimes::LifetimeSeq(&value);
     assert_eq!(
         serde_json::to_string(&lifetime).unwrap(),
-        "{\"LifetimeSeq\":[5]}"
+        "{\"LifetimeSeq\":5}"
     );
 
     let lifetime = Lifetimes::NoLifetimeSeq(5);
     assert_eq!(
         serde_json::to_string(&lifetime).unwrap(),
-        "{\"NoLifetimeSeq\":[5]}"
+        "{\"NoLifetimeSeq\":5}"
     );
 
     let value = 5;
@@ -515,8 +515,8 @@ fn test_generic() {
     declare_tests!(
         GenericStruct<u32> : GenericStruct { x: 5 } => "{\"x\":5}",
         GenericTupleStruct<u32> : GenericTupleStruct(5) => "[5]",
-        GenericEnumSeq<u32, u32> : GenericEnumSeq::Ok(5) => "{\"Ok\":[5]}",
-        GenericEnumSeq<u32, u32> : GenericEnumSeq::Err(5) => "{\"Err\":[5]}",
+        GenericEnumSeq<u32, u32> : GenericEnumSeq::Ok(5) => "{\"Ok\":5}",
+        GenericEnumSeq<u32, u32> : GenericEnumSeq::Err(5) => "{\"Err\":5}",
         GenericEnumMap<u32, u32> : GenericEnumMap::Ok { x: 5 } => "{\"Ok\":{\"x\":5}}",
         GenericEnumMap<u32, u32> : GenericEnumMap::Err { x: 5 } => "{\"Err\":{\"x\":5}}",
     );

serde_tests/tests/test_ser.rs

@@ -27,6 +27,8 @@ pub enum Token<'a> {
     UnitStruct(&'a str),
     EnumUnit(&'a str, &'a str),
 
+    EnumSimple(&'a str, &'a str),
+
     SeqStart(Option<usize>),
     TupleStructStart(&'a str, Option<usize>),
     EnumSeqStart(&'a str, &'a str, Option<usize>),
@@ -80,6 +82,17 @@ impl<'a> Serializer for AssertSerializer<'a> {
         Ok(())
     }
 
+    fn visit_enum_simple<T>(&mut self,
+                            name: &str,
+                            variant: &str,
+                            value: T,
+                            ) -> Result<(), ()>
+        where T: Serialize,
+    {
+        assert_eq!(self.iter.next(), Some(Token::EnumSimple(name, variant)));
+        value.serialize(self)
+    }
+
     fn visit_unit_struct(&mut self, name: &str) -> Result<(), ()> {
         assert_eq!(self.iter.next().unwrap(), Token::UnitStruct(name));
         Ok(())
@@ -301,6 +314,7 @@ struct Struct {
 #[derive(Serialize)]
 enum Enum {
     Unit,
+    One(i32),
     Seq(i32, i32),
     Map { a: i32, b: i32 },
 }
@@ -554,6 +568,7 @@ declare_tests! {
     }
     test_enum {
         Enum::Unit => vec![Token::EnumUnit("Enum", "Unit")],
+        Enum::One(42) => vec![Token::EnumSimple("Enum", "One"), Token::I32(42)],
         Enum::Seq(1, 2) => vec![
             Token::EnumSeqStart("Enum", "Seq", Some(2)),
                 Token::SeqSep,