start to restructure unit tests

yaserde/src/lib.rs

@@ -137,3 +137,76 @@ fn default_visitor() {
   test_type!(visit_u64, "Unexpected u64 \"\"");
   test_type!(visit_str, "Unexpected str \"\"");
 }
+
+#[doc(hidden)]
+mod testing {
+  #[macro_export]
+  macro_rules! test_for_type {
+    ($type:ty, $value:expr, $content:expr) => {{
+      #[derive(Debug, PartialEq, YaDeserialize, YaSerialize)]
+      #[yaserde(root = "data")]
+      pub struct Data {
+        item: $type,
+      }
+
+      let model = Data { item: $value };
+
+      let content = if let Some(str_value) = $content {
+        String::from("<data><item>") + str_value + "</item></data>"
+      } else {
+        String::from("<data />")
+      };
+
+      serialize_and_validate!(model, content);
+      deserialize_and_validate!(&content, model, Data);
+    }};
+  }
+
+  #[macro_export]
+  macro_rules! test_for_attribute_type {
+    ($type: ty, $value: expr, $content: expr) => {{
+      #[derive(Debug, PartialEq, YaDeserialize, YaSerialize)]
+      #[yaserde(root = "data")]
+      pub struct Data {
+        #[yaserde(attribute)]
+        item: $type,
+      }
+      let model = Data { item: $value };
+
+      let content = if let Some(str_value) = $content {
+        "<data item=\"".to_string() + str_value + "\" />"
+      } else {
+        "<data />".to_string()
+      };
+
+      serialize_and_validate!(model, content);
+      deserialize_and_validate!(&content, model, Data);
+    }};
+  }
+
+  #[macro_export]
+  macro_rules! deserialize_and_validate {
+    ($content: expr, $model: expr, $struct: tt) => {
+      let loaded: Result<$struct, String> = yaserde::de::from_str($content);
+      assert_eq!(loaded, Ok($model));
+    };
+  }
+
+  #[macro_export]
+  macro_rules! serialize_and_validate {
+    ($model: expr, $content: expr) => {
+      let data: Result<String, String> = yaserde::ser::to_string(&$model);
+
+      let content = String::from(r#"<?xml version="1.0" encoding="utf-8"?>"#) + &$content;
+      assert_eq!(
+        data,
+        Ok(
+          String::from(content)
+            .split("\n")
+            .map(|s| s.trim())
+            .collect::<String>()
+        )
+      );
+    };
+  }
+}

yaserde/tests/de_default.rs

@@ -1,93 +0,0 @@
-#[macro_use]
-extern crate yaserde_derive;
-
-use std::io::Read;
-use yaserde::de::from_str;
-use yaserde::YaDeserialize;
-
-macro_rules! convert_and_validate {
-  ($content: expr, $struct: tt, $model: expr) => {
-    let loaded: Result<$struct, String> = from_str($content);
-    assert_eq!(loaded, Ok($model));
-  };
-}
-
-#[test]
-fn de_default_field_string() {
-  fn default_string() -> String {
-    "my_default_value".to_string()
-  }
-
-  #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root = "base")]
-  pub struct XmlStruct {
-    #[yaserde(default = "default_string")]
-    background: String,
-  }
-
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base />";
-  convert_and_validate!(
-    content,
-    XmlStruct,
-    XmlStruct {
-      background: "my_default_value".to_string(),
-    }
-  );
-}
-
-#[test]
-fn de_default_field_boolean() {
-  fn default_boolean() -> bool {
-    true
-  }
-
-  #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root = "base")]
-  pub struct XmlStruct {
-    #[yaserde(default = "default_boolean")]
-    background: bool,
-  }
-
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base />";
-  convert_and_validate!(content, XmlStruct, XmlStruct { background: true });
-}
-
-#[test]
-fn de_default_field_number() {
-  fn default_number() -> u8 {
-    6
-  }
-
-  #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root = "base")]
-  pub struct XmlStruct {
-    #[yaserde(default = "default_number")]
-    background: u8,
-  }
-
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base />";
-  convert_and_validate!(content, XmlStruct, XmlStruct { background: 6 });
-}
-
-#[test]
-fn de_default_attribute_string() {
-  fn default_string() -> String {
-    "my_default_value".to_string()
-  }
-
-  #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root = "base")]
-  pub struct XmlStruct {
-    #[yaserde(attribute, default = "default_string")]
-    background: String,
-  }
-
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base />";
-  convert_and_validate!(
-    content,
-    XmlStruct,
-    XmlStruct {
-      background: "my_default_value".to_string(),
-    }
-  );
-}

yaserde/tests/de_option.rs

@@ -1,144 +0,0 @@
-#[macro_use]
-extern crate yaserde_derive;
-
-use std::io::Read;
-use yaserde::de::from_str;
-use yaserde::YaDeserialize;
-
-macro_rules! convert_and_validate {
-  ($type: ty, $value: expr, $content: expr) => {{
-    #[derive(YaDeserialize, PartialEq, Debug)]
-    #[yaserde(root = "data")]
-    pub struct Data {
-      item: Option<$type>,
-    }
-
-    let model = Data { item: $value };
-
-    let source = if let Some(content) = $content {
-      String::from("<?xml version=\"1.0\" encoding=\"utf-8\"?><data><item>")
-        + content
-        + "</item></data>"
-    } else {
-      String::from("<?xml version=\"1.0\" encoding=\"utf-8\"?><data />")
-    };
-
-    let loaded: Result<Data, String> = from_str(&source);
-    assert_eq!(loaded, Ok(model));
-  }};
-}
-
-macro_rules! convert_and_validate_for_attribute {
-  ($type: ty, $value: expr, $content: expr) => {{
-    #[derive(YaDeserialize, PartialEq, Debug)]
-    #[yaserde(root = "data")]
-    pub struct Data {
-      #[yaserde(attribute)]
-      item: Option<$type>,
-    }
-
-    let model = Data { item: $value };
-
-    let source = if let Some(content) = $content {
-      String::from("<?xml version=\"1.0\" encoding=\"utf-8\"?><data item=\"")
-        + content
-        + "\"></data>"
-    } else {
-      String::from("<?xml version=\"1.0\" encoding=\"utf-8\"?><data />")
-    };
-
-    let loaded: Result<Data, String> = from_str(&source);
-    assert_eq!(loaded, Ok(model));
-  }};
-}
-
-#[test]
-fn de_option() {
-  convert_and_validate!(String, Some("test".to_string()), Some("test"));
-  convert_and_validate!(String, None, None);
-  convert_and_validate!(bool, Some(true), Some("true"));
-  convert_and_validate!(bool, None, None);
-  convert_and_validate!(u8, Some(12 as u8), Some("12"));
-  convert_and_validate!(u8, None, None);
-  convert_and_validate!(i8, Some(12 as i8), Some("12"));
-  convert_and_validate!(i8, Some(-12 as i8), Some("-12"));
-  convert_and_validate!(i8, None, None);
-  convert_and_validate!(u16, Some(12 as u16), Some("12"));
-  convert_and_validate!(u16, None, None);
-  convert_and_validate!(i16, Some(12 as i16), Some("12"));
-  convert_and_validate!(i16, Some(-12 as i16), Some("-12"));
-  convert_and_validate!(i16, None, None);
-  convert_and_validate!(u32, Some(12 as u32), Some("12"));
-  convert_and_validate!(u32, None, None);
-  convert_and_validate!(i32, Some(12 as i32), Some("12"));
-  convert_and_validate!(i32, Some(-12 as i32), Some("-12"));
-  convert_and_validate!(i32, None, None);
-  convert_and_validate!(u64, Some(12 as u64), Some("12"));
-  convert_and_validate!(u64, None, None);
-  convert_and_validate!(i64, Some(12 as i64), Some("12"));
-  convert_and_validate!(i64, Some(-12 as i64), Some("-12"));
-  convert_and_validate!(i64, None, None);
-  convert_and_validate!(f32, Some(-12.5_f32 as f32), Some("-12.5"));
-  convert_and_validate!(f32, None, None);
-  convert_and_validate!(f64, Some(-12.5 as f64), Some("-12.5"));
-  convert_and_validate!(f64, None, None);
-
-  convert_and_validate_for_attribute!(String, Some("test".to_string()), Some("test"));
-  convert_and_validate_for_attribute!(String, None, None);
-  convert_and_validate_for_attribute!(bool, Some(true), Some("true"));
-  convert_and_validate_for_attribute!(bool, None, None);
-  convert_and_validate_for_attribute!(u8, Some(12 as u8), Some("12"));
-  convert_and_validate_for_attribute!(u8, None, None);
-  convert_and_validate_for_attribute!(i8, Some(12 as i8), Some("12"));
-  convert_and_validate_for_attribute!(i8, Some(-12 as i8), Some("-12"));
-  convert_and_validate_for_attribute!(i8, None, None);
-  convert_and_validate_for_attribute!(u16, Some(12 as u16), Some("12"));
-  convert_and_validate_for_attribute!(u16, None, None);
-  convert_and_validate_for_attribute!(i16, Some(12 as i16), Some("12"));
-  convert_and_validate_for_attribute!(i16, Some(-12 as i16), Some("-12"));
-  convert_and_validate_for_attribute!(i16, None, None);
-  convert_and_validate_for_attribute!(u32, Some(12 as u32), Some("12"));
-  convert_and_validate_for_attribute!(u32, None, None);
-  convert_and_validate_for_attribute!(i32, Some(12 as i32), Some("12"));
-  convert_and_validate_for_attribute!(i32, Some(-12 as i32), Some("-12"));
-  convert_and_validate_for_attribute!(i32, None, None);
-  convert_and_validate_for_attribute!(u64, Some(12 as u64), Some("12"));
-  convert_and_validate_for_attribute!(u64, None, None);
-  convert_and_validate_for_attribute!(i64, Some(12 as i64), Some("12"));
-  convert_and_validate_for_attribute!(i64, Some(-12 as i64), Some("-12"));
-  convert_and_validate_for_attribute!(i64, None, None);
-  convert_and_validate_for_attribute!(f32, Some(-12.5 as f32), Some("-12.5"));
-  convert_and_validate_for_attribute!(f32, None, None);
-  convert_and_validate_for_attribute!(f64, Some(-12.5 as f64), Some("-12.5"));
-  convert_and_validate_for_attribute!(f64, None, None);
-}
-
-#[test]
-fn de_option_struct() {
-  #[derive(YaDeserialize, Debug, PartialEq)]
-  struct Test {
-    field: SubTest,
-  }
-
-  #[derive(YaDeserialize, Debug, PartialEq)]
-  struct SubTest {
-    content: Option<String>,
-  }
-
-  impl Default for SubTest {
-    fn default() -> Self {
-      SubTest { content: None }
-    }
-  }
-
-  convert_and_validate!(
-    Test,
-    Some(Test {
-      field: SubTest {
-        content: Some("value".to_string())
-      }
-    }),
-    Some("<field><content>value</content></field>")
-  );
-  convert_and_validate!(Test, None, None);
-}

yaserde/tests/de_type.rs

@@ -1,81 +0,0 @@
-#[macro_use]
-extern crate yaserde_derive;
-
-use std::io::Read;
-use yaserde::de::from_str;
-use yaserde::YaDeserialize;
-
-macro_rules! convert_and_validate {
-  ($type:ty, $value:expr, $content:expr) => {{
-    #[derive(YaDeserialize, PartialEq, Debug)]
-    #[yaserde(root = "data")]
-    pub struct Data {
-      item: $type,
-    }
-
-    let model = Data { item: $value };
-
-    let content = String::from("<?xml version=\"1.0\" encoding=\"utf-8\"?><data><item>")
-      + $content
-      + "</item></data>";
-
-    let loaded: Result<Data, String> = from_str(&content);
-    assert_eq!(loaded, Ok(model));
-  }};
-}
-
-macro_rules! convert_and_validate_for_attribute {
-  ($type:ty, $value:expr, $content:expr) => {{
-    #[derive(YaDeserialize, PartialEq, Debug)]
-    #[yaserde(root = "data")]
-    pub struct Data {
-      #[yaserde(attribute)]
-      item: $type,
-    }
-
-    let model = Data { item: $value };
-
-    let content =
-      String::from("<?xml version=\"1.0\" encoding=\"utf-8\"?><data item=\"") + $content + "\" />";
-
-    let loaded: Result<Data, String> = from_str(&content);
-    assert_eq!(loaded, Ok(model));
-  }};
-}
-
-#[test]
-fn de_type() {
-  convert_and_validate!(String, "test".to_string(), "test");
-  convert_and_validate!(bool, true, "true");
-  convert_and_validate!(u8, 12 as u8, "12");
-  convert_and_validate!(i8, 12 as i8, "12");
-  convert_and_validate!(i8, -12 as i8, "-12");
-  convert_and_validate!(u16, 12 as u16, "12");
-  convert_and_validate!(i16, 12 as i16, "12");
-  convert_and_validate!(i16, -12 as i16, "-12");
-  convert_and_validate!(u32, 12 as u32, "12");
-  convert_and_validate!(i32, 12 as i32, "12");
-  convert_and_validate!(i32, -12 as i32, "-12");
-  convert_and_validate!(u64, 12 as u64, "12");
-  convert_and_validate!(i64, 12 as i64, "12");
-  convert_and_validate!(i64, -12 as i64, "-12");
-  convert_and_validate!(f32, -12.5_f32 as f32, "-12.5");
-  convert_and_validate!(f64, -12.5 as f64, "-12.5");
-
-  convert_and_validate_for_attribute!(String, "test".to_string(), "test");
-  convert_and_validate_for_attribute!(bool, true, "true");
-  convert_and_validate_for_attribute!(u8, 12 as u8, "12");
-  convert_and_validate_for_attribute!(i8, 12 as i8, "12");
-  convert_and_validate_for_attribute!(i8, -12 as i8, "-12");
-  convert_and_validate_for_attribute!(u16, 12 as u16, "12");
-  convert_and_validate_for_attribute!(i16, 12 as i16, "12");
-  convert_and_validate_for_attribute!(i16, -12 as i16, "-12");
-  convert_and_validate_for_attribute!(u32, 12 as u32, "12");
-  convert_and_validate_for_attribute!(i32, 12 as i32, "12");
-  convert_and_validate_for_attribute!(i32, -12 as i32, "-12");
-  convert_and_validate_for_attribute!(u64, 12 as u64, "12");
-  convert_and_validate_for_attribute!(i64, 12 as i64, "12");
-  convert_and_validate_for_attribute!(i64, -12 as i64, "-12");
-  convert_and_validate_for_attribute!(f32, -12.5 as f32, "-12.5");
-  convert_and_validate_for_attribute!(f64, -12.5 as f64, "-12.5");
-}

yaserde/tests/default.rs

@@ -0,0 +1,113 @@
+#[macro_use]
+extern crate yaserde;
+#[macro_use]
+extern crate yaserde_derive;
+
+use std::io::{Read, Write};
+use yaserde::{YaDeserialize, YaSerialize};
+
+#[test]
+fn default_field_string() {
+  fn default_string() -> String {
+    "my_default_value".to_string()
+  }
+
+  #[derive(Debug, PartialEq, YaDeserialize, YaSerialize)]
+  #[yaserde(root = "base")]
+  pub struct XmlStruct {
+    #[yaserde(default = "default_string")]
+    background: String,
+  }
+
+  let model = XmlStruct {
+    background: "my_default_value".to_string(),
+  };
+
+  let content = "<base />";
+  serialize_and_validate!(model, content);
+  deserialize_and_validate!(content, model, XmlStruct);
+
+
+  let content = "<base><background>my_value</background></base>";
+  let model = XmlStruct {
+      background: "my_value".to_string(),
+    };
+  serialize_and_validate!(model, content);
+  deserialize_and_validate!(content, model, XmlStruct);
+}
+
+#[test]
+fn default_field_boolean() {
+  fn default_boolean() -> bool {
+    true
+  }
+
+  #[derive(Debug, PartialEq, YaDeserialize, YaSerialize)]
+  #[yaserde(root = "base")]
+  pub struct XmlStruct {
+    #[yaserde(default = "default_boolean")]
+    background: bool,
+  }
+
+  let content = "<base />";
+  let model = XmlStruct { background: true };
+  serialize_and_validate!(model, content);
+  deserialize_and_validate!(content, model, XmlStruct);
+
+  let content = "<base><background>false</background></base>";
+  let model = XmlStruct { background: false };
+  serialize_and_validate!(model, content);
+  deserialize_and_validate!(content, model, XmlStruct);
+}
+
+#[test]
+fn default_field_number() {
+  fn default_number() -> u8 {
+    6
+  }
+
+  #[derive(Debug, PartialEq, YaDeserialize, YaSerialize)]
+  #[yaserde(root = "base")]
+  pub struct XmlStruct {
+    #[yaserde(default = "default_number")]
+    background: u8,
+  }
+
+  let content = "<base />";
+  let model = XmlStruct { background: 6 };
+  serialize_and_validate!(model, content);
+  deserialize_and_validate!(content, model, XmlStruct);
+
+  let content = "<base><background>4</background></base>";
+  let model = XmlStruct { background: 4 };
+  serialize_and_validate!(model, content);
+  deserialize_and_validate!(content, model, XmlStruct);
+}
+
+#[test]
+fn de_default_attribute_string() {
+  fn default_string() -> String {
+    "my_default_value".to_string()
+  }
+
+  #[derive(Debug, PartialEq, YaDeserialize, YaSerialize)]
+  #[yaserde(root = "base")]
+  pub struct XmlStruct {
+    #[yaserde(attribute, default = "default_string")]
+    background: String,
+  }
+
+  let content = "<base />";
+  let model = XmlStruct {
+    background: "my_default_value".to_string(),
+  };
+  serialize_and_validate!(model, content);
+  deserialize_and_validate!(content, model, XmlStruct);
+
+  let content = r#"<base background="black" />"#;
+  let model = XmlStruct {
+    background: "black".to_string(),
+  };
+  serialize_and_validate!(model, content);
+  deserialize_and_validate!(content, model, XmlStruct);
+}

yaserde/tests/flatten.rs

@@ -0,0 +1,145 @@
+#[macro_use]
+extern crate yaserde;
+#[macro_use]
+extern crate yaserde_derive;
+
+use std::io::{Read, Write};
+
+use yaserde::{YaDeserialize, YaSerialize};
+
+#[test]
+fn basic_flatten() {
+  #[derive(Default, PartialEq, Debug, YaSerialize)]
+  struct DateTime {
+    #[yaserde(flatten)]
+    date: Date,
+    time: String,
+    #[yaserde(flatten)]
+    kind: DateKind,
+  }
+
+  #[derive(Default, PartialEq, Debug, YaSerialize)]
+  struct Date {
+    year: i32,
+    month: i32,
+    day: i32,
+    #[yaserde(flatten)]
+    extra: Extra,
+    #[yaserde(flatten)]
+    optional_extra: Option<OptionalExtra>,
+  }
+
+  #[derive(Default, PartialEq, Debug, YaSerialize)]
+  pub struct Extra {
+    week: i32,
+    century: i32,
+  }
+
+  #[derive(Default, PartialEq, Debug, YaSerialize)]
+  pub struct OptionalExtra {
+    lunar_day: i32,
+  }
+
+  #[derive(PartialEq, Debug, YaSerialize)]
+  pub enum DateKind {
+    #[yaserde(rename = "holidays")]
+    Holidays(Vec<String>),
+    #[yaserde(rename = "working")]
+    Working,
+  }
+
+  impl Default for DateKind {
+    fn default() -> Self {
+      DateKind::Working
+    }
+  };
+
+  let model = DateTime {
+    date: Date {
+      year: 2020,
+      month: 1,
+      day: 1,
+      extra: Extra {
+        week: 1,
+        century: 21,
+      },
+      optional_extra: Some(OptionalExtra { lunar_day: 1 }),
+    },
+    time: "10:40:03".to_string(),
+    kind: DateKind::Holidays(vec![
+      "New Year's Day".into(),
+      "Novy God Day".into(),
+      "Polar Bear Swim Day".into(),
+    ]),
+  };
+
+  let content = r#"
+    <DateTime>
+      <year>2020</year>
+      <month>1</month>
+      <day>1</day>
+      <week>1</week>
+      <century>21</century>
+      <lunar_day>1</lunar_day>
+      <time>10:40:03</time>
+      <holidays>New Year's Day</holidays>
+      <holidays>Novy God Day</holidays>
+      <holidays>Polar Bear Swim Day</holidays>
+    </DateTime>"#;
+
+  serialize_and_validate!(model, content);
+}
+
+#[test]
+fn root_flatten_struct() {
+  #[derive(YaDeserialize, YaSerialize, PartialEq, Debug)]
+  #[yaserde(flatten)]
+  pub struct Content {
+    binary_data: String,
+    string_data: String,
+  }
+
+  let model = Content {
+    binary_data: "binary".to_string(),
+    string_data: "string".to_string(),
+  };
+
+  let content = "<binary_data>binary</binary_data><string_data>string</string_data>";
+
+  serialize_and_validate!(model, content);
+  deserialize_and_validate!(content, model, Content);
+}
+
+#[test]
+fn root_flatten_enum() {
+  #[derive(YaSerialize, PartialEq, Debug)]
+  #[yaserde(flatten)]
+  pub enum Content {
+    Binary(Binary),
+    Data(Data),
+  }
+
+  #[derive(YaSerialize, PartialEq, Debug)]
+  pub struct Binary {
+    binary_data: String,
+  }
+
+  #[derive(YaSerialize, PartialEq, Debug)]
+  pub struct Data {
+    string_data: String,
+  }
+
+  let model = Content::Binary(Binary {
+    binary_data: "binary".to_string(),
+  });
+
+  let content = "<Binary><binary_data>binary</binary_data></Binary>";
+  serialize_and_validate!(model, content);
+
+  let model = Content::Data(Data {
+    string_data: "string".to_string(),
+  });
+
+  let content = "<Data><string_data>string</string_data></Data>";
+  serialize_and_validate!(model, content);
+}

yaserde/tests/option.rs

@@ -0,0 +1,103 @@
+#[macro_use]
+extern crate yaserde;
+#[macro_use]
+extern crate yaserde_derive;
+
+use std::io::{Read, Write};
+use yaserde::{YaDeserialize, YaSerialize};
+
+#[test]
+fn basic_option_types() {
+  test_for_type!(Option::<String>, Some("test".to_string()), Some("test"));
+  test_for_type!(Option::<String>, None, None);
+  test_for_type!(Option::<bool>, Some(true), Some("true"));
+  test_for_type!(Option::<bool>, None, None);
+  test_for_type!(Option::<u8>, Some(12 as u8), Some("12"));
+  test_for_type!(Option::<u8>, None, None);
+  test_for_type!(Option::<i8>, Some(12 as i8), Some("12"));
+  test_for_type!(Option::<i8>, Some(-12 as i8), Some("-12"));
+  test_for_type!(Option::<i8>, None, None);
+  test_for_type!(Option::<u16>, Some(12 as u16), Some("12"));
+  test_for_type!(Option::<u16>, None, None);
+  test_for_type!(Option::<i16>, Some(12 as i16), Some("12"));
+  test_for_type!(Option::<i16>, Some(-12 as i16), Some("-12"));
+  test_for_type!(Option::<i16>, None, None);
+  test_for_type!(Option::<u32>, Some(12 as u32), Some("12"));
+  test_for_type!(Option::<u32>, None, None);
+  test_for_type!(Option::<i32>, Some(12 as i32), Some("12"));
+  test_for_type!(Option::<i32>, Some(-12 as i32), Some("-12"));
+  test_for_type!(Option::<i32>, None, None);
+  test_for_type!(Option::<u64>, Some(12 as u64), Some("12"));
+  test_for_type!(Option::<u64>, None, None);
+  test_for_type!(Option::<i64>, Some(12 as i64), Some("12"));
+  test_for_type!(Option::<i64>, Some(-12 as i64), Some("-12"));
+  test_for_type!(Option::<i64>, None, None);
+  test_for_type!(Option::<f32>, Some(-12.5 as f32), Some("-12.5"));
+  test_for_type!(Option::<f32>, None, None);
+  test_for_type!(Option::<f64>, Some(-12.5 as f64), Some("-12.5"));
+  test_for_type!(Option::<f64>, None, None);
+
+  // test_for_type!(Option::<Vec::<u8>>, None, None);
+  // test_for_type!(Option::<Vec::<u8>>, Some(vec![0]), Some("0"));
+  // test_for_type!(Option::<Vec::<String>>, None, None);
+  // test_for_type!(Option::<Vec::<String>>, Some(vec!["test".to_string()]), Some("test"));
+
+  test_for_attribute_type!(Option::<String>, Some("test".to_string()), Some("test"));
+  test_for_attribute_type!(Option::<String>, None, None);
+  test_for_attribute_type!(Option::<bool>, Some(true), Some("true"));
+  test_for_attribute_type!(Option::<bool>, None, None);
+  test_for_attribute_type!(Option::<u8>, Some(12 as u8), Some("12"));
+  test_for_attribute_type!(Option::<u8>, None, None);
+  test_for_attribute_type!(Option::<i8>, Some(12 as i8), Some("12"));
+  test_for_attribute_type!(Option::<i8>, Some(-12 as i8), Some("-12"));
+  test_for_attribute_type!(Option::<i8>, None, None);
+  test_for_attribute_type!(Option::<u16>, Some(12 as u16), Some("12"));
+  test_for_attribute_type!(Option::<u16>, None, None);
+  test_for_attribute_type!(Option::<i16>, Some(12 as i16), Some("12"));
+  test_for_attribute_type!(Option::<i16>, Some(-12 as i16), Some("-12"));
+  test_for_attribute_type!(Option::<i16>, None, None);
+  test_for_attribute_type!(Option::<u32>, Some(12 as u32), Some("12"));
+  test_for_attribute_type!(Option::<u32>, None, None);
+  test_for_attribute_type!(Option::<i32>, Some(12 as i32), Some("12"));
+  test_for_attribute_type!(Option::<i32>, Some(-12 as i32), Some("-12"));
+  test_for_attribute_type!(Option::<i32>, None, None);
+  test_for_attribute_type!(Option::<u64>, Some(12 as u64), Some("12"));
+  test_for_attribute_type!(Option::<u64>, None, None);
+  test_for_attribute_type!(Option::<i64>, Some(12 as i64), Some("12"));
+  test_for_attribute_type!(Option::<i64>, Some(-12 as i64), Some("-12"));
+  test_for_attribute_type!(Option::<i64>, None, None);
+  test_for_attribute_type!(Option::<f32>, Some(-12.5 as f32), Some("-12.5"));
+  test_for_attribute_type!(Option::<f32>, None, None);
+  test_for_attribute_type!(Option::<f64>, Some(-12.5 as f64), Some("-12.5"));
+  test_for_attribute_type!(Option::<f64>, None, None);
+}
+
+#[test]
+fn option_struct() {
+  #[derive(Debug, PartialEq, YaDeserialize, YaSerialize)]
+  struct Test {
+    field: SubTest,
+  }
+
+  #[derive(Debug, PartialEq, YaDeserialize, YaSerialize)]
+  struct SubTest {
+    content: Option<String>,
+  }
+
+  impl Default for SubTest {
+    fn default() -> Self {
+      SubTest { content: None }
+    }
+  }
+
+  test_for_type!(
+    Option::<Test>,
+    Some(Test {
+      field: SubTest {
+        content: Some("value".to_string())
+      }
+    }),
+    Some("<field><content>value</content></field>")
+  );
+  test_for_type!(Option::<Test>, None, None);
+}

yaserde/tests/ser_default.rs

@@ -1,103 +0,0 @@
-#[macro_use]
-extern crate yaserde_derive;
-
-use std::io::Write;
-use yaserde::ser::to_string;
-use yaserde::YaSerialize;
-
-macro_rules! convert_and_validate {
-  ($model:expr, $content:expr) => {
-    let data: Result<String, String> = to_string(&$model);
-    assert_eq!(data, Ok(String::from($content)));
-  };
-}
-
-#[test]
-fn ser_default_field_string() {
-  fn default_string() -> String {
-    "my_default_value".to_string()
-  }
-
-  #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root = "base")]
-  pub struct XmlStruct {
-    #[yaserde(default = "default_string")]
-    background: String,
-  }
-
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base />";
-  convert_and_validate!(
-    XmlStruct {
-      background: "my_default_value".to_string(),
-    },
-    content
-  );
-  let content =
-    "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><background>my_value</background></base>";
-  convert_and_validate!(
-    XmlStruct {
-      background: "my_value".to_string(),
-    },
-    content
-  );
-}
-
-#[test]
-fn ser_default_field_boolean() {
-  fn default_boolean() -> bool {
-    true
-  }
-
-  #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root = "base")]
-  pub struct XmlStruct {
-    #[yaserde(default = "default_boolean")]
-    background: bool,
-  }
-
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base />";
-  convert_and_validate!(XmlStruct { background: true }, content);
-
-  let content =
-    "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><background>false</background></base>";
-  convert_and_validate!(XmlStruct { background: false }, content);
-}
-
-#[test]
-fn ser_default_field_number() {
-  fn default_number() -> u8 {
-    6
-  }
-
-  #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root = "base")]
-  pub struct XmlStruct {
-    #[yaserde(default = "default_number")]
-    background: u8,
-  }
-
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base />";
-  convert_and_validate!(XmlStruct { background: 6 }, content);
-}
-
-#[test]
-fn ser_default_attribute_string() {
-  fn default_string() -> String {
-    "my_default_value".to_string()
-  }
-
-  #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root = "base")]
-  pub struct XmlStruct {
-    #[yaserde(attribute, default = "default_string")]
-    background: String,
-  }
-
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base />";
-  convert_and_validate!(
-    XmlStruct {
-      background: "my_default_value".to_string(),
-    },
-    content
-  );
-}

yaserde/tests/ser_enum.rs

@@ -1,25 +1,11 @@
 #[macro_use]
+extern crate yaserde;
+#[macro_use]
 extern crate yaserde_derive;
 
 use std::io::Write;
-use yaserde::ser::to_string;
 use yaserde::YaSerialize;
 
-macro_rules! convert_and_validate {
-  ($model: expr, $content: expr) => {
-    let data: Result<String, String> = to_string(&$model);
-    assert_eq!(
-      data,
-      Ok(
-        String::from($content)
-          .split("\n")
-          .map(|s| s.trim())
-          .collect::<String>()
-      )
-    );
-  };
-}
-
 #[test]
 fn ser_enum() {
   #[derive(YaSerialize, PartialEq, Debug)]
@@ -77,8 +63,8 @@ fn ser_enum() {
     color: Color::Black,
   };
 
-  let content = r#"<?xml version="1.0" encoding="utf-8"?><base><color>Black</color></base>"#;
+  let content = "<base><color>Black</color></base>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 
   let model = XmlStruct {
     color: Color::Custom {
@@ -103,7 +89,7 @@ fn ser_enum() {
     },
   };
 
-  let content = r#"<?xml version="1.0" encoding="utf-8"?>
+  let content = r#"
 <base>
 <color><enabled>true</enabled>
 <u8_value>8</u8_value>
@@ -123,7 +109,7 @@ fn ser_enum() {
 </color>
 </base>"#;
 
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -144,8 +130,8 @@ fn ser_attribute_enum() {
 
   let model = XmlStruct { color: Color::Pink };
 
-  let content = r#"<?xml version="1.0" encoding="utf-8"?><base color="pink" />"#;
+  let content = r#"<base color="pink" />"#;
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -190,73 +176,72 @@ fn ser_unnamed_enum() {
     color: Enum::Field(String::from("some_text")),
   };
 
-  let content =
+  let content = "<base><color><Field>some_text</Field></color></base>";
-    r#"<?xml version="1.0" encoding="utf-8"?><base><color><Field>some_text</Field></color></base>"#;
+  serialize_and_validate!(model, content);
-  convert_and_validate!(model, content);
 
   let model = XmlStruct {
     color: Enum::FullPath(String::from("some_text")),
   };
 
-  let content = r#"<?xml version="1.0" encoding="utf-8"?><base><color><FullPath>some_text</FullPath></color></base>"#;
+  let content = "<base><color><FullPath>some_text</FullPath></color></base>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 
   let model = XmlStruct {
     color: Enum::Integer(56),
   };
 
-  let content =
+  let content = "<base><color><Integer>56</Integer></color></base>";
-    r#"<?xml version="1.0" encoding="utf-8"?><base><color><Integer>56</Integer></color></base>"#;
+  serialize_and_validate!(model, content);
-  convert_and_validate!(model, content);
 
   let model = XmlStruct {
     color: Enum::UserStruct(OtherStruct { fi: 24, se: 42 }),
   };
 
-  let content = r#"<?xml version="1.0" encoding="utf-8"?><base><color><UserStruct><fi>24</fi><se>42</se></UserStruct></color></base>"#;
+  let content = "<base><color><UserStruct><fi>24</fi><se>42</se></UserStruct></color></base>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 
   let model = XmlStruct {
     color: Enum::OptionString(Some(String::from("some_text"))),
   };
 
-  let content = r#"<?xml version="1.0" encoding="utf-8"?><base><color><OptionString>some_text</OptionString></color></base>"#;
+  let content = "<base><color><OptionString>some_text</OptionString></color></base>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 
   let model = XmlStruct {
     color: Enum::OptionString(None),
   };
 
-  let content = r#"<?xml version="1.0" encoding="utf-8"?><base><color /></base>"#;
+  let content = "<base><color /></base>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 
   let model = XmlStruct {
     color: Enum::OptionUserStruct(Some(OtherStruct { fi: 12, se: 23 })),
   };
 
-  let content = r#"<?xml version="1.0" encoding="utf-8"?><base><color><OptionUserStruct><fi>12</fi><se>23</se></OptionUserStruct></color></base>"#;
+  let content =
-  convert_and_validate!(model, content);
+    "<base><color><OptionUserStruct><fi>12</fi><se>23</se></OptionUserStruct></color></base>";
+  serialize_and_validate!(model, content);
 
   let model = XmlStruct {
     color: Enum::OptionUserStruct(None),
   };
 
-  let content = r#"<?xml version="1.0" encoding="utf-8"?><base><color /></base>"#;
+  let content = "<base><color /></base>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 
   let model = XmlStruct {
     color: Enum::Strings(vec![String::from("abc"), String::from("def")]),
   };
 
-  let content = r#"<?xml version="1.0" encoding="utf-8"?><base><color><Strings>abc</Strings><Strings>def</Strings></color></base>"#;
+  let content = "<base><color><Strings>abc</Strings><Strings>def</Strings></color></base>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 
   let model = XmlStruct {
     color: Enum::Ints(vec![23, 45]),
   };
 
-  let content = r#"<?xml version="1.0" encoding="utf-8"?><base><color><Ints>23</Ints><Ints>45</Ints></color></base>"#;
+  let content = "<base><color><Ints>23</Ints><Ints>45</Ints></color></base>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 
   let model = XmlStruct {
     color: Enum::Structs(vec![
@@ -265,21 +250,20 @@ fn ser_unnamed_enum() {
     ]),
   };
 
-  let content = r#"<?xml version="1.0" encoding="utf-8"?><base><color><Structs><fi>12</fi><se>23</se></Structs><Structs><fi>34</fi><se>45</se></Structs></color></base>"#;
+  let content = "<base><color><Structs><fi>12</fi><se>23</se></Structs><Structs><fi>34</fi><se>45</se></Structs></color></base>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 
   let model = XmlStruct {
     color: Enum::ToRename(87),
   };
 
-  let content =
+  let content = "<base><color><renamed>87</renamed></color></base>";
-    r#"<?xml version="1.0" encoding="utf-8"?><base><color><renamed>87</renamed></color></base>"#;
+  serialize_and_validate!(model, content);
-  convert_and_validate!(model, content);
 
   let model = XmlStruct {
     color: Enum::ToRenameDots(84),
   };
 
-  let content = r#"<?xml version="1.0" encoding="utf-8"?><base><color><renamed.with.dots>84</renamed.with.dots></color></base>"#;
+  let content = "<base><color><renamed.with.dots>84</renamed.with.dots></color></base>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }

yaserde/tests/ser_flatten.rs

@@ -1,25 +1,11 @@
 #[macro_use]
+extern crate yaserde;
+#[macro_use]
 extern crate yaserde_derive;
 
 use std::io::Write;
-use yaserde::ser::to_string;
 use yaserde::YaSerialize;
 
-macro_rules! convert_and_validate {
-  ($model: expr, $content: expr) => {
-    let data: Result<String, String> = to_string(&$model);
-    assert_eq!(
-      data,
-      Ok(
-        String::from($content)
-          .split("\n")
-          .map(|s| s.trim())
-          .collect::<String>()
-      )
-    );
-  };
-}
-
 #[test]
 fn ser_flatten() {
   #[derive(Default, PartialEq, Debug, YaSerialize)]
@@ -87,7 +73,6 @@ fn ser_flatten() {
   };
 
   let content = r#"
-    <?xml version="1.0" encoding="utf-8"?>
     <DateTime>
       <year>2020</year>
       <month>1</month>
@@ -101,7 +86,7 @@ fn ser_flatten() {
       <holidays>Polar Bear Swim Day</holidays>
     </DateTime>"#;
 
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -117,8 +102,8 @@ fn ser_root_flatten_struct() {
     binary_data: "binary".to_string(),
     string_data: "string".to_string(),
   };
-  let content = r#"<?xml version="1.0" encoding="utf-8"?><binary_data>binary</binary_data><string_data>string</string_data>"#;
+  let content = "<binary_data>binary</binary_data><string_data>string</string_data>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -143,14 +128,12 @@ fn ser_root_flatten_enum() {
   let model = Content::Binary(Binary {
     binary_data: "binary".to_string(),
   });
-  let content =
+  let content = "<Binary><binary_data>binary</binary_data></Binary>";
-    r#"<?xml version="1.0" encoding="utf-8"?><Binary><binary_data>binary</binary_data></Binary>"#;
+  serialize_and_validate!(model, content);
-  convert_and_validate!(model, content);
 
   let model = Content::Data(Data {
     string_data: "string".to_string(),
   });
-  let content =
+  let content = "<Data><string_data>string</string_data></Data>";
-    r#"<?xml version="1.0" encoding="utf-8"?><Data><string_data>string</string_data></Data>"#;
+  serialize_and_validate!(model, content);
-  convert_and_validate!(model, content);
 }

yaserde/tests/ser_namespace.rs

@@ -1,25 +1,11 @@
 #[macro_use]
+extern crate yaserde;
+#[macro_use]
 extern crate yaserde_derive;
 
 use std::io::Write;
-use yaserde::ser::to_string;
 use yaserde::YaSerialize;
 
-macro_rules! convert_and_validate {
-  ($model: expr, $content: expr) => {
-    let data: Result<String, String> = to_string(&$model);
-    assert_eq!(
-      data,
-      Ok(
-        String::from($content)
-          .split("\n")
-          .map(|s| s.trim())
-          .collect::<String>()
-      )
-    );
-  };
-}
-
 #[test]
 fn ser_struct_namespace() {
   #[derive(YaSerialize, PartialEq, Debug)]
@@ -37,8 +23,9 @@ fn ser_struct_namespace() {
     item: "something".to_string(),
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ns:root xmlns:ns=\"http://www.sample.com/ns/domain\"><ns:item>something</ns:item></ns:root>";
+  let content =
-  convert_and_validate!(model, content);
+    r#"<ns:root xmlns:ns="http://www.sample.com/ns/domain"><ns:item>something</ns:item></ns:root>"#;
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -58,13 +45,13 @@ fn ser_enum_namespace() {
 
   let model = XmlStruct::Item;
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ns:root xmlns:ns=\"http://www.sample.com/ns/domain\">ns:Item</ns:root>";
+  let content = r#"<ns:root xmlns:ns="http://www.sample.com/ns/domain">ns:Item</ns:root>"#;
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 
   let model = XmlStruct::ItemWithField("Value".to_string());
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ns:root xmlns:ns=\"http://www.sample.com/ns/domain\"><ns:ItemWithField>Value</ns:ItemWithField></ns:root>";
+  let content = r#"<ns:root xmlns:ns="http://www.sample.com/ns/domain"><ns:ItemWithField>Value</ns:ItemWithField></ns:root>"#;
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -87,8 +74,8 @@ fn ser_struct_multi_namespace() {
     item_2: "something 2".to_string(),
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><root xmlns:ns1=\"http://www.sample.com/ns/domain1\" xmlns:ns2=\"http://www.sample.com/ns/domain2\"><ns1:item_1>something 1</ns1:item_1><ns2:item_2>something 2</ns2:item_2></root>";
+  let content = r#"<root xmlns:ns1="http://www.sample.com/ns/domain1" xmlns:ns2="http://www.sample.com/ns/domain2"><ns1:item_1>something 1</ns1:item_1><ns2:item_2>something 2</ns2:item_2></root>"#;
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -107,11 +94,11 @@ fn ser_enum_multi_namespace() {
   }
 
   let model1 = XmlStruct::Item1;
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><root xmlns:ns1=\"http://www.sample.com/ns/domain1\" xmlns:ns2=\"http://www.sample.com/ns/domain2\">ns1:Item1</root>";
+  let content = r#"<root xmlns:ns1="http://www.sample.com/ns/domain1" xmlns:ns2="http://www.sample.com/ns/domain2">ns1:Item1</root>"#;
-  convert_and_validate!(model1, content);
+  serialize_and_validate!(model1, content);
   let model2 = XmlStruct::Item2;
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><root xmlns:ns1=\"http://www.sample.com/ns/domain1\" xmlns:ns2=\"http://www.sample.com/ns/domain2\">ns2:Item2</root>";
+  let content = r#"<root xmlns:ns1="http://www.sample.com/ns/domain1" xmlns:ns2="http://www.sample.com/ns/domain2">ns2:Item2</root>"#;
-  convert_and_validate!(model2, content);
+  serialize_and_validate!(model2, content);
 }
 
 #[test]
@@ -134,8 +121,8 @@ fn ser_struct_attribute_namespace() {
     item_2: "something 2".to_string(),
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><root xmlns:ns1=\"http://www.sample.com/ns/domain1\" xmlns:ns2=\"http://www.sample.com/ns/domain2\" ns2:item_2=\"something 2\"><ns1:item_1>something 1</ns1:item_1></root>";
+  let content = r#"<root xmlns:ns1="http://www.sample.com/ns/domain1" xmlns:ns2="http://www.sample.com/ns/domain2" ns2:item_2="something 2"><ns1:item_1>something 1</ns1:item_1></root>"#;
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -154,8 +141,8 @@ fn ser_struct_default_namespace() {
     item: "something".to_string(),
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><tt xmlns=\"http://www.w3.org/ns/ttml\" xmlns:ttm=\"http://www.w3.org/ns/ttml#metadata\"><item>something</item></tt>";
+  let content = r#"<tt xmlns="http://www.w3.org/ns/ttml" xmlns:ttm="http://www.w3.org/ns/ttml#metadata"><item>something</item></tt>"#;
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -175,8 +162,8 @@ fn ser_struct_default_namespace_via_attribute() {
     item: "something".to_string(),
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><tt xmlns=\"http://www.w3.org/ns/ttml\" xmlns:ttm=\"http://www.w3.org/ns/ttml#metadata\"><item>something</item></tt>";
+  let content = r#"<tt xmlns="http://www.w3.org/ns/ttml" xmlns:ttm="http://www.w3.org/ns/ttml#metadata"><item>something</item></tt>"#;
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -198,8 +185,8 @@ fn ser_struct_default_namespace_via_attribute_with_prefix() {
     item: "something".to_string(),
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><tt xmlns=\"http://www.w3.org/ns/ttml\" xmlns:ttm=\"http://www.w3.org/ns/ttml#metadata\"><item>something</item></tt>";
+  let content = r#"<tt xmlns="http://www.w3.org/ns/ttml" xmlns:ttm="http://www.w3.org/ns/ttml#metadata"><item>something</item></tt>"#;
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -219,12 +206,11 @@ fn ser_struct_namespace_nested() {
     nested: A,
   }
 
-  convert_and_validate!(
+  serialize_and_validate!(
     B {
       nested: A { alpha: 32 }
     },
     r#"
-    <?xml version="1.0" encoding="utf-8"?>
     <nsb:B xmlns:nsb="http://www.sample.com/ns/b">
       <nsb:nested xmlns:nsa="http://www.sample.com/ns/a">
         <nsa:alpha>32</nsa:alpha>

yaserde/tests/ser_option.rs

@@ -1,147 +0,0 @@
-#[macro_use]
-extern crate yaserde_derive;
-
-use std::io::Write;
-use yaserde::ser::to_string;
-use yaserde::YaSerialize;
-
-macro_rules! convert_and_validate {
-  ($type: ty, $value: expr, $content: expr) => {{
-    #[derive(YaSerialize, PartialEq, Debug)]
-    #[yaserde(root = "data")]
-    pub struct Data {
-      item: Option<$type>,
-    }
-    let model = Data { item: $value };
-
-    let data: Result<String, String> = to_string(&model);
-
-    let content = if let Some(str_value) = $content {
-      "<data><item>".to_string() + str_value + "</item></data>"
-    } else {
-      "<data />".to_string()
-    };
-
-    let content = String::from("<?xml version=\"1.0\" encoding=\"utf-8\"?>") + &content;
-    assert_eq!(data, Ok(content));
-  }};
-}
-
-macro_rules! convert_and_validate_as_attribute {
-  ($type: ty, $value: expr, $content: expr) => {{
-    #[derive(YaSerialize, PartialEq, Debug)]
-    #[yaserde(root = "data")]
-    pub struct Data {
-      #[yaserde(attribute)]
-      item: Option<$type>,
-    }
-    let model = Data { item: $value };
-
-    let data: Result<String, String> = to_string(&model);
-
-    let content = if let Some(str_value) = $content {
-      "<data item=\"".to_string() + str_value + "\" />"
-    } else {
-      "<data />".to_string()
-    };
-
-    let content = String::from("<?xml version=\"1.0\" encoding=\"utf-8\"?>") + &content;
-    assert_eq!(data, Ok(content));
-  }};
-}
-
-#[test]
-fn ser_option() {
-  convert_and_validate!(String, Some("test".to_string()), Some("test"));
-  convert_and_validate!(String, None, None);
-  convert_and_validate!(bool, Some(true), Some("true"));
-  convert_and_validate!(bool, None, None);
-  convert_and_validate!(u8, Some(12 as u8), Some("12"));
-  convert_and_validate!(u8, None, None);
-  convert_and_validate!(i8, Some(12 as i8), Some("12"));
-  convert_and_validate!(i8, Some(-12 as i8), Some("-12"));
-  convert_and_validate!(i8, None, None);
-  convert_and_validate!(u16, Some(12 as u16), Some("12"));
-  convert_and_validate!(u16, None, None);
-  convert_and_validate!(i16, Some(12 as i16), Some("12"));
-  convert_and_validate!(i16, Some(-12 as i16), Some("-12"));
-  convert_and_validate!(i16, None, None);
-  convert_and_validate!(u32, Some(12 as u32), Some("12"));
-  convert_and_validate!(u32, None, None);
-  convert_and_validate!(i32, Some(12 as i32), Some("12"));
-  convert_and_validate!(i32, Some(-12 as i32), Some("-12"));
-  convert_and_validate!(i32, None, None);
-  convert_and_validate!(u64, Some(12 as u64), Some("12"));
-  convert_and_validate!(u64, None, None);
-  convert_and_validate!(i64, Some(12 as i64), Some("12"));
-  convert_and_validate!(i64, Some(-12 as i64), Some("-12"));
-  convert_and_validate!(i64, None, None);
-  convert_and_validate!(f32, Some(-12.5 as f32), Some("-12.5"));
-  convert_and_validate!(f32, None, None);
-  convert_and_validate!(f64, Some(-12.5 as f64), Some("-12.5"));
-  convert_and_validate!(f64, None, None);
-
-  convert_and_validate!(Vec<u8>, None, None);
-  convert_and_validate!(Vec<u8>, Some(vec![0]), Some("0"));
-  convert_and_validate!(Vec<String>, None, None);
-  convert_and_validate!(Vec<String>, Some(vec!["test".to_string()]), Some("test"));
-
-  convert_and_validate_as_attribute!(String, Some("test".to_string()), Some("test"));
-  convert_and_validate_as_attribute!(String, None, None);
-  convert_and_validate_as_attribute!(bool, Some(true), Some("true"));
-  convert_and_validate_as_attribute!(bool, None, None);
-  convert_and_validate_as_attribute!(u8, Some(12 as u8), Some("12"));
-  convert_and_validate_as_attribute!(u8, None, None);
-  convert_and_validate_as_attribute!(i8, Some(12 as i8), Some("12"));
-  convert_and_validate_as_attribute!(i8, Some(-12 as i8), Some("-12"));
-  convert_and_validate_as_attribute!(i8, None, None);
-  convert_and_validate_as_attribute!(u16, Some(12 as u16), Some("12"));
-  convert_and_validate_as_attribute!(u16, None, None);
-  convert_and_validate_as_attribute!(i16, Some(12 as i16), Some("12"));
-  convert_and_validate_as_attribute!(i16, Some(-12 as i16), Some("-12"));
-  convert_and_validate_as_attribute!(i16, None, None);
-  convert_and_validate_as_attribute!(u32, Some(12 as u32), Some("12"));
-  convert_and_validate_as_attribute!(u32, None, None);
-  convert_and_validate_as_attribute!(i32, Some(12 as i32), Some("12"));
-  convert_and_validate_as_attribute!(i32, Some(-12 as i32), Some("-12"));
-  convert_and_validate_as_attribute!(i32, None, None);
-  convert_and_validate_as_attribute!(u64, Some(12 as u64), Some("12"));
-  convert_and_validate_as_attribute!(u64, None, None);
-  convert_and_validate_as_attribute!(i64, Some(12 as i64), Some("12"));
-  convert_and_validate_as_attribute!(i64, Some(-12 as i64), Some("-12"));
-  convert_and_validate_as_attribute!(i64, None, None);
-  convert_and_validate_as_attribute!(f32, Some(-12.5 as f32), Some("-12.5"));
-  convert_and_validate_as_attribute!(f32, None, None);
-  convert_and_validate_as_attribute!(f64, Some(-12.5 as f64), Some("-12.5"));
-  convert_and_validate_as_attribute!(f64, None, None);
-}
-
-#[test]
-fn de_option_struct() {
-  #[derive(YaSerialize, Debug, PartialEq)]
-  struct Test {
-    field: SubTest,
-  }
-
-  #[derive(YaSerialize, Debug, PartialEq)]
-  struct SubTest {
-    content: Option<String>,
-  }
-
-  impl Default for SubTest {
-    fn default() -> Self {
-      SubTest { content: None }
-    }
-  }
-
-  convert_and_validate!(
-    Test,
-    Some(Test {
-      field: SubTest {
-        content: Some("value".to_string())
-      }
-    }),
-    Some("<field><content>value</content></field>")
-  );
-  convert_and_validate!(Test, None, None);
-}

yaserde/tests/ser_skip.rs

@@ -1,25 +1,11 @@
 #[macro_use]
+extern crate yaserde;
+#[macro_use]
 extern crate yaserde_derive;
 
 use std::io::Write;
-use yaserde::ser::to_string;
 use yaserde::YaSerialize;
 
-macro_rules! convert_and_validate {
-  ($model: expr, $content: expr) => {
-    let data: Result<String, String> = to_string(&$model);
-    assert_eq!(
-      data,
-      Ok(
-        String::from($content)
-          .split("\n")
-          .map(|s| s.trim())
-          .collect::<String>()
-      )
-    );
-  };
-}
-
 #[test]
 fn ser_skip_serializing_if_for_struct() {
   #[derive(YaSerialize, PartialEq, Debug)]
@@ -60,6 +46,6 @@ fn ser_skip_serializing_if_for_struct() {
     option_string_item: Some("something".to_string()),
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base />";
+  let content = "<base />";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }

yaserde/tests/ser_type.rs

@@ -1,83 +0,0 @@
-#[macro_use]
-extern crate yaserde_derive;
-
-use std::io::Write;
-use yaserde::ser::to_string;
-use yaserde::YaSerialize;
-
-macro_rules! convert_and_validate {
-  ($type: ty, $value: expr, $content: expr) => {{
-    #[derive(YaSerialize, PartialEq, Debug)]
-    #[yaserde(root = "data")]
-    pub struct Data {
-      item: $type,
-    }
-    let model = Data { item: $value };
-
-    let data: Result<String, String> = to_string(&model);
-    let content = if $content == "" {
-      String::from("<?xml version=\"1.0\" encoding=\"utf-8\"?><data />")
-    } else {
-      String::from("<?xml version=\"1.0\" encoding=\"utf-8\"?><data><item>")
-        + $content
-        + "</item></data>"
-    };
-    assert_eq!(data, Ok(content));
-  }};
-}
-
-macro_rules! convert_and_validate_as_attribute {
-  ($type: ty, $value: expr, $content: expr) => {{
-    #[derive(YaSerialize, PartialEq, Debug)]
-    #[yaserde(root = "data")]
-    pub struct Data {
-      #[yaserde(attribute)]
-      item: $type,
-    }
-    let model = Data { item: $value };
-
-    let data: Result<String, String> = to_string(&model);
-    let content =
-      String::from("<?xml version=\"1.0\" encoding=\"utf-8\"?><data item=\"") + $content + "\" />";
-    assert_eq!(data, Ok(content));
-  }};
-}
-
-#[test]
-fn ser_type() {
-  convert_and_validate!(String, "test".to_string(), "test");
-  convert_and_validate!(bool, true, "true");
-  convert_and_validate!(u8, 12 as u8, "12");
-  convert_and_validate!(i8, 12 as i8, "12");
-  convert_and_validate!(i8, -12 as i8, "-12");
-  convert_and_validate!(u16, 12 as u16, "12");
-  convert_and_validate!(i16, 12 as i16, "12");
-  convert_and_validate!(i16, -12 as i16, "-12");
-  convert_and_validate!(u32, 12 as u32, "12");
-  convert_and_validate!(i32, 12 as i32, "12");
-  convert_and_validate!(i32, -12 as i32, "-12");
-  convert_and_validate!(u64, 12 as u64, "12");
-  convert_and_validate!(i64, 12 as i64, "12");
-  convert_and_validate!(i64, -12 as i64, "-12");
-  convert_and_validate!(f32, -12.5 as f32, "-12.5");
-  convert_and_validate!(f64, -12.5 as f64, "-12.5");
-  convert_and_validate!(Vec<String>, vec![], "");
-  convert_and_validate!(Vec<String>, vec!["test".to_string()], "test");
-
-  convert_and_validate_as_attribute!(String, "test".to_string(), "test");
-  convert_and_validate_as_attribute!(bool, true, "true");
-  convert_and_validate_as_attribute!(u8, 12 as u8, "12");
-  convert_and_validate_as_attribute!(i8, 12 as i8, "12");
-  convert_and_validate_as_attribute!(i8, -12 as i8, "-12");
-  convert_and_validate_as_attribute!(u16, 12 as u16, "12");
-  convert_and_validate_as_attribute!(i16, 12 as i16, "12");
-  convert_and_validate_as_attribute!(i16, -12 as i16, "-12");
-  convert_and_validate_as_attribute!(u32, 12 as u32, "12");
-  convert_and_validate_as_attribute!(i32, 12 as i32, "12");
-  convert_and_validate_as_attribute!(i32, -12 as i32, "-12");
-  convert_and_validate_as_attribute!(u64, 12 as u64, "12");
-  convert_and_validate_as_attribute!(i64, 12 as i64, "12");
-  convert_and_validate_as_attribute!(i64, -12 as i64, "-12");
-  convert_and_validate_as_attribute!(f32, -12.5 as f32, "-12.5");
-  convert_and_validate_as_attribute!(f64, -12.5 as f64, "-12.5");
-}

yaserde/tests/serializer.rs

@@ -1,25 +1,11 @@
 #[macro_use]
+extern crate yaserde;
+#[macro_use]
 extern crate yaserde_derive;
 
 use std::io::Write;
-use yaserde::ser::to_string;
 use yaserde::YaSerialize;
 
-macro_rules! convert_and_validate {
-  ($model: expr, $content: expr) => {
-    let data: Result<String, String> = to_string(&$model);
-    assert_eq!(
-      data,
-      Ok(
-        String::from($content)
-          .split("\n")
-          .map(|s| s.trim())
-          .collect::<String>()
-      )
-    );
-  };
-}
-
 #[test]
 fn ser_basic() {
   #[derive(YaSerialize, PartialEq, Debug)]
@@ -32,8 +18,8 @@ fn ser_basic() {
     item: "something".to_string(),
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><item>something</item></base>";
+  let content = "<base><item>something</item></base>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -48,8 +34,8 @@ fn ser_list_of_items() {
     items: vec!["something1".to_string(), "something2".to_string()],
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><items>something1</items><items>something2</items></base>";
+  let content = "<base><items>something1</items><items>something2</items></base>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 
   #[derive(YaSerialize, PartialEq, Debug)]
   #[yaserde(root = "base")]
@@ -74,8 +60,9 @@ fn ser_list_of_items() {
     ],
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><items><field>something1</field></items><items><field>something2</field></items></base>";
+  let content =
-  convert_and_validate!(model2, content);
+    "<base><items><field>something1</field></items><items><field>something2</field></items></base>";
+  serialize_and_validate!(model2, content);
 }
 
 #[test]
@@ -117,8 +104,8 @@ fn ser_attributes() {
     },
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base item=\"something\"><sub subitem=\"sub-something\" /></base>";
+  let content = r#"<base item="something"><sub subitem="sub-something" /></base>"#;
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -158,24 +145,20 @@ fn ser_attributes_complex() {
     }
   }
 
-  convert_and_validate!(
+  serialize_and_validate!(
     Struct {
       attr_option_string: None,
       attr_option_enum: None,
     },
-    r#"
+    "<Struct />"
-    <?xml version="1.0" encoding="utf-8"?>
-    <Struct />
-    "#
   );
 
-  convert_and_validate!(
+  serialize_and_validate!(
     Struct {
       attr_option_string: Some("some value".to_string()),
       attr_option_enum: Some(other_mod::AttrEnum::Variant2),
     },
     r#"
-    <?xml version="1.0" encoding="utf-8"?>
     <Struct attr_option_string="some value" attr_option_enum="variant 2" />
     "#
   );
@@ -224,8 +207,8 @@ fn ser_rename() {
     version: "2.0.2".into(),
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base Item=\"something\"><sub sub_item=\"sub_something\" /><maj.min.bug>2.0.2</maj.min.bug></base>";
+  let content = r#"<base Item="something"><sub sub_item="sub_something" /><maj.min.bug>2.0.2</maj.min.bug></base>"#;
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -273,8 +256,8 @@ fn ser_text_content_with_attributes() {
     },
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base Item=\"something\"><sub sub_item=\"sub_something\">text_content</sub></base>";
+  let content = r#"<base Item="something"><sub sub_item="sub_something">text_content</sub></base>"#;
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -289,8 +272,8 @@ fn ser_name_issue_21() {
     name: "something".to_string(),
   };
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><name>something</name></base>";
+  let content = "<base><name>something</name></base>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }
 
 #[test]
@@ -326,6 +309,6 @@ fn ser_custom() {
     month: 1,
     day: Day { value: 5 },
   };
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><Date><Year>2020</Year><Month>1</Month><DoubleDay>10</DoubleDay></Date>";
+  let content = "<Date><Year>2020</Year><Month>1</Month><DoubleDay>10</DoubleDay></Date>";
-  convert_and_validate!(model, content);
+  serialize_and_validate!(model, content);
 }

yaserde/tests/types.rs

@@ -0,0 +1,46 @@
+#[macro_use]
+extern crate yaserde;
+#[macro_use]
+extern crate yaserde_derive;
+
+use std::io::{Read, Write};
+use yaserde::{YaDeserialize, YaSerialize};
+
+#[test]
+fn ser_type() {
+  test_for_type!(String, "test".to_string(), Some("test"));
+  test_for_type!(bool, true, Some("true"));
+  test_for_type!(u8, 12 as u8, Some("12"));
+  test_for_type!(i8, 12 as i8, Some("12"));
+  test_for_type!(i8, -12 as i8, Some("-12"));
+  test_for_type!(u16, 12 as u16, Some("12"));
+  test_for_type!(i16, 12 as i16, Some("12"));
+  test_for_type!(i16, -12 as i16, Some("-12"));
+  test_for_type!(u32, 12 as u32, Some("12"));
+  test_for_type!(i32, 12 as i32, Some("12"));
+  test_for_type!(i32, -12 as i32, Some("-12"));
+  test_for_type!(u64, 12 as u64, Some("12"));
+  test_for_type!(i64, 12 as i64, Some("12"));
+  test_for_type!(i64, -12 as i64, Some("-12"));
+  test_for_type!(f32, -12.5 as f32, Some("-12.5"));
+  test_for_type!(f64, -12.5 as f64, Some("-12.5"));
+  test_for_type!(Vec::<String>, vec![], None);
+  test_for_type!(Vec::<String>, vec!["test".to_string()], Some("test"));
+
+  test_for_attribute_type!(String, "test".to_string(), Some("test"));
+  test_for_attribute_type!(bool, true, Some("true"));
+  test_for_attribute_type!(u8, 12 as u8, Some("12"));
+  test_for_attribute_type!(i8, 12 as i8, Some("12"));
+  test_for_attribute_type!(i8, -12 as i8, Some("-12"));
+  test_for_attribute_type!(u16, 12 as u16, Some("12"));
+  test_for_attribute_type!(i16, 12 as i16, Some("12"));
+  test_for_attribute_type!(i16, -12 as i16, Some("-12"));
+  test_for_attribute_type!(u32, 12 as u32, Some("12"));
+  test_for_attribute_type!(i32, 12 as i32, Some("12"));
+  test_for_attribute_type!(i32, -12 as i32, Some("-12"));
+  test_for_attribute_type!(u64, 12 as u64, Some("12"));
+  test_for_attribute_type!(i64, 12 as i64, Some("12"));
+  test_for_attribute_type!(i64, -12 as i64, Some("-12"));
+  test_for_attribute_type!(f32, -12.5 as f32, Some("-12.5"));
+  test_for_attribute_type!(f64, -12.5 as f64, Some("-12.5"));
+}