Merge #24

24: Roundtrip test r=kvark

r? @torkleyy

src/de.rs

@@ -242,9 +242,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             | sym(b'b').map(|_|b'\x08') | sym(b'f').map(|_|b'\x0C')
             | sym(b'n').map(|_|b'\n') | sym(b'r').map(|_|b'\r') | sym(b't').map(|_|b'\t');
         let escape_sequence = sym(b'\\') * special_char;
-        let char_string = (none_of(b"\\\"") | escape_sequence).repeat(1..).convert(String::from_utf8);
+        let char_string = (none_of(b"\\\"") | escape_sequence).repeat(0..).convert(String::from_utf8);
         let utf16_char = seq(b"\\u") * is_a(char_class::hex_digit).repeat(4).convert(String::from_utf8).convert(|digits|u16::from_str_radix(&digits, 16));
-        let utf16_string = utf16_char.repeat(1..).map(|chars| decode_utf16(chars).map(|r| r.unwrap_or(REPLACEMENT_CHARACTER)).collect::<String>());
+        let utf16_string = utf16_char.repeat(0..).map(|chars| decode_utf16(chars).map(|r| r.unwrap_or(REPLACEMENT_CHARACTER)).collect::<String>());
         let parser = sym(b'"') * (char_string | utf16_string) - sym(b'"');
 
         match parser.parse(&mut self.input) {

src/ser.rs

@@ -364,7 +364,10 @@ impl<'a> ser::SerializeMap for &'a mut Serializer {
         where T: ?Sized + Serialize
     {
         self.output += ":";
-        value.serialize(&mut **self)
+        value.serialize(&mut **self)?;
+        self.output += ",";
+
+        Ok(())
     }
 
     fn end(self) -> Result<()> {

tests/roundtrip.rs

@@ -0,0 +1,50 @@
+extern crate ron;
+#[macro_use]
+extern crate serde_derive;
+
+use std::collections::HashMap;
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct UnitStruct;
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct NewType(f32);
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct TupleStruct(UnitStruct, i8);
+
+#[derive(Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+struct Key(u32);
+
+#[derive(Debug, PartialEq, Eq, Hash, Deserialize, Serialize)]
+enum Enum {
+    Unit,
+    Bool(bool),
+    Chars(char, String),
+}
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct Struct {
+    tuple: ((), NewType, TupleStruct),
+    vec: Vec<Option<UnitStruct>>,
+    map: HashMap<Key, Enum>,
+}
+
+#[test]
+fn roundtrip() {
+    let value = Struct {
+        tuple: ((), NewType(0.5), TupleStruct(UnitStruct, -5)),
+        vec: vec![None, Some(UnitStruct)],
+        map: vec![
+            (Key(5), Enum::Unit),
+            (Key(6), Enum::Bool(false)),
+            (Key(7), Enum::Bool(true)),
+            (Key(9), Enum::Chars('x', "".to_string())),
+        ].into_iter().collect()
+    };
+
+    let serial = ron::ser::to_string(&value).unwrap();
+    let deserial = ron::de::from_str(&serial);
+
+    assert_eq!(Ok(value), deserial);
+}