From 3295ae59fa4f18127dd09c0ed4769bae6b35c4b2 Mon Sep 17 00:00:00 2001
From: Mingun <Alexander_Sergey@mail.ru>
Date: Sat, 27 Aug 2022 23:22:18 +0500
Subject: [PATCH 01/11] Move tests of internal API to corresponding file

---
 src/se/mod.rs | 17 -----------------
 src/se/var.rs | 27 +++++++++++++++++++++++++++
 2 files changed, 27 insertions(+), 17 deletions(-)

diff --git a/src/se/mod.rs b/src/se/mod.rs
index eab194ba..d5417914 100644
--- a/src/se/mod.rs
+++ b/src/se/mod.rs
@@ -334,7 +334,6 @@ impl<'r, 'w, W: Write> ser::Serializer for &'w mut Serializer<'r, W> {
 mod tests {
     use super::*;
     use pretty_assertions::assert_eq;
-    use serde::ser::SerializeMap;
     use serde::{Serialize, Serializer as SerSerializer};
 
     #[test]
@@ -414,22 +413,6 @@ mod tests {
         assert_eq!(got, should_be);
     }
 
-    #[test]
-    fn test_serialize_map_entries() {
-        let should_be = "<name>Bob</name><age>5</age>";
-        let mut buffer = Vec::new();
-
-        {
-            let mut ser = Serializer::new(&mut buffer);
-            let mut map = Map::new(&mut ser);
-            map.serialize_entry("name", "Bob").unwrap();
-            map.serialize_entry("age", "5").unwrap();
-        }
-
-        let got = String::from_utf8(buffer).unwrap();
-        assert_eq!(got, should_be);
-    }
-
     #[test]
     fn test_serialize_enum() {
         #[derive(Serialize)]
diff --git a/src/se/var.rs b/src/se/var.rs
index c8e062eb..76e09a56 100644
--- a/src/se/var.rs
+++ b/src/se/var.rs
@@ -79,6 +79,8 @@ where
     }
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 /// An implementation of `SerializeStruct` for serializing to XML.
 pub struct Struct<'r, 'w, W>
 where
@@ -185,6 +187,8 @@ where
     }
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 /// An implementation of `SerializeSeq' for serializing to XML.
 pub struct Seq<'r, 'w, W>
 where
@@ -223,6 +227,8 @@ where
     }
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 /// An implementation of `SerializeTuple`, `SerializeTupleStruct` and
 /// `SerializeTupleVariant` for serializing to XML.
 pub struct Tuple<'r, 'w, W>
@@ -308,3 +314,24 @@ where
         <Self as ser::SerializeTuple>::end(self)
     }
 }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#[test]
+fn test_serialize_map_entries() {
+    use serde::ser::SerializeMap;
+
+    let mut buffer = Vec::new();
+
+    {
+        let mut ser = Serializer::new(&mut buffer);
+        let mut map = Map::new(&mut ser);
+        map.serialize_entry("name", "Bob").unwrap();
+        map.serialize_entry("age", "5").unwrap();
+    }
+
+    assert_eq!(
+        String::from_utf8(buffer).unwrap(),
+        "<name>Bob</name><age>5</age>"
+    );
+}

From d3184198b9930a0612dcc35ecb0a43e1081bdfca Mon Sep 17 00:00:00 2001
From: Mingun <Alexander_Sergey@mail.ru>
Date: Sat, 27 Aug 2022 23:28:57 +0500
Subject: [PATCH 02/11] Move integration serde serializer tests to the
 integration tests directory

---
 Cargo.toml        |   4 +
 src/se/mod.rs     | 853 ----------------------------------------------
 tests/serde-se.rs | 852 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 856 insertions(+), 853 deletions(-)
 create mode 100644 tests/serde-se.rs

diff --git a/Cargo.toml b/Cargo.toml
index 48d71687..204eca20 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -186,6 +186,10 @@ required-features = ["serialize"]
 name = "serde-de"
 required-features = ["serialize"]
 
+[[test]]
+name = "serde-se"
+required-features = ["serialize"]
+
 [[test]]
 name = "serde-migrated"
 required-features = ["serialize"]
diff --git a/src/se/mod.rs b/src/se/mod.rs
index d5417914..df7556c7 100644
--- a/src/se/mod.rs
+++ b/src/se/mod.rs
@@ -329,856 +329,3 @@ impl<'r, 'w, W: Write> ser::Serializer for &'w mut Serializer<'r, W> {
         Ok(Struct::new(self, variant))
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use pretty_assertions::assert_eq;
-    use serde::{Serialize, Serializer as SerSerializer};
-
-    #[test]
-    fn test_serialize_bool() {
-        let inputs = vec![(true, "true"), (false, "false")];
-
-        for (src, should_be) in inputs {
-            let mut buffer = Vec::new();
-
-            {
-                let mut ser = Serializer::new(&mut buffer);
-                ser.serialize_bool(src).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
-        }
-    }
-
-    #[test]
-    fn test_serialize_struct() {
-        #[derive(Serialize)]
-        struct Person {
-            name: String,
-            age: u32,
-        }
-
-        let bob = Person {
-            name: "Bob".to_string(),
-            age: 42,
-        };
-        let should_be = "<Person name=\"Bob\" age=\"42\"/>";
-        let mut buffer = Vec::new();
-
-        {
-            let mut ser = Serializer::new(&mut buffer);
-            bob.serialize(&mut ser).unwrap();
-        }
-
-        let got = String::from_utf8(buffer).unwrap();
-        assert_eq!(got, should_be);
-    }
-
-    #[test]
-    fn test_serialize_struct_value_number() {
-        #[derive(Serialize)]
-        struct Person {
-            name: String,
-            #[serde(rename = "$value")]
-            age: u32,
-        }
-
-        let bob = Person {
-            name: "Bob".to_string(),
-            age: 42,
-        };
-        let should_be = "<Person name=\"Bob\">42</Person>";
-        let got = to_string(&bob).unwrap();
-        assert_eq!(got, should_be);
-    }
-
-    #[test]
-    fn test_serialize_struct_value_string() {
-        #[derive(Serialize)]
-        struct Person {
-            name: String,
-            #[serde(rename = "$value")]
-            age: String,
-        }
-
-        let bob = Person {
-            name: "Bob".to_string(),
-            age: "42".to_string(),
-        };
-        let should_be = "<Person name=\"Bob\">42</Person>";
-        let got = to_string(&bob).unwrap();
-        assert_eq!(got, should_be);
-    }
-
-    #[test]
-    fn test_serialize_enum() {
-        #[derive(Serialize)]
-        #[allow(dead_code)]
-        enum Node {
-            Boolean(bool),
-            Number(f64),
-            String(String),
-        }
-
-        let mut buffer = Vec::new();
-        let should_be = "<Boolean>true</Boolean>";
-
-        {
-            let mut ser = Serializer::new(&mut buffer);
-            let node = Node::Boolean(true);
-            node.serialize(&mut ser).unwrap();
-        }
-
-        let got = String::from_utf8(buffer).unwrap();
-        assert_eq!(got, should_be);
-    }
-
-    #[test]
-    #[ignore]
-    fn serialize_a_list() {
-        let inputs = vec![1, 2, 3, 4];
-
-        let mut buffer = Vec::new();
-
-        {
-            let mut ser = Serializer::new(&mut buffer);
-            inputs.serialize(&mut ser).unwrap();
-        }
-
-        let got = String::from_utf8(buffer).unwrap();
-        println!("{}", got);
-        panic!();
-    }
-
-    #[test]
-    fn unit() {
-        #[derive(Serialize)]
-        struct Unit;
-
-        let data = Unit;
-        let should_be = "<root/>";
-        let mut buffer = Vec::new();
-
-        {
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-            data.serialize(&mut ser).unwrap();
-        }
-
-        let got = String::from_utf8(buffer).unwrap();
-        assert_eq!(got, should_be);
-    }
-
-    #[test]
-    fn newtype() {
-        #[derive(Serialize)]
-        struct Newtype(bool);
-
-        let data = Newtype(true);
-        let should_be = "<root>true</root>";
-        let mut buffer = Vec::new();
-
-        {
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-            data.serialize(&mut ser).unwrap();
-        }
-
-        let got = String::from_utf8(buffer).unwrap();
-        assert_eq!(got, should_be);
-    }
-
-    #[test]
-    fn tuple() {
-        let data = (42.0, "answer");
-        let should_be = "<root>42</root><root>answer</root>";
-        let mut buffer = Vec::new();
-
-        {
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
-            data.serialize(&mut ser).unwrap();
-        }
-
-        let got = String::from_utf8(buffer).unwrap();
-        assert_eq!(got, should_be);
-    }
-
-    #[test]
-    fn tuple_struct() {
-        #[derive(Serialize)]
-        struct Tuple(f32, &'static str);
-
-        let data = Tuple(42.0, "answer");
-        let should_be = "<root>42</root><root>answer</root>";
-        let mut buffer = Vec::new();
-
-        {
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
-            data.serialize(&mut ser).unwrap();
-        }
-
-        let got = String::from_utf8(buffer).unwrap();
-        assert_eq!(got, should_be);
-    }
-
-    #[test]
-    fn struct_() {
-        #[derive(Serialize)]
-        struct Struct {
-            float: f64,
-            string: String,
-        }
-
-        let mut buffer = Vec::new();
-        let should_be = r#"<root float="42" string="answer"/>"#;
-
-        {
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
-            let node = Struct {
-                float: 42.0,
-                string: "answer".to_string(),
-            };
-            node.serialize(&mut ser).unwrap();
-        }
-
-        let got = String::from_utf8(buffer).unwrap();
-        assert_eq!(got, should_be);
-    }
-
-    #[test]
-    fn nested_struct() {
-        #[derive(Serialize)]
-        struct Struct {
-            nested: Nested,
-            string: String,
-        }
-
-        #[derive(Serialize)]
-        struct Nested {
-            float: f64,
-        }
-
-        let mut buffer = Vec::new();
-        let should_be = r#"<root string="answer"><nested float="42"/>
-</root>"#;
-
-        {
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
-            let node = Struct {
-                nested: Nested { float: 42.0 },
-                string: "answer".to_string(),
-            };
-            node.serialize(&mut ser).unwrap();
-        }
-
-        let got = String::from_utf8(buffer).unwrap();
-        assert_eq!(got, should_be);
-    }
-
-    #[test]
-    fn flatten_struct() {
-        #[derive(Serialize)]
-        struct Struct {
-            #[serde(flatten)]
-            nested: Nested,
-            string: String,
-        }
-
-        #[derive(Serialize)]
-        struct Nested {
-            float: f64,
-        }
-
-        let mut buffer = Vec::new();
-        let should_be = r#"<root><float>42</float><string>answer</string></root>"#;
-
-        {
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
-            let node = Struct {
-                nested: Nested { float: 42.0 },
-                string: "answer".to_string(),
-            };
-            node.serialize(&mut ser).unwrap();
-        }
-
-        let got = String::from_utf8(buffer).unwrap();
-        assert_eq!(got, should_be);
-    }
-
-    mod enum_ {
-        use super::*;
-
-        #[derive(Serialize)]
-        struct Nested {
-            float: f64,
-        }
-
-        mod externally_tagged {
-            use super::*;
-            use pretty_assertions::assert_eq;
-
-            #[derive(Serialize)]
-            enum Node {
-                Unit,
-                #[serde(rename = "$primitive=PrimitiveUnit")]
-                PrimitiveUnit,
-                Newtype(bool),
-                Tuple(f64, String),
-                Struct {
-                    float: f64,
-                    string: String,
-                },
-                Holder {
-                    nested: Nested,
-                    string: String,
-                },
-                Flatten {
-                    #[serde(flatten)]
-                    nested: Nested,
-                    string: String,
-                },
-            }
-
-            #[test]
-            fn unit() {
-                let mut buffer = Vec::new();
-                let should_be = "<Unit/>";
-
-                {
-                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                    let node = Node::Unit;
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn primitive_unit() {
-                let mut buffer = Vec::new();
-                let should_be = "PrimitiveUnit";
-
-                {
-                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                    let node = Node::PrimitiveUnit;
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn newtype() {
-                let mut buffer = Vec::new();
-                let should_be = "<Newtype>true</Newtype>";
-
-                {
-                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                    let node = Node::Newtype(true);
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn struct_() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<Struct float="42" string="answer"/>"#;
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Struct {
-                        float: 42.0,
-                        string: "answer".to_string(),
-                    };
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn tuple_struct() {
-                let mut buffer = Vec::new();
-                let should_be = "<Tuple>42</Tuple><Tuple>answer</Tuple>";
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Tuple(42.0, "answer".to_string());
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn nested_struct() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<Holder string="answer"><nested float="42"/>
-</Holder>"#;
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Holder {
-                        nested: Nested { float: 42.0 },
-                        string: "answer".to_string(),
-                    };
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn flatten_struct() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<Flatten><float>42</float><string>answer</string></Flatten>"#;
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Flatten {
-                        nested: Nested { float: 42.0 },
-                        string: "answer".to_string(),
-                    };
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-        }
-
-        mod internally_tagged {
-            use super::*;
-            use pretty_assertions::assert_eq;
-
-            #[derive(Serialize)]
-            #[serde(tag = "tag")]
-            enum Node {
-                Unit,
-                /// Primitives (such as `bool`) are not supported by the serde in the internally tagged mode
-                Newtype(NewtypeContent),
-                // Tuple(f64, String),// Tuples are not supported in the internally tagged mode
-                Struct {
-                    float: f64,
-                    string: String,
-                },
-                Holder {
-                    nested: Nested,
-                    string: String,
-                },
-                Flatten {
-                    #[serde(flatten)]
-                    nested: Nested,
-                    string: String,
-                },
-            }
-
-            #[derive(Serialize)]
-            struct NewtypeContent {
-                value: bool,
-            }
-
-            #[test]
-            fn unit() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<root tag="Unit"/>"#;
-
-                {
-                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                    let node = Node::Unit;
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn newtype() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<root tag="Newtype" value="true"/>"#;
-
-                {
-                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                    let node = Node::Newtype(NewtypeContent { value: true });
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn struct_() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<root tag="Struct" float="42" string="answer"/>"#;
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Struct {
-                        float: 42.0,
-                        string: "answer".to_string(),
-                    };
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn nested_struct() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<root tag="Holder" string="answer"><nested float="42"/>
-</root>"#;
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Holder {
-                        nested: Nested { float: 42.0 },
-                        string: "answer".to_string(),
-                    };
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn flatten_struct() {
-                let mut buffer = Vec::new();
-                let should_be =
-                    r#"<root><tag>Flatten</tag><float>42</float><string>answer</string></root>"#;
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Flatten {
-                        nested: Nested { float: 42.0 },
-                        string: "answer".to_string(),
-                    };
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-        }
-
-        mod adjacently_tagged {
-            use super::*;
-            use pretty_assertions::assert_eq;
-
-            #[derive(Serialize)]
-            #[serde(tag = "tag", content = "content")]
-            enum Node {
-                Unit,
-                Newtype(bool),
-                Tuple(f64, String),
-                Struct {
-                    float: f64,
-                    string: String,
-                },
-                Holder {
-                    nested: Nested,
-                    string: String,
-                },
-                Flatten {
-                    #[serde(flatten)]
-                    nested: Nested,
-                    string: String,
-                },
-            }
-
-            #[test]
-            fn unit() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<root tag="Unit"/>"#;
-
-                {
-                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                    let node = Node::Unit;
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn newtype() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<root tag="Newtype" content="true"/>"#;
-
-                {
-                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                    let node = Node::Newtype(true);
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn tuple_struct() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<root tag="Tuple"><content>42</content><content>answer</content>
-</root>"#;
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Tuple(42.0, "answer".to_string());
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn struct_() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<root tag="Struct"><content float="42" string="answer"/>
-</root>"#;
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Struct {
-                        float: 42.0,
-                        string: "answer".to_string(),
-                    };
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn nested_struct() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<root tag="Holder"><content string="answer"><nested float="42"/></content>
-</root>"#;
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Holder {
-                        nested: Nested { float: 42.0 },
-                        string: "answer".to_string(),
-                    };
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn flatten_struct() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<root tag="Flatten"><content><float>42</float><string>answer</string></content>
-</root>"#;
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Flatten {
-                        nested: Nested { float: 42.0 },
-                        string: "answer".to_string(),
-                    };
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-        }
-
-        mod untagged {
-            use super::*;
-            use pretty_assertions::assert_eq;
-
-            #[derive(Serialize)]
-            #[serde(untagged)]
-            enum Node {
-                Unit,
-                Newtype(bool),
-                Tuple(f64, String),
-                Struct {
-                    float: f64,
-                    string: String,
-                },
-                Holder {
-                    nested: Nested,
-                    string: String,
-                },
-                Flatten {
-                    #[serde(flatten)]
-                    nested: Nested,
-                    string: String,
-                },
-            }
-
-            #[test]
-            fn unit() {
-                let mut buffer = Vec::new();
-                // Unit variant consists just from the tag, and because tags
-                // are not written in untagged mode, nothing is written
-                let should_be = "";
-
-                {
-                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                    let node = Node::Unit;
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn newtype() {
-                let mut buffer = Vec::new();
-                let should_be = "true";
-
-                {
-                    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                    let node = Node::Newtype(true);
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn tuple_struct() {
-                let mut buffer = Vec::new();
-                let should_be = "<root>42</root><root>answer</root>";
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Tuple(42.0, "answer".to_string());
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn struct_() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<root float="42" string="answer"/>"#;
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Struct {
-                        float: 42.0,
-                        string: "answer".to_string(),
-                    };
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn nested_struct() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<root string="answer"><nested float="42"/>
-</root>"#;
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Holder {
-                        nested: Nested { float: 42.0 },
-                        string: "answer".to_string(),
-                    };
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-
-            #[test]
-            fn flatten_struct() {
-                let mut buffer = Vec::new();
-                let should_be = r#"<root><float>42</float><string>answer</string></root>"#;
-
-                {
-                    let mut ser = Serializer::with_root(
-                        Writer::new_with_indent(&mut buffer, b' ', 4),
-                        Some("root"),
-                    );
-                    let node = Node::Flatten {
-                        nested: Nested { float: 42.0 },
-                        string: "answer".to_string(),
-                    };
-                    node.serialize(&mut ser).unwrap();
-                }
-
-                let got = String::from_utf8(buffer).unwrap();
-                assert_eq!(got, should_be);
-            }
-        }
-    }
-}
diff --git a/tests/serde-se.rs b/tests/serde-se.rs
new file mode 100644
index 00000000..1cc4c71f
--- /dev/null
+++ b/tests/serde-se.rs
@@ -0,0 +1,852 @@
+use quick_xml::se::{to_string, Serializer};
+use quick_xml::writer::Writer;
+
+use pretty_assertions::assert_eq;
+
+use serde::{Serialize, Serializer as SerSerializer};
+
+#[test]
+fn serialize_bool() {
+    let inputs = [(true, "true"), (false, "false")];
+
+    for (src, should_be) in &inputs {
+        let mut buffer = Vec::new();
+
+        {
+            let mut ser = Serializer::new(&mut buffer);
+            ser.serialize_bool(*src).unwrap();
+        }
+
+        let got = String::from_utf8(buffer).unwrap();
+        assert_eq!(got, *should_be);
+    }
+}
+
+#[test]
+fn serialize_struct() {
+    #[derive(Serialize)]
+    struct Person {
+        name: String,
+        age: u32,
+    }
+
+    let bob = Person {
+        name: "Bob".to_string(),
+        age: 42,
+    };
+    let should_be = "<Person name=\"Bob\" age=\"42\"/>";
+    let mut buffer = Vec::new();
+
+    {
+        let mut ser = Serializer::new(&mut buffer);
+        bob.serialize(&mut ser).unwrap();
+    }
+
+    let got = String::from_utf8(buffer).unwrap();
+    assert_eq!(got, should_be);
+}
+
+#[test]
+fn serialize_struct_value_number() {
+    #[derive(Serialize)]
+    struct Person {
+        name: String,
+        #[serde(rename = "$value")]
+        age: u32,
+    }
+
+    let bob = Person {
+        name: "Bob".to_string(),
+        age: 42,
+    };
+    let should_be = "<Person name=\"Bob\">42</Person>";
+    let got = to_string(&bob).unwrap();
+    assert_eq!(got, should_be);
+}
+
+#[test]
+fn serialize_struct_value_string() {
+    #[derive(Serialize)]
+    struct Person {
+        name: String,
+        #[serde(rename = "$value")]
+        age: String,
+    }
+
+    let bob = Person {
+        name: "Bob".to_string(),
+        age: "42".to_string(),
+    };
+    let should_be = "<Person name=\"Bob\">42</Person>";
+    let got = to_string(&bob).unwrap();
+    assert_eq!(got, should_be);
+}
+
+#[test]
+fn serialize_enum() {
+    #[derive(Serialize)]
+    #[allow(dead_code)]
+    enum Node {
+        Boolean(bool),
+        Number(f64),
+        String(String),
+    }
+
+    let mut buffer = Vec::new();
+    let should_be = "<Boolean>true</Boolean>";
+
+    {
+        let mut ser = Serializer::new(&mut buffer);
+        let node = Node::Boolean(true);
+        node.serialize(&mut ser).unwrap();
+    }
+
+    let got = String::from_utf8(buffer).unwrap();
+    assert_eq!(got, should_be);
+}
+
+#[test]
+#[ignore]
+fn serialize_a_list() {
+    let inputs = vec![1, 2, 3, 4];
+
+    let mut buffer = Vec::new();
+
+    {
+        let mut ser = Serializer::new(&mut buffer);
+        inputs.serialize(&mut ser).unwrap();
+    }
+
+    let got = String::from_utf8(buffer).unwrap();
+    println!("{}", got);
+    panic!();
+}
+
+#[test]
+fn unit() {
+    #[derive(Serialize)]
+    struct Unit;
+
+    let data = Unit;
+    let should_be = "<root/>";
+    let mut buffer = Vec::new();
+
+    {
+        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+        data.serialize(&mut ser).unwrap();
+    }
+
+    let got = String::from_utf8(buffer).unwrap();
+    assert_eq!(got, should_be);
+}
+
+#[test]
+fn newtype() {
+    #[derive(Serialize)]
+    struct Newtype(bool);
+
+    let data = Newtype(true);
+    let should_be = "<root>true</root>";
+    let mut buffer = Vec::new();
+
+    {
+        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+        data.serialize(&mut ser).unwrap();
+    }
+
+    let got = String::from_utf8(buffer).unwrap();
+    assert_eq!(got, should_be);
+}
+
+#[test]
+fn tuple() {
+    let data = (42.0, "answer");
+    let should_be = "<root>42</root><root>answer</root>";
+    let mut buffer = Vec::new();
+
+    {
+        let mut ser =
+            Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+        data.serialize(&mut ser).unwrap();
+    }
+
+    let got = String::from_utf8(buffer).unwrap();
+    assert_eq!(got, should_be);
+}
+
+#[test]
+fn tuple_struct() {
+    #[derive(Serialize)]
+    struct Tuple(f32, &'static str);
+
+    let data = Tuple(42.0, "answer");
+    let should_be = "<root>42</root><root>answer</root>";
+    let mut buffer = Vec::new();
+
+    {
+        let mut ser =
+            Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+        data.serialize(&mut ser).unwrap();
+    }
+
+    let got = String::from_utf8(buffer).unwrap();
+    assert_eq!(got, should_be);
+}
+
+#[test]
+fn struct_() {
+    #[derive(Serialize)]
+    struct Struct {
+        float: f64,
+        string: String,
+    }
+
+    let mut buffer = Vec::new();
+    let should_be = r#"<root float="42" string="answer"/>"#;
+
+    {
+        let mut ser =
+            Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+        let node = Struct {
+            float: 42.0,
+            string: "answer".to_string(),
+        };
+        node.serialize(&mut ser).unwrap();
+    }
+
+    let got = String::from_utf8(buffer).unwrap();
+    assert_eq!(got, should_be);
+}
+
+#[test]
+fn nested_struct() {
+    #[derive(Serialize)]
+    struct Struct {
+        nested: Nested,
+        string: String,
+    }
+
+    #[derive(Serialize)]
+    struct Nested {
+        float: f64,
+    }
+
+    let mut buffer = Vec::new();
+    let should_be = r#"<root string="answer"><nested float="42"/>
+</root>"#;
+
+    {
+        let mut ser =
+            Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+        let node = Struct {
+            nested: Nested { float: 42.0 },
+            string: "answer".to_string(),
+        };
+        node.serialize(&mut ser).unwrap();
+    }
+
+    let got = String::from_utf8(buffer).unwrap();
+    assert_eq!(got, should_be);
+}
+
+#[test]
+fn flatten_struct() {
+    #[derive(Serialize)]
+    struct Struct {
+        #[serde(flatten)]
+        nested: Nested,
+        string: String,
+    }
+
+    #[derive(Serialize)]
+    struct Nested {
+        float: f64,
+    }
+
+    let mut buffer = Vec::new();
+    let should_be = r#"<root><float>42</float><string>answer</string></root>"#;
+
+    {
+        let mut ser =
+            Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+        let node = Struct {
+            nested: Nested { float: 42.0 },
+            string: "answer".to_string(),
+        };
+        node.serialize(&mut ser).unwrap();
+    }
+
+    let got = String::from_utf8(buffer).unwrap();
+    assert_eq!(got, should_be);
+}
+
+mod enum_ {
+    use super::*;
+
+    #[derive(Serialize)]
+    struct Nested {
+        float: f64,
+    }
+
+    mod externally_tagged {
+        use super::*;
+        use pretty_assertions::assert_eq;
+
+        #[derive(Serialize)]
+        enum Node {
+            Unit,
+            #[serde(rename = "$primitive=PrimitiveUnit")]
+            PrimitiveUnit,
+            Newtype(bool),
+            Tuple(f64, String),
+            Struct {
+                float: f64,
+                string: String,
+            },
+            Holder {
+                nested: Nested,
+                string: String,
+            },
+            Flatten {
+                #[serde(flatten)]
+                nested: Nested,
+                string: String,
+            },
+        }
+
+        #[test]
+        fn unit() {
+            let mut buffer = Vec::new();
+            let should_be = "<Unit/>";
+
+            {
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+                let node = Node::Unit;
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn primitive_unit() {
+            let mut buffer = Vec::new();
+            let should_be = "PrimitiveUnit";
+
+            {
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+                let node = Node::PrimitiveUnit;
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn newtype() {
+            let mut buffer = Vec::new();
+            let should_be = "<Newtype>true</Newtype>";
+
+            {
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+                let node = Node::Newtype(true);
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn struct_() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<Struct float="42" string="answer"/>"#;
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Struct {
+                    float: 42.0,
+                    string: "answer".to_string(),
+                };
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn tuple_struct() {
+            let mut buffer = Vec::new();
+            let should_be = "<Tuple>42</Tuple><Tuple>answer</Tuple>";
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Tuple(42.0, "answer".to_string());
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn nested_struct() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<Holder string="answer"><nested float="42"/>
+</Holder>"#;
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Holder {
+                    nested: Nested { float: 42.0 },
+                    string: "answer".to_string(),
+                };
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn flatten_struct() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<Flatten><float>42</float><string>answer</string></Flatten>"#;
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Flatten {
+                    nested: Nested { float: 42.0 },
+                    string: "answer".to_string(),
+                };
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+    }
+
+    mod internally_tagged {
+        use super::*;
+        use pretty_assertions::assert_eq;
+
+        #[derive(Serialize)]
+        #[serde(tag = "tag")]
+        enum Node {
+            Unit,
+            /// Primitives (such as `bool`) are not supported by the serde in the internally tagged mode
+            Newtype(NewtypeContent),
+            // Tuple(f64, String),// Tuples are not supported in the internally tagged mode
+            Struct {
+                float: f64,
+                string: String,
+            },
+            Holder {
+                nested: Nested,
+                string: String,
+            },
+            Flatten {
+                #[serde(flatten)]
+                nested: Nested,
+                string: String,
+            },
+        }
+
+        #[derive(Serialize)]
+        struct NewtypeContent {
+            value: bool,
+        }
+
+        #[test]
+        fn unit() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<root tag="Unit"/>"#;
+
+            {
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+                let node = Node::Unit;
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn newtype() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<root tag="Newtype" value="true"/>"#;
+
+            {
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+                let node = Node::Newtype(NewtypeContent { value: true });
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn struct_() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<root tag="Struct" float="42" string="answer"/>"#;
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Struct {
+                    float: 42.0,
+                    string: "answer".to_string(),
+                };
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn nested_struct() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<root tag="Holder" string="answer"><nested float="42"/>
+</root>"#;
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Holder {
+                    nested: Nested { float: 42.0 },
+                    string: "answer".to_string(),
+                };
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn flatten_struct() {
+            let mut buffer = Vec::new();
+            let should_be =
+                r#"<root><tag>Flatten</tag><float>42</float><string>answer</string></root>"#;
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Flatten {
+                    nested: Nested { float: 42.0 },
+                    string: "answer".to_string(),
+                };
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+    }
+
+    mod adjacently_tagged {
+        use super::*;
+        use pretty_assertions::assert_eq;
+
+        #[derive(Serialize)]
+        #[serde(tag = "tag", content = "content")]
+        enum Node {
+            Unit,
+            Newtype(bool),
+            Tuple(f64, String),
+            Struct {
+                float: f64,
+                string: String,
+            },
+            Holder {
+                nested: Nested,
+                string: String,
+            },
+            Flatten {
+                #[serde(flatten)]
+                nested: Nested,
+                string: String,
+            },
+        }
+
+        #[test]
+        fn unit() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<root tag="Unit"/>"#;
+
+            {
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+                let node = Node::Unit;
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn newtype() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<root tag="Newtype" content="true"/>"#;
+
+            {
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+                let node = Node::Newtype(true);
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn tuple_struct() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<root tag="Tuple"><content>42</content><content>answer</content>
+</root>"#;
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Tuple(42.0, "answer".to_string());
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn struct_() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<root tag="Struct"><content float="42" string="answer"/>
+</root>"#;
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Struct {
+                    float: 42.0,
+                    string: "answer".to_string(),
+                };
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn nested_struct() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<root tag="Holder"><content string="answer"><nested float="42"/></content>
+</root>"#;
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Holder {
+                    nested: Nested { float: 42.0 },
+                    string: "answer".to_string(),
+                };
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn flatten_struct() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<root tag="Flatten"><content><float>42</float><string>answer</string></content>
+</root>"#;
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Flatten {
+                    nested: Nested { float: 42.0 },
+                    string: "answer".to_string(),
+                };
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+    }
+
+    mod untagged {
+        use super::*;
+        use pretty_assertions::assert_eq;
+
+        #[derive(Serialize)]
+        #[serde(untagged)]
+        enum Node {
+            Unit,
+            Newtype(bool),
+            Tuple(f64, String),
+            Struct {
+                float: f64,
+                string: String,
+            },
+            Holder {
+                nested: Nested,
+                string: String,
+            },
+            Flatten {
+                #[serde(flatten)]
+                nested: Nested,
+                string: String,
+            },
+        }
+
+        #[test]
+        fn unit() {
+            let mut buffer = Vec::new();
+            // Unit variant consists just from the tag, and because tags
+            // are not written in untagged mode, nothing is written
+            let should_be = "";
+
+            {
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+                let node = Node::Unit;
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn newtype() {
+            let mut buffer = Vec::new();
+            let should_be = "true";
+
+            {
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+                let node = Node::Newtype(true);
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn tuple_struct() {
+            let mut buffer = Vec::new();
+            let should_be = "<root>42</root><root>answer</root>";
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Tuple(42.0, "answer".to_string());
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn struct_() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<root float="42" string="answer"/>"#;
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Struct {
+                    float: 42.0,
+                    string: "answer".to_string(),
+                };
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn nested_struct() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<root string="answer"><nested float="42"/>
+</root>"#;
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Holder {
+                    nested: Nested { float: 42.0 },
+                    string: "answer".to_string(),
+                };
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+
+        #[test]
+        fn flatten_struct() {
+            let mut buffer = Vec::new();
+            let should_be = r#"<root><float>42</float><string>answer</string></root>"#;
+
+            {
+                let mut ser = Serializer::with_root(
+                    Writer::new_with_indent(&mut buffer, b' ', 4),
+                    Some("root"),
+                );
+                let node = Node::Flatten {
+                    nested: Nested { float: 42.0 },
+                    string: "answer".to_string(),
+                };
+                node.serialize(&mut ser).unwrap();
+            }
+
+            let got = String::from_utf8(buffer).unwrap();
+            assert_eq!(got, should_be);
+        }
+    }
+}

From 97a6be5083270cf204544da066b49d3110f69862 Mon Sep 17 00:00:00 2001
From: Mingun <alexander_sergey@mail.ru>
Date: Wed, 31 Aug 2022 18:29:43 +0500
Subject: [PATCH 03/11] Reformat tests to be more idiomatic

---
 tests/serde-se.rs | 748 +++++++++++++++++++---------------------------
 1 file changed, 308 insertions(+), 440 deletions(-)

diff --git a/tests/serde-se.rs b/tests/serde-se.rs
index 1cc4c71f..2da51236 100644
--- a/tests/serde-se.rs
+++ b/tests/serde-se.rs
@@ -11,14 +11,10 @@ fn serialize_bool() {
 
     for (src, should_be) in &inputs {
         let mut buffer = Vec::new();
+        let mut ser = Serializer::new(&mut buffer);
+        ser.serialize_bool(*src).unwrap();
 
-        {
-            let mut ser = Serializer::new(&mut buffer);
-            ser.serialize_bool(*src).unwrap();
-        }
-
-        let got = String::from_utf8(buffer).unwrap();
-        assert_eq!(got, *should_be);
+        assert_eq!(String::from_utf8(buffer).unwrap(), *should_be);
     }
 }
 
@@ -34,16 +30,15 @@ fn serialize_struct() {
         name: "Bob".to_string(),
         age: 42,
     };
-    let should_be = "<Person name=\"Bob\" age=\"42\"/>";
-    let mut buffer = Vec::new();
 
-    {
-        let mut ser = Serializer::new(&mut buffer);
-        bob.serialize(&mut ser).unwrap();
-    }
+    let mut buffer = Vec::new();
+    let mut ser = Serializer::new(&mut buffer);
+    bob.serialize(&mut ser).unwrap();
 
-    let got = String::from_utf8(buffer).unwrap();
-    assert_eq!(got, should_be);
+    assert_eq!(
+        String::from_utf8(buffer).unwrap(),
+        "<Person name=\"Bob\" age=\"42\"/>"
+    );
 }
 
 #[test]
@@ -59,9 +54,7 @@ fn serialize_struct_value_number() {
         name: "Bob".to_string(),
         age: 42,
     };
-    let should_be = "<Person name=\"Bob\">42</Person>";
-    let got = to_string(&bob).unwrap();
-    assert_eq!(got, should_be);
+    assert_eq!(to_string(&bob).unwrap(), "<Person name=\"Bob\">42</Person>");
 }
 
 #[test]
@@ -77,9 +70,7 @@ fn serialize_struct_value_string() {
         name: "Bob".to_string(),
         age: "42".to_string(),
     };
-    let should_be = "<Person name=\"Bob\">42</Person>";
-    let got = to_string(&bob).unwrap();
-    assert_eq!(got, should_be);
+    assert_eq!(to_string(&bob).unwrap(), "<Person name=\"Bob\">42</Person>");
 }
 
 #[test]
@@ -93,16 +84,14 @@ fn serialize_enum() {
     }
 
     let mut buffer = Vec::new();
-    let should_be = "<Boolean>true</Boolean>";
-
-    {
-        let mut ser = Serializer::new(&mut buffer);
-        let node = Node::Boolean(true);
-        node.serialize(&mut ser).unwrap();
-    }
-
-    let got = String::from_utf8(buffer).unwrap();
-    assert_eq!(got, should_be);
+    let mut ser = Serializer::new(&mut buffer);
+    let node = Node::Boolean(true);
+    node.serialize(&mut ser).unwrap();
+
+    assert_eq!(
+        String::from_utf8(buffer).unwrap(),
+        "<Boolean>true</Boolean>"
+    );
 }
 
 #[test]
@@ -111,14 +100,10 @@ fn serialize_a_list() {
     let inputs = vec![1, 2, 3, 4];
 
     let mut buffer = Vec::new();
+    let mut ser = Serializer::new(&mut buffer);
+    inputs.serialize(&mut ser).unwrap();
 
-    {
-        let mut ser = Serializer::new(&mut buffer);
-        inputs.serialize(&mut ser).unwrap();
-    }
-
-    let got = String::from_utf8(buffer).unwrap();
-    println!("{}", got);
+    println!("{}", String::from_utf8(buffer).unwrap());
     panic!();
 }
 
@@ -127,17 +112,12 @@ fn unit() {
     #[derive(Serialize)]
     struct Unit;
 
-    let data = Unit;
-    let should_be = "<root/>";
     let mut buffer = Vec::new();
+    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-    {
-        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-        data.serialize(&mut ser).unwrap();
-    }
-
-    let got = String::from_utf8(buffer).unwrap();
-    assert_eq!(got, should_be);
+    let data = Unit;
+    data.serialize(&mut ser).unwrap();
+    assert_eq!(String::from_utf8(buffer).unwrap(), "<root/>");
 }
 
 #[test]
@@ -145,33 +125,26 @@ fn newtype() {
     #[derive(Serialize)]
     struct Newtype(bool);
 
-    let data = Newtype(true);
-    let should_be = "<root>true</root>";
     let mut buffer = Vec::new();
+    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-    {
-        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-        data.serialize(&mut ser).unwrap();
-    }
-
-    let got = String::from_utf8(buffer).unwrap();
-    assert_eq!(got, should_be);
+    let data = Newtype(true);
+    data.serialize(&mut ser).unwrap();
+    assert_eq!(String::from_utf8(buffer).unwrap(), "<root>true</root>");
 }
 
 #[test]
 fn tuple() {
-    let data = (42.0, "answer");
-    let should_be = "<root>42</root><root>answer</root>";
     let mut buffer = Vec::new();
+    let mut ser =
+        Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
 
-    {
-        let mut ser =
-            Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
-        data.serialize(&mut ser).unwrap();
-    }
-
-    let got = String::from_utf8(buffer).unwrap();
-    assert_eq!(got, should_be);
+    let data = (42.0, "answer");
+    data.serialize(&mut ser).unwrap();
+    assert_eq!(
+        String::from_utf8(buffer).unwrap(),
+        "<root>42</root><root>answer</root>"
+    );
 }
 
 #[test]
@@ -179,18 +152,16 @@ fn tuple_struct() {
     #[derive(Serialize)]
     struct Tuple(f32, &'static str);
 
-    let data = Tuple(42.0, "answer");
-    let should_be = "<root>42</root><root>answer</root>";
     let mut buffer = Vec::new();
+    let mut ser =
+        Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
 
-    {
-        let mut ser =
-            Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
-        data.serialize(&mut ser).unwrap();
-    }
-
-    let got = String::from_utf8(buffer).unwrap();
-    assert_eq!(got, should_be);
+    let data = Tuple(42.0, "answer");
+    data.serialize(&mut ser).unwrap();
+    assert_eq!(
+        String::from_utf8(buffer).unwrap(),
+        "<root>42</root><root>answer</root>"
+    );
 }
 
 #[test]
@@ -202,20 +173,18 @@ fn struct_() {
     }
 
     let mut buffer = Vec::new();
-    let should_be = r#"<root float="42" string="answer"/>"#;
-
-    {
-        let mut ser =
-            Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
-        let node = Struct {
-            float: 42.0,
-            string: "answer".to_string(),
-        };
-        node.serialize(&mut ser).unwrap();
-    }
+    let mut ser =
+        Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
 
-    let got = String::from_utf8(buffer).unwrap();
-    assert_eq!(got, should_be);
+    let node = Struct {
+        float: 42.0,
+        string: "answer".to_string(),
+    };
+    node.serialize(&mut ser).unwrap();
+    assert_eq!(
+        String::from_utf8(buffer).unwrap(),
+        r#"<root float="42" string="answer"/>"#
+    );
 }
 
 #[test]
@@ -232,21 +201,19 @@ fn nested_struct() {
     }
 
     let mut buffer = Vec::new();
-    let should_be = r#"<root string="answer"><nested float="42"/>
-</root>"#;
-
-    {
-        let mut ser =
-            Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
-        let node = Struct {
-            nested: Nested { float: 42.0 },
-            string: "answer".to_string(),
-        };
-        node.serialize(&mut ser).unwrap();
-    }
+    let mut ser =
+        Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
 
-    let got = String::from_utf8(buffer).unwrap();
-    assert_eq!(got, should_be);
+    let node = Struct {
+        nested: Nested { float: 42.0 },
+        string: "answer".to_string(),
+    };
+    node.serialize(&mut ser).unwrap();
+    assert_eq!(
+        String::from_utf8(buffer).unwrap(),
+        r#"<root string="answer"><nested float="42"/>
+</root>"#
+    );
 }
 
 #[test]
@@ -264,20 +231,18 @@ fn flatten_struct() {
     }
 
     let mut buffer = Vec::new();
-    let should_be = r#"<root><float>42</float><string>answer</string></root>"#;
-
-    {
-        let mut ser =
-            Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
-        let node = Struct {
-            nested: Nested { float: 42.0 },
-            string: "answer".to_string(),
-        };
-        node.serialize(&mut ser).unwrap();
-    }
+    let mut ser =
+        Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
 
-    let got = String::from_utf8(buffer).unwrap();
-    assert_eq!(got, should_be);
+    let node = Struct {
+        nested: Nested { float: 42.0 },
+        string: "answer".to_string(),
+    };
+    node.serialize(&mut ser).unwrap();
+    assert_eq!(
+        String::from_utf8(buffer).unwrap(),
+        r#"<root><float>42</float><string>answer</string></root>"#
+    );
 }
 
 mod enum_ {
@@ -317,128 +282,100 @@ mod enum_ {
         #[test]
         fn unit() {
             let mut buffer = Vec::new();
-            let should_be = "<Unit/>";
-
-            {
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                let node = Node::Unit;
-                node.serialize(&mut ser).unwrap();
-            }
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let node = Node::Unit;
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(String::from_utf8(buffer).unwrap(), "<Unit/>");
         }
 
         #[test]
         fn primitive_unit() {
             let mut buffer = Vec::new();
-            let should_be = "PrimitiveUnit";
-
-            {
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                let node = Node::PrimitiveUnit;
-                node.serialize(&mut ser).unwrap();
-            }
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let node = Node::PrimitiveUnit;
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(String::from_utf8(buffer).unwrap(), "PrimitiveUnit");
         }
 
         #[test]
         fn newtype() {
             let mut buffer = Vec::new();
-            let should_be = "<Newtype>true</Newtype>";
-
-            {
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                let node = Node::Newtype(true);
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+            let node = Node::Newtype(true);
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                "<Newtype>true</Newtype>"
+            );
         }
 
         #[test]
         fn struct_() {
             let mut buffer = Vec::new();
-            let should_be = r#"<Struct float="42" string="answer"/>"#;
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Struct {
-                    float: 42.0,
-                    string: "answer".to_string(),
-                };
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Struct {
+                float: 42.0,
+                string: "answer".to_string(),
+            };
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<Struct float="42" string="answer"/>"#
+            );
         }
 
         #[test]
         fn tuple_struct() {
             let mut buffer = Vec::new();
-            let should_be = "<Tuple>42</Tuple><Tuple>answer</Tuple>";
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Tuple(42.0, "answer".to_string());
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Tuple(42.0, "answer".to_string());
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                "<Tuple>42</Tuple><Tuple>answer</Tuple>"
+            );
         }
 
         #[test]
         fn nested_struct() {
             let mut buffer = Vec::new();
-            let should_be = r#"<Holder string="answer"><nested float="42"/>
-</Holder>"#;
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Holder {
-                    nested: Nested { float: 42.0 },
-                    string: "answer".to_string(),
-                };
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Holder {
+                nested: Nested { float: 42.0 },
+                string: "answer".to_string(),
+            };
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<Holder string="answer"><nested float="42"/>
+</Holder>"#
+            );
         }
 
         #[test]
         fn flatten_struct() {
             let mut buffer = Vec::new();
-            let should_be = r#"<Flatten><float>42</float><string>answer</string></Flatten>"#;
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Flatten {
-                    nested: Nested { float: 42.0 },
-                    string: "answer".to_string(),
-                };
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Flatten {
+                nested: Nested { float: 42.0 },
+                string: "answer".to_string(),
+            };
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<Flatten><float>42</float><string>answer</string></Flatten>"#
+            );
         }
     }
 
@@ -476,96 +413,76 @@ mod enum_ {
         #[test]
         fn unit() {
             let mut buffer = Vec::new();
-            let should_be = r#"<root tag="Unit"/>"#;
-
-            {
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                let node = Node::Unit;
-                node.serialize(&mut ser).unwrap();
-            }
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let node = Node::Unit;
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(String::from_utf8(buffer).unwrap(), r#"<root tag="Unit"/>"#);
         }
 
         #[test]
         fn newtype() {
             let mut buffer = Vec::new();
-            let should_be = r#"<root tag="Newtype" value="true"/>"#;
-
-            {
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                let node = Node::Newtype(NewtypeContent { value: true });
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+            let node = Node::Newtype(NewtypeContent { value: true });
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<root tag="Newtype" value="true"/>"#
+            );
         }
 
         #[test]
         fn struct_() {
             let mut buffer = Vec::new();
-            let should_be = r#"<root tag="Struct" float="42" string="answer"/>"#;
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Struct {
-                    float: 42.0,
-                    string: "answer".to_string(),
-                };
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Struct {
+                float: 42.0,
+                string: "answer".to_string(),
+            };
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<root tag="Struct" float="42" string="answer"/>"#
+            );
         }
 
         #[test]
         fn nested_struct() {
             let mut buffer = Vec::new();
-            let should_be = r#"<root tag="Holder" string="answer"><nested float="42"/>
-</root>"#;
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Holder {
-                    nested: Nested { float: 42.0 },
-                    string: "answer".to_string(),
-                };
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Holder {
+                nested: Nested { float: 42.0 },
+                string: "answer".to_string(),
+            };
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<root tag="Holder" string="answer"><nested float="42"/>
+</root>"#
+            );
         }
 
         #[test]
         fn flatten_struct() {
             let mut buffer = Vec::new();
-            let should_be =
-                r#"<root><tag>Flatten</tag><float>42</float><string>answer</string></root>"#;
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Flatten {
-                    nested: Nested { float: 42.0 },
-                    string: "answer".to_string(),
-                };
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Flatten {
+                nested: Nested { float: 42.0 },
+                string: "answer".to_string(),
+            };
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<root><tag>Flatten</tag><float>42</float><string>answer</string></root>"#
+            );
         }
     }
 
@@ -597,116 +514,93 @@ mod enum_ {
         #[test]
         fn unit() {
             let mut buffer = Vec::new();
-            let should_be = r#"<root tag="Unit"/>"#;
-
-            {
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                let node = Node::Unit;
-                node.serialize(&mut ser).unwrap();
-            }
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let node = Node::Unit;
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(String::from_utf8(buffer).unwrap(), r#"<root tag="Unit"/>"#);
         }
 
         #[test]
         fn newtype() {
             let mut buffer = Vec::new();
-            let should_be = r#"<root tag="Newtype" content="true"/>"#;
-
-            {
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                let node = Node::Newtype(true);
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+            let node = Node::Newtype(true);
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<root tag="Newtype" content="true"/>"#
+            );
         }
 
         #[test]
         fn tuple_struct() {
             let mut buffer = Vec::new();
-            let should_be = r#"<root tag="Tuple"><content>42</content><content>answer</content>
-</root>"#;
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Tuple(42.0, "answer".to_string());
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Tuple(42.0, "answer".to_string());
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<root tag="Tuple"><content>42</content><content>answer</content>
+</root>"#
+            );
         }
 
         #[test]
         fn struct_() {
             let mut buffer = Vec::new();
-            let should_be = r#"<root tag="Struct"><content float="42" string="answer"/>
-</root>"#;
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Struct {
-                    float: 42.0,
-                    string: "answer".to_string(),
-                };
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Struct {
+                float: 42.0,
+                string: "answer".to_string(),
+            };
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<root tag="Struct"><content float="42" string="answer"/>
+</root>"#
+            );
         }
 
         #[test]
         fn nested_struct() {
             let mut buffer = Vec::new();
-            let should_be = r#"<root tag="Holder"><content string="answer"><nested float="42"/></content>
-</root>"#;
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Holder {
-                    nested: Nested { float: 42.0 },
-                    string: "answer".to_string(),
-                };
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Holder {
+                nested: Nested { float: 42.0 },
+                string: "answer".to_string(),
+            };
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<root tag="Holder"><content string="answer"><nested float="42"/></content>
+</root>"#
+            );
         }
 
         #[test]
         fn flatten_struct() {
             let mut buffer = Vec::new();
-            let should_be = r#"<root tag="Flatten"><content><float>42</float><string>answer</string></content>
-</root>"#;
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Flatten {
-                    nested: Nested { float: 42.0 },
-                    string: "answer".to_string(),
-                };
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Flatten {
+                nested: Nested { float: 42.0 },
+                string: "answer".to_string(),
+            };
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<root tag="Flatten"><content><float>42</float><string>answer</string></content>
+</root>"#
+            );
         }
     }
 
@@ -738,115 +632,89 @@ mod enum_ {
         #[test]
         fn unit() {
             let mut buffer = Vec::new();
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+            let node = Node::Unit;
+            node.serialize(&mut ser).unwrap();
             // Unit variant consists just from the tag, and because tags
             // are not written in untagged mode, nothing is written
-            let should_be = "";
-
-            {
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                let node = Node::Unit;
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            assert_eq!(String::from_utf8(buffer).unwrap(), "");
         }
 
         #[test]
         fn newtype() {
             let mut buffer = Vec::new();
-            let should_be = "true";
-
-            {
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-                let node = Node::Newtype(true);
-                node.serialize(&mut ser).unwrap();
-            }
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let node = Node::Newtype(true);
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(String::from_utf8(buffer).unwrap(), "true");
         }
 
         #[test]
         fn tuple_struct() {
             let mut buffer = Vec::new();
-            let should_be = "<root>42</root><root>answer</root>";
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Tuple(42.0, "answer".to_string());
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Tuple(42.0, "answer".to_string());
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                "<root>42</root><root>answer</root>"
+            );
         }
 
         #[test]
         fn struct_() {
             let mut buffer = Vec::new();
-            let should_be = r#"<root float="42" string="answer"/>"#;
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Struct {
-                    float: 42.0,
-                    string: "answer".to_string(),
-                };
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Struct {
+                float: 42.0,
+                string: "answer".to_string(),
+            };
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<root float="42" string="answer"/>"#
+            );
         }
 
         #[test]
         fn nested_struct() {
             let mut buffer = Vec::new();
-            let should_be = r#"<root string="answer"><nested float="42"/>
-</root>"#;
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Holder {
-                    nested: Nested { float: 42.0 },
-                    string: "answer".to_string(),
-                };
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Holder {
+                nested: Nested { float: 42.0 },
+                string: "answer".to_string(),
+            };
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<root string="answer"><nested float="42"/>
+</root>"#
+            );
         }
 
         #[test]
         fn flatten_struct() {
             let mut buffer = Vec::new();
-            let should_be = r#"<root><float>42</float><string>answer</string></root>"#;
-
-            {
-                let mut ser = Serializer::with_root(
-                    Writer::new_with_indent(&mut buffer, b' ', 4),
-                    Some("root"),
-                );
-                let node = Node::Flatten {
-                    nested: Nested { float: 42.0 },
-                    string: "answer".to_string(),
-                };
-                node.serialize(&mut ser).unwrap();
-            }
-
-            let got = String::from_utf8(buffer).unwrap();
-            assert_eq!(got, should_be);
+            let mut ser =
+                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+
+            let node = Node::Flatten {
+                nested: Nested { float: 42.0 },
+                string: "answer".to_string(),
+            };
+            node.serialize(&mut ser).unwrap();
+            assert_eq!(
+                String::from_utf8(buffer).unwrap(),
+                r#"<root><float>42</float><string>answer</string></root>"#
+            );
         }
     }
 }

From 21dd9f2e889fad2c053e783fd16252a418ce5399 Mon Sep 17 00:00:00 2001
From: Mingun <alexander_sergey@mail.ru>
Date: Wed, 31 Aug 2022 18:58:58 +0500
Subject: [PATCH 04/11] Serialization with indents is broken. Replace these
 tests by no-indents serialization for now

Serialization will reworked soon and new tests will be written
---
 tests/serde-se.rs | 84 ++++++++++++++++-------------------------------
 1 file changed, 28 insertions(+), 56 deletions(-)

diff --git a/tests/serde-se.rs b/tests/serde-se.rs
index 2da51236..f69f0623 100644
--- a/tests/serde-se.rs
+++ b/tests/serde-se.rs
@@ -136,8 +136,7 @@ fn newtype() {
 #[test]
 fn tuple() {
     let mut buffer = Vec::new();
-    let mut ser =
-        Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
     let data = (42.0, "answer");
     data.serialize(&mut ser).unwrap();
@@ -153,8 +152,7 @@ fn tuple_struct() {
     struct Tuple(f32, &'static str);
 
     let mut buffer = Vec::new();
-    let mut ser =
-        Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
     let data = Tuple(42.0, "answer");
     data.serialize(&mut ser).unwrap();
@@ -173,8 +171,7 @@ fn struct_() {
     }
 
     let mut buffer = Vec::new();
-    let mut ser =
-        Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
     let node = Struct {
         float: 42.0,
@@ -201,8 +198,7 @@ fn nested_struct() {
     }
 
     let mut buffer = Vec::new();
-    let mut ser =
-        Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
     let node = Struct {
         nested: Nested { float: 42.0 },
@@ -211,8 +207,7 @@ fn nested_struct() {
     node.serialize(&mut ser).unwrap();
     assert_eq!(
         String::from_utf8(buffer).unwrap(),
-        r#"<root string="answer"><nested float="42"/>
-</root>"#
+        r#"<root string="answer"><nested float="42"/></root>"#
     );
 }
 
@@ -231,8 +226,7 @@ fn flatten_struct() {
     }
 
     let mut buffer = Vec::new();
-    let mut ser =
-        Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
     let node = Struct {
         nested: Nested { float: 42.0 },
@@ -315,8 +309,7 @@ mod enum_ {
         #[test]
         fn struct_() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Struct {
                 float: 42.0,
@@ -332,8 +325,7 @@ mod enum_ {
         #[test]
         fn tuple_struct() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Tuple(42.0, "answer".to_string());
             node.serialize(&mut ser).unwrap();
@@ -346,8 +338,7 @@ mod enum_ {
         #[test]
         fn nested_struct() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Holder {
                 nested: Nested { float: 42.0 },
@@ -356,16 +347,14 @@ mod enum_ {
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
-                r#"<Holder string="answer"><nested float="42"/>
-</Holder>"#
+                r#"<Holder string="answer"><nested float="42"/></Holder>"#
             );
         }
 
         #[test]
         fn flatten_struct() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Flatten {
                 nested: Nested { float: 42.0 },
@@ -436,8 +425,7 @@ mod enum_ {
         #[test]
         fn struct_() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Struct {
                 float: 42.0,
@@ -453,8 +441,7 @@ mod enum_ {
         #[test]
         fn nested_struct() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Holder {
                 nested: Nested { float: 42.0 },
@@ -463,16 +450,14 @@ mod enum_ {
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Holder" string="answer"><nested float="42"/>
-</root>"#
+                r#"<root tag="Holder" string="answer"><nested float="42"/></root>"#
             );
         }
 
         #[test]
         fn flatten_struct() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Flatten {
                 nested: Nested { float: 42.0 },
@@ -537,23 +522,20 @@ mod enum_ {
         #[test]
         fn tuple_struct() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Tuple(42.0, "answer".to_string());
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Tuple"><content>42</content><content>answer</content>
-</root>"#
+                r#"<root tag="Tuple"><content>42</content><content>answer</content></root>"#
             );
         }
 
         #[test]
         fn struct_() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Struct {
                 float: 42.0,
@@ -562,16 +544,14 @@ mod enum_ {
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Struct"><content float="42" string="answer"/>
-</root>"#
+                r#"<root tag="Struct"><content float="42" string="answer"/></root>"#
             );
         }
 
         #[test]
         fn nested_struct() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Holder {
                 nested: Nested { float: 42.0 },
@@ -580,16 +560,14 @@ mod enum_ {
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Holder"><content string="answer"><nested float="42"/></content>
-</root>"#
+                r#"<root tag="Holder"><content string="answer"><nested float="42"/></content></root>"#
             );
         }
 
         #[test]
         fn flatten_struct() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Flatten {
                 nested: Nested { float: 42.0 },
@@ -598,8 +576,7 @@ mod enum_ {
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Flatten"><content><float>42</float><string>answer</string></content>
-</root>"#
+                r#"<root tag="Flatten"><content><float>42</float><string>answer</string></content></root>"#
             );
         }
     }
@@ -654,8 +631,7 @@ mod enum_ {
         #[test]
         fn tuple_struct() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Tuple(42.0, "answer".to_string());
             node.serialize(&mut ser).unwrap();
@@ -668,8 +644,7 @@ mod enum_ {
         #[test]
         fn struct_() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Struct {
                 float: 42.0,
@@ -685,8 +660,7 @@ mod enum_ {
         #[test]
         fn nested_struct() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Holder {
                 nested: Nested { float: 42.0 },
@@ -695,16 +669,14 @@ mod enum_ {
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
-                r#"<root string="answer"><nested float="42"/>
-</root>"#
+                r#"<root string="answer"><nested float="42"/></root>"#
             );
         }
 
         #[test]
         fn flatten_struct() {
             let mut buffer = Vec::new();
-            let mut ser =
-                Serializer::with_root(Writer::new_with_indent(&mut buffer, b' ', 4), Some("root"));
+            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
             let node = Node::Flatten {
                 nested: Nested { float: 42.0 },

From 87d54cf58e3ed2f71ec6c042712c2916d9592b18 Mon Sep 17 00:00:00 2001
From: Mingun <alexander_sergey@mail.ru>
Date: Wed, 31 Aug 2022 19:55:22 +0500
Subject: [PATCH 05/11] Move all helper structs to the upper level to reuse
 them later

---
 tests/serde-se.rs | 307 ++++++++++++++++++++++------------------------
 1 file changed, 146 insertions(+), 161 deletions(-)

diff --git a/tests/serde-se.rs b/tests/serde-se.rs
index f69f0623..42a1c666 100644
--- a/tests/serde-se.rs
+++ b/tests/serde-se.rs
@@ -107,11 +107,127 @@ fn serialize_a_list() {
     panic!();
 }
 
+#[derive(Serialize)]
+struct Unit;
+
+#[derive(Serialize)]
+struct Newtype(bool);
+
+#[derive(Serialize)]
+struct Tuple(f32, &'static str);
+
+#[derive(Serialize)]
+struct Struct {
+    float: f64,
+    string: String,
+}
+
+#[derive(Serialize)]
+struct NestedStruct {
+    nested: Nested,
+    string: String,
+}
+
+#[derive(Serialize)]
+struct FlattenStruct {
+    #[serde(flatten)]
+    nested: Nested,
+    string: String,
+}
+
+#[derive(Serialize)]
+struct Nested {
+    float: f64,
+}
+
+#[derive(Serialize)]
+enum ExternallyTagged {
+    Unit,
+    #[serde(rename = "$primitive=PrimitiveUnit")]
+    PrimitiveUnit,
+    Newtype(bool),
+    Tuple(f64, String),
+    Struct {
+        float: f64,
+        string: String,
+    },
+    Holder {
+        nested: Nested,
+        string: String,
+    },
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+        string: String,
+    },
+}
+
+#[derive(Serialize)]
+#[serde(tag = "tag")]
+enum InternallyTagged {
+    Unit,
+    /// Primitives (such as `bool`) are not supported by the serde in the internally tagged mode
+    Newtype(Nested),
+    // Tuple(f64, String),// Tuples are not supported in the internally tagged mode
+    Struct {
+        float: f64,
+        string: String,
+    },
+    Holder {
+        nested: Nested,
+        string: String,
+    },
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+        string: String,
+    },
+}
+
+#[derive(Serialize)]
+#[serde(tag = "tag", content = "content")]
+enum AdjacentlyTagged {
+    Unit,
+    Newtype(bool),
+    Tuple(f64, String),
+    Struct {
+        float: f64,
+        string: String,
+    },
+    Holder {
+        nested: Nested,
+        string: String,
+    },
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+        string: String,
+    },
+}
+
+#[derive(Serialize)]
+#[serde(untagged)]
+enum Untagged {
+    Unit,
+    Newtype(bool),
+    Tuple(f64, String),
+    Struct {
+        float: f64,
+        string: String,
+    },
+    Holder {
+        nested: Nested,
+        string: String,
+    },
+    Flatten {
+        #[serde(flatten)]
+        nested: Nested,
+        string: String,
+    },
+}
+
 #[test]
 fn unit() {
-    #[derive(Serialize)]
-    struct Unit;
-
     let mut buffer = Vec::new();
     let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
@@ -122,9 +238,6 @@ fn unit() {
 
 #[test]
 fn newtype() {
-    #[derive(Serialize)]
-    struct Newtype(bool);
-
     let mut buffer = Vec::new();
     let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
@@ -148,9 +261,6 @@ fn tuple() {
 
 #[test]
 fn tuple_struct() {
-    #[derive(Serialize)]
-    struct Tuple(f32, &'static str);
-
     let mut buffer = Vec::new();
     let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
@@ -164,12 +274,6 @@ fn tuple_struct() {
 
 #[test]
 fn struct_() {
-    #[derive(Serialize)]
-    struct Struct {
-        float: f64,
-        string: String,
-    }
-
     let mut buffer = Vec::new();
     let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
@@ -186,21 +290,10 @@ fn struct_() {
 
 #[test]
 fn nested_struct() {
-    #[derive(Serialize)]
-    struct Struct {
-        nested: Nested,
-        string: String,
-    }
-
-    #[derive(Serialize)]
-    struct Nested {
-        float: f64,
-    }
-
     let mut buffer = Vec::new();
     let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-    let node = Struct {
+    let node = NestedStruct {
         nested: Nested { float: 42.0 },
         string: "answer".to_string(),
     };
@@ -213,22 +306,10 @@ fn nested_struct() {
 
 #[test]
 fn flatten_struct() {
-    #[derive(Serialize)]
-    struct Struct {
-        #[serde(flatten)]
-        nested: Nested,
-        string: String,
-    }
-
-    #[derive(Serialize)]
-    struct Nested {
-        float: f64,
-    }
-
     let mut buffer = Vec::new();
     let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-    let node = Struct {
+    let node = FlattenStruct {
         nested: Nested { float: 42.0 },
         string: "answer".to_string(),
     };
@@ -242,43 +323,16 @@ fn flatten_struct() {
 mod enum_ {
     use super::*;
 
-    #[derive(Serialize)]
-    struct Nested {
-        float: f64,
-    }
-
     mod externally_tagged {
         use super::*;
         use pretty_assertions::assert_eq;
 
-        #[derive(Serialize)]
-        enum Node {
-            Unit,
-            #[serde(rename = "$primitive=PrimitiveUnit")]
-            PrimitiveUnit,
-            Newtype(bool),
-            Tuple(f64, String),
-            Struct {
-                float: f64,
-                string: String,
-            },
-            Holder {
-                nested: Nested,
-                string: String,
-            },
-            Flatten {
-                #[serde(flatten)]
-                nested: Nested,
-                string: String,
-            },
-        }
-
         #[test]
         fn unit() {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Unit;
+            let node = ExternallyTagged::Unit;
             node.serialize(&mut ser).unwrap();
             assert_eq!(String::from_utf8(buffer).unwrap(), "<Unit/>");
         }
@@ -288,7 +342,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::PrimitiveUnit;
+            let node = ExternallyTagged::PrimitiveUnit;
             node.serialize(&mut ser).unwrap();
             assert_eq!(String::from_utf8(buffer).unwrap(), "PrimitiveUnit");
         }
@@ -298,7 +352,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Newtype(true);
+            let node = ExternallyTagged::Newtype(true);
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
@@ -311,7 +365,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Struct {
+            let node = ExternallyTagged::Struct {
                 float: 42.0,
                 string: "answer".to_string(),
             };
@@ -327,7 +381,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Tuple(42.0, "answer".to_string());
+            let node = ExternallyTagged::Tuple(42.0, "answer".to_string());
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
@@ -340,7 +394,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Holder {
+            let node = ExternallyTagged::Holder {
                 nested: Nested { float: 42.0 },
                 string: "answer".to_string(),
             };
@@ -356,7 +410,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Flatten {
+            let node = ExternallyTagged::Flatten {
                 nested: Nested { float: 42.0 },
                 string: "answer".to_string(),
             };
@@ -372,39 +426,12 @@ mod enum_ {
         use super::*;
         use pretty_assertions::assert_eq;
 
-        #[derive(Serialize)]
-        #[serde(tag = "tag")]
-        enum Node {
-            Unit,
-            /// Primitives (such as `bool`) are not supported by the serde in the internally tagged mode
-            Newtype(NewtypeContent),
-            // Tuple(f64, String),// Tuples are not supported in the internally tagged mode
-            Struct {
-                float: f64,
-                string: String,
-            },
-            Holder {
-                nested: Nested,
-                string: String,
-            },
-            Flatten {
-                #[serde(flatten)]
-                nested: Nested,
-                string: String,
-            },
-        }
-
-        #[derive(Serialize)]
-        struct NewtypeContent {
-            value: bool,
-        }
-
         #[test]
         fn unit() {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Unit;
+            let node = InternallyTagged::Unit;
             node.serialize(&mut ser).unwrap();
             assert_eq!(String::from_utf8(buffer).unwrap(), r#"<root tag="Unit"/>"#);
         }
@@ -414,11 +441,11 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Newtype(NewtypeContent { value: true });
+            let node = InternallyTagged::Newtype(Nested { float: 4.2 });
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Newtype" value="true"/>"#
+                r#"<root tag="Newtype" float="4.2"/>"#
             );
         }
 
@@ -427,7 +454,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Struct {
+            let node = InternallyTagged::Struct {
                 float: 42.0,
                 string: "answer".to_string(),
             };
@@ -443,7 +470,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Holder {
+            let node = InternallyTagged::Holder {
                 nested: Nested { float: 42.0 },
                 string: "answer".to_string(),
             };
@@ -459,7 +486,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Flatten {
+            let node = InternallyTagged::Flatten {
                 nested: Nested { float: 42.0 },
                 string: "answer".to_string(),
             };
@@ -475,33 +502,12 @@ mod enum_ {
         use super::*;
         use pretty_assertions::assert_eq;
 
-        #[derive(Serialize)]
-        #[serde(tag = "tag", content = "content")]
-        enum Node {
-            Unit,
-            Newtype(bool),
-            Tuple(f64, String),
-            Struct {
-                float: f64,
-                string: String,
-            },
-            Holder {
-                nested: Nested,
-                string: String,
-            },
-            Flatten {
-                #[serde(flatten)]
-                nested: Nested,
-                string: String,
-            },
-        }
-
         #[test]
         fn unit() {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Unit;
+            let node = AdjacentlyTagged::Unit;
             node.serialize(&mut ser).unwrap();
             assert_eq!(String::from_utf8(buffer).unwrap(), r#"<root tag="Unit"/>"#);
         }
@@ -511,7 +517,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Newtype(true);
+            let node = AdjacentlyTagged::Newtype(true);
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
@@ -524,7 +530,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Tuple(42.0, "answer".to_string());
+            let node = AdjacentlyTagged::Tuple(42.0, "answer".to_string());
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
@@ -537,7 +543,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Struct {
+            let node = AdjacentlyTagged::Struct {
                 float: 42.0,
                 string: "answer".to_string(),
             };
@@ -553,7 +559,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Holder {
+            let node = AdjacentlyTagged::Holder {
                 nested: Nested { float: 42.0 },
                 string: "answer".to_string(),
             };
@@ -569,7 +575,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Flatten {
+            let node = AdjacentlyTagged::Flatten {
                 nested: Nested { float: 42.0 },
                 string: "answer".to_string(),
             };
@@ -585,33 +591,12 @@ mod enum_ {
         use super::*;
         use pretty_assertions::assert_eq;
 
-        #[derive(Serialize)]
-        #[serde(untagged)]
-        enum Node {
-            Unit,
-            Newtype(bool),
-            Tuple(f64, String),
-            Struct {
-                float: f64,
-                string: String,
-            },
-            Holder {
-                nested: Nested,
-                string: String,
-            },
-            Flatten {
-                #[serde(flatten)]
-                nested: Nested,
-                string: String,
-            },
-        }
-
         #[test]
         fn unit() {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Unit;
+            let node = Untagged::Unit;
             node.serialize(&mut ser).unwrap();
             // Unit variant consists just from the tag, and because tags
             // are not written in untagged mode, nothing is written
@@ -623,7 +608,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Newtype(true);
+            let node = Untagged::Newtype(true);
             node.serialize(&mut ser).unwrap();
             assert_eq!(String::from_utf8(buffer).unwrap(), "true");
         }
@@ -633,7 +618,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Tuple(42.0, "answer".to_string());
+            let node = Untagged::Tuple(42.0, "answer".to_string());
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
@@ -646,7 +631,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Struct {
+            let node = Untagged::Struct {
                 float: 42.0,
                 string: "answer".to_string(),
             };
@@ -662,7 +647,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Holder {
+            let node = Untagged::Holder {
                 nested: Nested { float: 42.0 },
                 string: "answer".to_string(),
             };
@@ -678,7 +663,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Node::Flatten {
+            let node = Untagged::Flatten {
                 nested: Nested { float: 42.0 },
                 string: "answer".to_string(),
             };

From 2788e75f286653651cbc5c27970d91e669f08a58 Mon Sep 17 00:00:00 2001
From: Mingun <alexander_sergey@mail.ru>
Date: Wed, 31 Aug 2022 22:36:20 +0500
Subject: [PATCH 06/11] Use `&'static str` instead of `String` for convenience

---
 tests/serde-se.rs | 74 +++++++++++++++++++++++------------------------
 1 file changed, 37 insertions(+), 37 deletions(-)

diff --git a/tests/serde-se.rs b/tests/serde-se.rs
index 42a1c666..bd9f9f4b 100644
--- a/tests/serde-se.rs
+++ b/tests/serde-se.rs
@@ -119,20 +119,20 @@ struct Tuple(f32, &'static str);
 #[derive(Serialize)]
 struct Struct {
     float: f64,
-    string: String,
+    string: &'static str,
 }
 
 #[derive(Serialize)]
 struct NestedStruct {
     nested: Nested,
-    string: String,
+    string: &'static str,
 }
 
 #[derive(Serialize)]
 struct FlattenStruct {
     #[serde(flatten)]
     nested: Nested,
-    string: String,
+    string: &'static str,
 }
 
 #[derive(Serialize)]
@@ -146,19 +146,19 @@ enum ExternallyTagged {
     #[serde(rename = "$primitive=PrimitiveUnit")]
     PrimitiveUnit,
     Newtype(bool),
-    Tuple(f64, String),
+    Tuple(f64, &'static str),
     Struct {
         float: f64,
-        string: String,
+        string: &'static str,
     },
     Holder {
         nested: Nested,
-        string: String,
+        string: &'static str,
     },
     Flatten {
         #[serde(flatten)]
         nested: Nested,
-        string: String,
+        string: &'static str,
     },
 }
 
@@ -168,19 +168,19 @@ enum InternallyTagged {
     Unit,
     /// Primitives (such as `bool`) are not supported by the serde in the internally tagged mode
     Newtype(Nested),
-    // Tuple(f64, String),// Tuples are not supported in the internally tagged mode
+    // Tuple(f64, &'static str),// Tuples are not supported in the internally tagged mode
     Struct {
         float: f64,
-        string: String,
+        string: &'static str,
     },
     Holder {
         nested: Nested,
-        string: String,
+        string: &'static str,
     },
     Flatten {
         #[serde(flatten)]
         nested: Nested,
-        string: String,
+        string: &'static str,
     },
 }
 
@@ -189,19 +189,19 @@ enum InternallyTagged {
 enum AdjacentlyTagged {
     Unit,
     Newtype(bool),
-    Tuple(f64, String),
+    Tuple(f64, &'static str),
     Struct {
         float: f64,
-        string: String,
+        string: &'static str,
     },
     Holder {
         nested: Nested,
-        string: String,
+        string: &'static str,
     },
     Flatten {
         #[serde(flatten)]
         nested: Nested,
-        string: String,
+        string: &'static str,
     },
 }
 
@@ -210,19 +210,19 @@ enum AdjacentlyTagged {
 enum Untagged {
     Unit,
     Newtype(bool),
-    Tuple(f64, String),
+    Tuple(f64, &'static str),
     Struct {
         float: f64,
-        string: String,
+        string: &'static str,
     },
     Holder {
         nested: Nested,
-        string: String,
+        string: &'static str,
     },
     Flatten {
         #[serde(flatten)]
         nested: Nested,
-        string: String,
+        string: &'static str,
     },
 }
 
@@ -279,7 +279,7 @@ fn struct_() {
 
     let node = Struct {
         float: 42.0,
-        string: "answer".to_string(),
+        string: "answer",
     };
     node.serialize(&mut ser).unwrap();
     assert_eq!(
@@ -295,7 +295,7 @@ fn nested_struct() {
 
     let node = NestedStruct {
         nested: Nested { float: 42.0 },
-        string: "answer".to_string(),
+        string: "answer",
     };
     node.serialize(&mut ser).unwrap();
     assert_eq!(
@@ -311,7 +311,7 @@ fn flatten_struct() {
 
     let node = FlattenStruct {
         nested: Nested { float: 42.0 },
-        string: "answer".to_string(),
+        string: "answer",
     };
     node.serialize(&mut ser).unwrap();
     assert_eq!(
@@ -367,7 +367,7 @@ mod enum_ {
 
             let node = ExternallyTagged::Struct {
                 float: 42.0,
-                string: "answer".to_string(),
+                string: "answer",
             };
             node.serialize(&mut ser).unwrap();
             assert_eq!(
@@ -381,7 +381,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = ExternallyTagged::Tuple(42.0, "answer".to_string());
+            let node = ExternallyTagged::Tuple(42.0, "answer");
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
@@ -396,7 +396,7 @@ mod enum_ {
 
             let node = ExternallyTagged::Holder {
                 nested: Nested { float: 42.0 },
-                string: "answer".to_string(),
+                string: "answer",
             };
             node.serialize(&mut ser).unwrap();
             assert_eq!(
@@ -412,7 +412,7 @@ mod enum_ {
 
             let node = ExternallyTagged::Flatten {
                 nested: Nested { float: 42.0 },
-                string: "answer".to_string(),
+                string: "answer",
             };
             node.serialize(&mut ser).unwrap();
             assert_eq!(
@@ -456,7 +456,7 @@ mod enum_ {
 
             let node = InternallyTagged::Struct {
                 float: 42.0,
-                string: "answer".to_string(),
+                string: "answer",
             };
             node.serialize(&mut ser).unwrap();
             assert_eq!(
@@ -472,7 +472,7 @@ mod enum_ {
 
             let node = InternallyTagged::Holder {
                 nested: Nested { float: 42.0 },
-                string: "answer".to_string(),
+                string: "answer",
             };
             node.serialize(&mut ser).unwrap();
             assert_eq!(
@@ -488,7 +488,7 @@ mod enum_ {
 
             let node = InternallyTagged::Flatten {
                 nested: Nested { float: 42.0 },
-                string: "answer".to_string(),
+                string: "answer",
             };
             node.serialize(&mut ser).unwrap();
             assert_eq!(
@@ -530,7 +530,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = AdjacentlyTagged::Tuple(42.0, "answer".to_string());
+            let node = AdjacentlyTagged::Tuple(42.0, "answer");
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
@@ -545,7 +545,7 @@ mod enum_ {
 
             let node = AdjacentlyTagged::Struct {
                 float: 42.0,
-                string: "answer".to_string(),
+                string: "answer",
             };
             node.serialize(&mut ser).unwrap();
             assert_eq!(
@@ -561,7 +561,7 @@ mod enum_ {
 
             let node = AdjacentlyTagged::Holder {
                 nested: Nested { float: 42.0 },
-                string: "answer".to_string(),
+                string: "answer",
             };
             node.serialize(&mut ser).unwrap();
             assert_eq!(
@@ -577,7 +577,7 @@ mod enum_ {
 
             let node = AdjacentlyTagged::Flatten {
                 nested: Nested { float: 42.0 },
-                string: "answer".to_string(),
+                string: "answer",
             };
             node.serialize(&mut ser).unwrap();
             assert_eq!(
@@ -618,7 +618,7 @@ mod enum_ {
             let mut buffer = Vec::new();
             let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-            let node = Untagged::Tuple(42.0, "answer".to_string());
+            let node = Untagged::Tuple(42.0, "answer");
             node.serialize(&mut ser).unwrap();
             assert_eq!(
                 String::from_utf8(buffer).unwrap(),
@@ -633,7 +633,7 @@ mod enum_ {
 
             let node = Untagged::Struct {
                 float: 42.0,
-                string: "answer".to_string(),
+                string: "answer",
             };
             node.serialize(&mut ser).unwrap();
             assert_eq!(
@@ -649,7 +649,7 @@ mod enum_ {
 
             let node = Untagged::Holder {
                 nested: Nested { float: 42.0 },
-                string: "answer".to_string(),
+                string: "answer",
             };
             node.serialize(&mut ser).unwrap();
             assert_eq!(
@@ -665,7 +665,7 @@ mod enum_ {
 
             let node = Untagged::Flatten {
                 nested: Nested { float: 42.0 },
-                string: "answer".to_string(),
+                string: "answer",
             };
             node.serialize(&mut ser).unwrap();
             assert_eq!(

From 06ef1fce90f493de76e60fd3aae61fa5818d42f1 Mon Sep 17 00:00:00 2001
From: Mingun <alexander_sergey@mail.ru>
Date: Thu, 1 Sep 2022 21:28:59 +0500
Subject: [PATCH 07/11] Move all "new" tests into `with_root` module

The `without_root` tests will be added soon

(review with with whitespace ignored mode)
---
 tests/serde-se.rs | 853 +++++++++++++++++++++++-----------------------
 1 file changed, 429 insertions(+), 424 deletions(-)

diff --git a/tests/serde-se.rs b/tests/serde-se.rs
index bd9f9f4b..5f4607b5 100644
--- a/tests/serde-se.rs
+++ b/tests/serde-se.rs
@@ -226,452 +226,457 @@ enum Untagged {
     },
 }
 
-#[test]
-fn unit() {
-    let mut buffer = Vec::new();
-    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-    let data = Unit;
-    data.serialize(&mut ser).unwrap();
-    assert_eq!(String::from_utf8(buffer).unwrap(), "<root/>");
-}
-
-#[test]
-fn newtype() {
-    let mut buffer = Vec::new();
-    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-    let data = Newtype(true);
-    data.serialize(&mut ser).unwrap();
-    assert_eq!(String::from_utf8(buffer).unwrap(), "<root>true</root>");
-}
-
-#[test]
-fn tuple() {
-    let mut buffer = Vec::new();
-    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-    let data = (42.0, "answer");
-    data.serialize(&mut ser).unwrap();
-    assert_eq!(
-        String::from_utf8(buffer).unwrap(),
-        "<root>42</root><root>answer</root>"
-    );
-}
-
-#[test]
-fn tuple_struct() {
-    let mut buffer = Vec::new();
-    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-    let data = Tuple(42.0, "answer");
-    data.serialize(&mut ser).unwrap();
-    assert_eq!(
-        String::from_utf8(buffer).unwrap(),
-        "<root>42</root><root>answer</root>"
-    );
-}
-
-#[test]
-fn struct_() {
-    let mut buffer = Vec::new();
-    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-    let node = Struct {
-        float: 42.0,
-        string: "answer",
-    };
-    node.serialize(&mut ser).unwrap();
-    assert_eq!(
-        String::from_utf8(buffer).unwrap(),
-        r#"<root float="42" string="answer"/>"#
-    );
-}
-
-#[test]
-fn nested_struct() {
-    let mut buffer = Vec::new();
-    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-    let node = NestedStruct {
-        nested: Nested { float: 42.0 },
-        string: "answer",
-    };
-    node.serialize(&mut ser).unwrap();
-    assert_eq!(
-        String::from_utf8(buffer).unwrap(),
-        r#"<root string="answer"><nested float="42"/></root>"#
-    );
-}
-
-#[test]
-fn flatten_struct() {
-    let mut buffer = Vec::new();
-    let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-    let node = FlattenStruct {
-        nested: Nested { float: 42.0 },
-        string: "answer",
-    };
-    node.serialize(&mut ser).unwrap();
-    assert_eq!(
-        String::from_utf8(buffer).unwrap(),
-        r#"<root><float>42</float><string>answer</string></root>"#
-    );
-}
-
-mod enum_ {
+mod with_root {
     use super::*;
+    use pretty_assertions::assert_eq;
 
-    mod externally_tagged {
-        use super::*;
-        use pretty_assertions::assert_eq;
-
-        #[test]
-        fn unit() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = ExternallyTagged::Unit;
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(String::from_utf8(buffer).unwrap(), "<Unit/>");
-        }
-
-        #[test]
-        fn primitive_unit() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = ExternallyTagged::PrimitiveUnit;
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(String::from_utf8(buffer).unwrap(), "PrimitiveUnit");
-        }
-
-        #[test]
-        fn newtype() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = ExternallyTagged::Newtype(true);
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                "<Newtype>true</Newtype>"
-            );
-        }
-
-        #[test]
-        fn struct_() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = ExternallyTagged::Struct {
-                float: 42.0,
-                string: "answer",
-            };
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<Struct float="42" string="answer"/>"#
-            );
-        }
-
-        #[test]
-        fn tuple_struct() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = ExternallyTagged::Tuple(42.0, "answer");
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                "<Tuple>42</Tuple><Tuple>answer</Tuple>"
-            );
-        }
-
-        #[test]
-        fn nested_struct() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = ExternallyTagged::Holder {
-                nested: Nested { float: 42.0 },
-                string: "answer",
-            };
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<Holder string="answer"><nested float="42"/></Holder>"#
-            );
-        }
+    #[test]
+    fn unit() {
+        let mut buffer = Vec::new();
+        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-        #[test]
-        fn flatten_struct() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = ExternallyTagged::Flatten {
-                nested: Nested { float: 42.0 },
-                string: "answer",
-            };
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<Flatten><float>42</float><string>answer</string></Flatten>"#
-            );
-        }
+        let data = Unit;
+        data.serialize(&mut ser).unwrap();
+        assert_eq!(String::from_utf8(buffer).unwrap(), "<root/>");
     }
 
-    mod internally_tagged {
-        use super::*;
-        use pretty_assertions::assert_eq;
-
-        #[test]
-        fn unit() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = InternallyTagged::Unit;
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(String::from_utf8(buffer).unwrap(), r#"<root tag="Unit"/>"#);
-        }
-
-        #[test]
-        fn newtype() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = InternallyTagged::Newtype(Nested { float: 4.2 });
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Newtype" float="4.2"/>"#
-            );
-        }
-
-        #[test]
-        fn struct_() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = InternallyTagged::Struct {
-                float: 42.0,
-                string: "answer",
-            };
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Struct" float="42" string="answer"/>"#
-            );
-        }
-
-        #[test]
-        fn nested_struct() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = InternallyTagged::Holder {
-                nested: Nested { float: 42.0 },
-                string: "answer",
-            };
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Holder" string="answer"><nested float="42"/></root>"#
-            );
-        }
+    #[test]
+    fn newtype() {
+        let mut buffer = Vec::new();
+        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-        #[test]
-        fn flatten_struct() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = InternallyTagged::Flatten {
-                nested: Nested { float: 42.0 },
-                string: "answer",
-            };
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<root><tag>Flatten</tag><float>42</float><string>answer</string></root>"#
-            );
-        }
+        let data = Newtype(true);
+        data.serialize(&mut ser).unwrap();
+        assert_eq!(String::from_utf8(buffer).unwrap(), "<root>true</root>");
     }
 
-    mod adjacently_tagged {
-        use super::*;
-        use pretty_assertions::assert_eq;
-
-        #[test]
-        fn unit() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = AdjacentlyTagged::Unit;
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(String::from_utf8(buffer).unwrap(), r#"<root tag="Unit"/>"#);
-        }
-
-        #[test]
-        fn newtype() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = AdjacentlyTagged::Newtype(true);
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Newtype" content="true"/>"#
-            );
-        }
+    #[test]
+    fn tuple() {
+        let mut buffer = Vec::new();
+        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+        let data = (42.0, "answer");
+        data.serialize(&mut ser).unwrap();
+        assert_eq!(
+            String::from_utf8(buffer).unwrap(),
+            "<root>42</root><root>answer</root>"
+        );
+    }
 
-        #[test]
-        fn tuple_struct() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = AdjacentlyTagged::Tuple(42.0, "answer");
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Tuple"><content>42</content><content>answer</content></root>"#
-            );
-        }
+    #[test]
+    fn tuple_struct() {
+        let mut buffer = Vec::new();
+        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+        let data = Tuple(42.0, "answer");
+        data.serialize(&mut ser).unwrap();
+        assert_eq!(
+            String::from_utf8(buffer).unwrap(),
+            "<root>42</root><root>answer</root>"
+        );
+    }
 
-        #[test]
-        fn struct_() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = AdjacentlyTagged::Struct {
-                float: 42.0,
-                string: "answer",
-            };
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Struct"><content float="42" string="answer"/></root>"#
-            );
-        }
+    #[test]
+    fn struct_() {
+        let mut buffer = Vec::new();
+        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+        let node = Struct {
+            float: 42.0,
+            string: "answer",
+        };
+        node.serialize(&mut ser).unwrap();
+        assert_eq!(
+            String::from_utf8(buffer).unwrap(),
+            r#"<root float="42" string="answer"/>"#
+        );
+    }
 
-        #[test]
-        fn nested_struct() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = AdjacentlyTagged::Holder {
-                nested: Nested { float: 42.0 },
-                string: "answer",
-            };
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Holder"><content string="answer"><nested float="42"/></content></root>"#
-            );
-        }
+    #[test]
+    fn nested_struct() {
+        let mut buffer = Vec::new();
+        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+        let node = NestedStruct {
+            nested: Nested { float: 42.0 },
+            string: "answer",
+        };
+        node.serialize(&mut ser).unwrap();
+        assert_eq!(
+            String::from_utf8(buffer).unwrap(),
+            r#"<root string="answer"><nested float="42"/></root>"#
+        );
+    }
 
-        #[test]
-        fn flatten_struct() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = AdjacentlyTagged::Flatten {
-                nested: Nested { float: 42.0 },
-                string: "answer",
-            };
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<root tag="Flatten"><content><float>42</float><string>answer</string></content></root>"#
-            );
-        }
+    #[test]
+    fn flatten_struct() {
+        let mut buffer = Vec::new();
+        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+        let node = FlattenStruct {
+            nested: Nested { float: 42.0 },
+            string: "answer",
+        };
+        node.serialize(&mut ser).unwrap();
+        assert_eq!(
+            String::from_utf8(buffer).unwrap(),
+            r#"<root><float>42</float><string>answer</string></root>"#
+        );
     }
 
-    mod untagged {
+    mod enum_ {
         use super::*;
-        use pretty_assertions::assert_eq;
-
-        #[test]
-        fn unit() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = Untagged::Unit;
-            node.serialize(&mut ser).unwrap();
-            // Unit variant consists just from the tag, and because tags
-            // are not written in untagged mode, nothing is written
-            assert_eq!(String::from_utf8(buffer).unwrap(), "");
-        }
-
-        #[test]
-        fn newtype() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = Untagged::Newtype(true);
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(String::from_utf8(buffer).unwrap(), "true");
-        }
 
-        #[test]
-        fn tuple_struct() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = Untagged::Tuple(42.0, "answer");
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                "<root>42</root><root>answer</root>"
-            );
+        mod externally_tagged {
+            use super::*;
+            use pretty_assertions::assert_eq;
+
+            #[test]
+            fn unit() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = ExternallyTagged::Unit;
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(String::from_utf8(buffer).unwrap(), "<Unit/>");
+            }
+
+            #[test]
+            fn primitive_unit() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = ExternallyTagged::PrimitiveUnit;
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(String::from_utf8(buffer).unwrap(), "PrimitiveUnit");
+            }
+
+            #[test]
+            fn newtype() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = ExternallyTagged::Newtype(true);
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    "<Newtype>true</Newtype>"
+                );
+            }
+
+            #[test]
+            fn struct_() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = ExternallyTagged::Struct {
+                    float: 42.0,
+                    string: "answer",
+                };
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<Struct float="42" string="answer"/>"#
+                );
+            }
+
+            #[test]
+            fn tuple_struct() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = ExternallyTagged::Tuple(42.0, "answer");
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    "<Tuple>42</Tuple><Tuple>answer</Tuple>"
+                );
+            }
+
+            #[test]
+            fn nested_struct() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = ExternallyTagged::Holder {
+                    nested: Nested { float: 42.0 },
+                    string: "answer",
+                };
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<Holder string="answer"><nested float="42"/></Holder>"#
+                );
+            }
+
+            #[test]
+            fn flatten_struct() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = ExternallyTagged::Flatten {
+                    nested: Nested { float: 42.0 },
+                    string: "answer",
+                };
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<Flatten><float>42</float><string>answer</string></Flatten>"#
+                );
+            }
         }
 
-        #[test]
-        fn struct_() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = Untagged::Struct {
-                float: 42.0,
-                string: "answer",
-            };
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<root float="42" string="answer"/>"#
-            );
+        mod internally_tagged {
+            use super::*;
+            use pretty_assertions::assert_eq;
+
+            #[test]
+            fn unit() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = InternallyTagged::Unit;
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(String::from_utf8(buffer).unwrap(), r#"<root tag="Unit"/>"#);
+            }
+
+            #[test]
+            fn newtype() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = InternallyTagged::Newtype(Nested { float: 4.2 });
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<root tag="Newtype" float="4.2"/>"#
+                );
+            }
+
+            #[test]
+            fn struct_() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = InternallyTagged::Struct {
+                    float: 42.0,
+                    string: "answer",
+                };
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<root tag="Struct" float="42" string="answer"/>"#
+                );
+            }
+
+            #[test]
+            fn nested_struct() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = InternallyTagged::Holder {
+                    nested: Nested { float: 42.0 },
+                    string: "answer",
+                };
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<root tag="Holder" string="answer"><nested float="42"/></root>"#
+                );
+            }
+
+            #[test]
+            fn flatten_struct() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = InternallyTagged::Flatten {
+                    nested: Nested { float: 42.0 },
+                    string: "answer",
+                };
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<root><tag>Flatten</tag><float>42</float><string>answer</string></root>"#
+                );
+            }
         }
 
-        #[test]
-        fn nested_struct() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = Untagged::Holder {
-                nested: Nested { float: 42.0 },
-                string: "answer",
-            };
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<root string="answer"><nested float="42"/></root>"#
-            );
+        mod adjacently_tagged {
+            use super::*;
+            use pretty_assertions::assert_eq;
+
+            #[test]
+            fn unit() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = AdjacentlyTagged::Unit;
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(String::from_utf8(buffer).unwrap(), r#"<root tag="Unit"/>"#);
+            }
+
+            #[test]
+            fn newtype() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = AdjacentlyTagged::Newtype(true);
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<root tag="Newtype" content="true"/>"#
+                );
+            }
+
+            #[test]
+            fn tuple_struct() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = AdjacentlyTagged::Tuple(42.0, "answer");
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<root tag="Tuple"><content>42</content><content>answer</content></root>"#
+                );
+            }
+
+            #[test]
+            fn struct_() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = AdjacentlyTagged::Struct {
+                    float: 42.0,
+                    string: "answer",
+                };
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<root tag="Struct"><content float="42" string="answer"/></root>"#
+                );
+            }
+
+            #[test]
+            fn nested_struct() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = AdjacentlyTagged::Holder {
+                    nested: Nested { float: 42.0 },
+                    string: "answer",
+                };
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<root tag="Holder"><content string="answer"><nested float="42"/></content></root>"#
+                );
+            }
+
+            #[test]
+            fn flatten_struct() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = AdjacentlyTagged::Flatten {
+                    nested: Nested { float: 42.0 },
+                    string: "answer",
+                };
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<root tag="Flatten"><content><float>42</float><string>answer</string></content></root>"#
+                );
+            }
         }
 
-        #[test]
-        fn flatten_struct() {
-            let mut buffer = Vec::new();
-            let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-            let node = Untagged::Flatten {
-                nested: Nested { float: 42.0 },
-                string: "answer",
-            };
-            node.serialize(&mut ser).unwrap();
-            assert_eq!(
-                String::from_utf8(buffer).unwrap(),
-                r#"<root><float>42</float><string>answer</string></root>"#
-            );
+        mod untagged {
+            use super::*;
+            use pretty_assertions::assert_eq;
+
+            #[test]
+            fn unit() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = Untagged::Unit;
+                node.serialize(&mut ser).unwrap();
+                // Unit variant consists just from the tag, and because tags
+                // are not written in untagged mode, nothing is written
+                assert_eq!(String::from_utf8(buffer).unwrap(), "");
+            }
+
+            #[test]
+            fn newtype() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = Untagged::Newtype(true);
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(String::from_utf8(buffer).unwrap(), "true");
+            }
+
+            #[test]
+            fn tuple_struct() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = Untagged::Tuple(42.0, "answer");
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    "<root>42</root><root>answer</root>"
+                );
+            }
+
+            #[test]
+            fn struct_() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = Untagged::Struct {
+                    float: 42.0,
+                    string: "answer",
+                };
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<root float="42" string="answer"/>"#
+                );
+            }
+
+            #[test]
+            fn nested_struct() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = Untagged::Holder {
+                    nested: Nested { float: 42.0 },
+                    string: "answer",
+                };
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<root string="answer"><nested float="42"/></root>"#
+                );
+            }
+
+            #[test]
+            fn flatten_struct() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+
+                let node = Untagged::Flatten {
+                    nested: Nested { float: 42.0 },
+                    string: "answer",
+                };
+                node.serialize(&mut ser).unwrap();
+                assert_eq!(
+                    String::from_utf8(buffer).unwrap(),
+                    r#"<root><float>42</float><string>answer</string></root>"#
+                );
+            }
         }
     }
 }

From 49d918d4d26911aff6fe925a743291dc2113f594 Mon Sep 17 00:00:00 2001
From: Mingun <alexander_sergey@mail.ru>
Date: Thu, 1 Sep 2022 21:48:50 +0500
Subject: [PATCH 08/11] Rewrite tests using macros

---
 tests/serde-se.rs | 506 +++++++++++-----------------------------------
 1 file changed, 119 insertions(+), 387 deletions(-)

diff --git a/tests/serde-se.rs b/tests/serde-se.rs
index 5f4607b5..f7efd767 100644
--- a/tests/serde-se.rs
+++ b/tests/serde-se.rs
@@ -230,99 +230,49 @@ mod with_root {
     use super::*;
     use pretty_assertions::assert_eq;
 
-    #[test]
-    fn unit() {
-        let mut buffer = Vec::new();
-        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-        let data = Unit;
-        data.serialize(&mut ser).unwrap();
-        assert_eq!(String::from_utf8(buffer).unwrap(), "<root/>");
-    }
-
-    #[test]
-    fn newtype() {
-        let mut buffer = Vec::new();
-        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-        let data = Newtype(true);
-        data.serialize(&mut ser).unwrap();
-        assert_eq!(String::from_utf8(buffer).unwrap(), "<root>true</root>");
-    }
-
-    #[test]
-    fn tuple() {
-        let mut buffer = Vec::new();
-        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-        let data = (42.0, "answer");
-        data.serialize(&mut ser).unwrap();
-        assert_eq!(
-            String::from_utf8(buffer).unwrap(),
-            "<root>42</root><root>answer</root>"
-        );
-    }
-
-    #[test]
-    fn tuple_struct() {
-        let mut buffer = Vec::new();
-        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-        let data = Tuple(42.0, "answer");
-        data.serialize(&mut ser).unwrap();
-        assert_eq!(
-            String::from_utf8(buffer).unwrap(),
-            "<root>42</root><root>answer</root>"
-        );
-    }
-
-    #[test]
-    fn struct_() {
-        let mut buffer = Vec::new();
-        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
+    macro_rules! serialize_as {
+        ($name:ident: $data:expr => $expected:literal) => {
+            #[test]
+            fn $name() {
+                let mut buffer = Vec::new();
+                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
 
-        let node = Struct {
-            float: 42.0,
-            string: "answer",
+                $data.serialize(&mut ser).unwrap();
+                assert_eq!(String::from_utf8(buffer).unwrap(), $expected);
+            }
         };
-        node.serialize(&mut ser).unwrap();
-        assert_eq!(
-            String::from_utf8(buffer).unwrap(),
-            r#"<root float="42" string="answer"/>"#
-        );
     }
 
-    #[test]
-    fn nested_struct() {
-        let mut buffer = Vec::new();
-        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-        let node = NestedStruct {
+    serialize_as!(unit:
+        Unit
+        => "<root/>");
+    serialize_as!(newtype:
+        Newtype(true)
+        => "<root>true</root>");
+    serialize_as!(tuple:
+        (42.0, "answer")
+        => "<root>42</root><root>answer</root>");
+    serialize_as!(tuple_struct:
+        Tuple(42.0, "answer")
+        => "<root>42</root><root>answer</root>");
+    serialize_as!(struct_:
+        Struct {
+            float: 42.0,
+            string: "answer"
+        }
+        => r#"<root float="42" string="answer"/>"#);
+    serialize_as!(nested_struct:
+        NestedStruct {
             nested: Nested { float: 42.0 },
             string: "answer",
-        };
-        node.serialize(&mut ser).unwrap();
-        assert_eq!(
-            String::from_utf8(buffer).unwrap(),
-            r#"<root string="answer"><nested float="42"/></root>"#
-        );
-    }
-
-    #[test]
-    fn flatten_struct() {
-        let mut buffer = Vec::new();
-        let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-        let node = FlattenStruct {
+        }
+        => r#"<root string="answer"><nested float="42"/></root>"#);
+    serialize_as!(flatten_struct:
+        FlattenStruct {
             nested: Nested { float: 42.0 },
             string: "answer",
-        };
-        node.serialize(&mut ser).unwrap();
-        assert_eq!(
-            String::from_utf8(buffer).unwrap(),
-            r#"<root><float>42</float><string>answer</string></root>"#
-        );
-    }
+        }
+        => r#"<root><float>42</float><string>answer</string></root>"#);
 
     mod enum_ {
         use super::*;
@@ -331,352 +281,134 @@ mod with_root {
             use super::*;
             use pretty_assertions::assert_eq;
 
-            #[test]
-            fn unit() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = ExternallyTagged::Unit;
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(String::from_utf8(buffer).unwrap(), "<Unit/>");
-            }
-
-            #[test]
-            fn primitive_unit() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = ExternallyTagged::PrimitiveUnit;
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(String::from_utf8(buffer).unwrap(), "PrimitiveUnit");
-            }
-
-            #[test]
-            fn newtype() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = ExternallyTagged::Newtype(true);
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    "<Newtype>true</Newtype>"
-                );
-            }
-
-            #[test]
-            fn struct_() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = ExternallyTagged::Struct {
+            serialize_as!(unit:
+                ExternallyTagged::Unit
+                => "<Unit/>");
+            serialize_as!(primitive_unit:
+                ExternallyTagged::PrimitiveUnit
+                => "PrimitiveUnit");
+            serialize_as!(newtype:
+                ExternallyTagged::Newtype(true)
+                => "<Newtype>true</Newtype>");
+            serialize_as!(tuple_struct:
+                ExternallyTagged::Tuple(42.0, "answer")
+                => "<Tuple>42</Tuple><Tuple>answer</Tuple>");
+            serialize_as!(struct_:
+                ExternallyTagged::Struct {
                     float: 42.0,
                     string: "answer",
-                };
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<Struct float="42" string="answer"/>"#
-                );
-            }
-
-            #[test]
-            fn tuple_struct() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = ExternallyTagged::Tuple(42.0, "answer");
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    "<Tuple>42</Tuple><Tuple>answer</Tuple>"
-                );
-            }
-
-            #[test]
-            fn nested_struct() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = ExternallyTagged::Holder {
+                }
+                => r#"<Struct float="42" string="answer"/>"#);
+            serialize_as!(nested_struct:
+                ExternallyTagged::Holder {
                     nested: Nested { float: 42.0 },
                     string: "answer",
-                };
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<Holder string="answer"><nested float="42"/></Holder>"#
-                );
-            }
-
-            #[test]
-            fn flatten_struct() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = ExternallyTagged::Flatten {
+                }
+                => r#"<Holder string="answer"><nested float="42"/></Holder>"#);
+            serialize_as!(flatten_struct:
+                ExternallyTagged::Flatten {
                     nested: Nested { float: 42.0 },
                     string: "answer",
-                };
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<Flatten><float>42</float><string>answer</string></Flatten>"#
-                );
-            }
+                }
+                => r#"<Flatten><float>42</float><string>answer</string></Flatten>"#);
         }
 
         mod internally_tagged {
             use super::*;
             use pretty_assertions::assert_eq;
 
-            #[test]
-            fn unit() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = InternallyTagged::Unit;
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(String::from_utf8(buffer).unwrap(), r#"<root tag="Unit"/>"#);
-            }
-
-            #[test]
-            fn newtype() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = InternallyTagged::Newtype(Nested { float: 4.2 });
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<root tag="Newtype" float="4.2"/>"#
-                );
-            }
-
-            #[test]
-            fn struct_() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = InternallyTagged::Struct {
+            serialize_as!(unit:
+                InternallyTagged::Unit
+                => r#"<root tag="Unit"/>"#);
+            serialize_as!(newtype:
+                InternallyTagged::Newtype(Nested { float: 4.2 })
+                => r#"<root tag="Newtype" float="4.2"/>"#);
+            serialize_as!(struct_:
+                InternallyTagged::Struct {
                     float: 42.0,
                     string: "answer",
-                };
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<root tag="Struct" float="42" string="answer"/>"#
-                );
-            }
-
-            #[test]
-            fn nested_struct() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = InternallyTagged::Holder {
+                }
+                => r#"<root tag="Struct" float="42" string="answer"/>"#);
+            serialize_as!(nested_struct:
+                InternallyTagged::Holder {
                     nested: Nested { float: 42.0 },
                     string: "answer",
-                };
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<root tag="Holder" string="answer"><nested float="42"/></root>"#
-                );
-            }
-
-            #[test]
-            fn flatten_struct() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = InternallyTagged::Flatten {
+                }
+                => r#"<root tag="Holder" string="answer"><nested float="42"/></root>"#);
+            serialize_as!(flatten_struct:
+                InternallyTagged::Flatten {
                     nested: Nested { float: 42.0 },
                     string: "answer",
-                };
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<root><tag>Flatten</tag><float>42</float><string>answer</string></root>"#
-                );
-            }
+                }
+                => r#"<root><tag>Flatten</tag><float>42</float><string>answer</string></root>"#);
         }
 
         mod adjacently_tagged {
             use super::*;
             use pretty_assertions::assert_eq;
 
-            #[test]
-            fn unit() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = AdjacentlyTagged::Unit;
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(String::from_utf8(buffer).unwrap(), r#"<root tag="Unit"/>"#);
-            }
-
-            #[test]
-            fn newtype() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = AdjacentlyTagged::Newtype(true);
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<root tag="Newtype" content="true"/>"#
-                );
-            }
-
-            #[test]
-            fn tuple_struct() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = AdjacentlyTagged::Tuple(42.0, "answer");
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<root tag="Tuple"><content>42</content><content>answer</content></root>"#
-                );
-            }
-
-            #[test]
-            fn struct_() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = AdjacentlyTagged::Struct {
+            serialize_as!(unit:
+                AdjacentlyTagged::Unit
+                => r#"<root tag="Unit"/>"#);
+            serialize_as!(newtype:
+                AdjacentlyTagged::Newtype(true)
+                => r#"<root tag="Newtype" content="true"/>"#);
+            serialize_as!(tuple_struct:
+                AdjacentlyTagged::Tuple(42.0, "answer")
+                => r#"<root tag="Tuple"><content>42</content><content>answer</content></root>"#);
+            serialize_as!(struct_:
+                AdjacentlyTagged::Struct {
                     float: 42.0,
                     string: "answer",
-                };
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<root tag="Struct"><content float="42" string="answer"/></root>"#
-                );
-            }
-
-            #[test]
-            fn nested_struct() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = AdjacentlyTagged::Holder {
+                }
+                => r#"<root tag="Struct"><content float="42" string="answer"/></root>"#);
+            serialize_as!(nested_struct:
+                AdjacentlyTagged::Holder {
                     nested: Nested { float: 42.0 },
                     string: "answer",
-                };
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<root tag="Holder"><content string="answer"><nested float="42"/></content></root>"#
-                );
-            }
-
-            #[test]
-            fn flatten_struct() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = AdjacentlyTagged::Flatten {
+                }
+                => r#"<root tag="Holder"><content string="answer"><nested float="42"/></content></root>"#);
+            serialize_as!(flatten_struct:
+                AdjacentlyTagged::Flatten {
                     nested: Nested { float: 42.0 },
                     string: "answer",
-                };
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<root tag="Flatten"><content><float>42</float><string>answer</string></content></root>"#
-                );
-            }
+                }
+                => r#"<root tag="Flatten"><content><float>42</float><string>answer</string></content></root>"#);
         }
 
         mod untagged {
             use super::*;
             use pretty_assertions::assert_eq;
 
-            #[test]
-            fn unit() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = Untagged::Unit;
-                node.serialize(&mut ser).unwrap();
+            serialize_as!(unit:
+                Untagged::Unit
                 // Unit variant consists just from the tag, and because tags
                 // are not written in untagged mode, nothing is written
-                assert_eq!(String::from_utf8(buffer).unwrap(), "");
-            }
-
-            #[test]
-            fn newtype() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = Untagged::Newtype(true);
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(String::from_utf8(buffer).unwrap(), "true");
-            }
-
-            #[test]
-            fn tuple_struct() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = Untagged::Tuple(42.0, "answer");
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    "<root>42</root><root>answer</root>"
-                );
-            }
-
-            #[test]
-            fn struct_() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = Untagged::Struct {
+                => "");
+            serialize_as!(newtype:
+                Untagged::Newtype(true)
+                => "true");
+            serialize_as!(tuple_struct:
+                Untagged::Tuple(42.0, "answer")
+                => "<root>42</root><root>answer</root>");
+            serialize_as!(struct_:
+                Untagged::Struct {
                     float: 42.0,
                     string: "answer",
-                };
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<root float="42" string="answer"/>"#
-                );
-            }
-
-            #[test]
-            fn nested_struct() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = Untagged::Holder {
+                }
+                => r#"<root float="42" string="answer"/>"#);
+            serialize_as!(nested_struct:
+                Untagged::Holder {
                     nested: Nested { float: 42.0 },
                     string: "answer",
-                };
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<root string="answer"><nested float="42"/></root>"#
-                );
-            }
-
-            #[test]
-            fn flatten_struct() {
-                let mut buffer = Vec::new();
-                let mut ser = Serializer::with_root(Writer::new(&mut buffer), Some("root"));
-
-                let node = Untagged::Flatten {
+                }
+                => r#"<root string="answer"><nested float="42"/></root>"#);
+            serialize_as!(flatten_struct:
+                Untagged::Flatten {
                     nested: Nested { float: 42.0 },
                     string: "answer",
-                };
-                node.serialize(&mut ser).unwrap();
-                assert_eq!(
-                    String::from_utf8(buffer).unwrap(),
-                    r#"<root><float>42</float><string>answer</string></root>"#
-                );
-            }
+                }
+                => r#"<root><float>42</float><string>answer</string></root>"#);
         }
     }
 }

From 6043d57f00b9451351d31128d3b58e8f5a6dcdb9 Mon Sep 17 00:00:00 2001
From: Mingun <alexander_sergey@mail.ru>
Date: Thu, 1 Sep 2022 22:49:56 +0500
Subject: [PATCH 09/11] Add a special cases of structs: Empty and with `$value`
 field

---
 tests/serde-se.rs | 79 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 79 insertions(+)

diff --git a/tests/serde-se.rs b/tests/serde-se.rs
index f7efd767..99d2b5ba 100644
--- a/tests/serde-se.rs
+++ b/tests/serde-se.rs
@@ -140,6 +140,16 @@ struct Nested {
     float: f64,
 }
 
+#[derive(Serialize)]
+struct Empty {}
+
+#[derive(Serialize)]
+struct Value {
+    #[serde(rename = "$value")]
+    float: f64,
+    string: &'static str,
+}
+
 #[derive(Serialize)]
 enum ExternallyTagged {
     Unit,
@@ -160,6 +170,12 @@ enum ExternallyTagged {
         nested: Nested,
         string: &'static str,
     },
+    Empty {},
+    Value {
+        #[serde(rename = "$value")]
+        float: f64,
+        string: &'static str,
+    },
 }
 
 #[derive(Serialize)]
@@ -182,6 +198,12 @@ enum InternallyTagged {
         nested: Nested,
         string: &'static str,
     },
+    Empty {},
+    Value {
+        #[serde(rename = "$value")]
+        float: f64,
+        string: &'static str,
+    },
 }
 
 #[derive(Serialize)]
@@ -203,6 +225,12 @@ enum AdjacentlyTagged {
         nested: Nested,
         string: &'static str,
     },
+    Empty {},
+    Value {
+        #[serde(rename = "$value")]
+        float: f64,
+        string: &'static str,
+    },
 }
 
 #[derive(Serialize)]
@@ -224,6 +252,12 @@ enum Untagged {
         nested: Nested,
         string: &'static str,
     },
+    Empty {},
+    Value {
+        #[serde(rename = "$value")]
+        float: f64,
+        string: &'static str,
+    },
 }
 
 mod with_root {
@@ -273,6 +307,15 @@ mod with_root {
             string: "answer",
         }
         => r#"<root><float>42</float><string>answer</string></root>"#);
+    serialize_as!(empty_struct:
+        Empty {}
+        => "<root/>");
+    serialize_as!(value:
+        Value {
+            float: 42.0,
+            string: "answer"
+        }
+        => r#"<root string="answer">42</root>"#);
 
     mod enum_ {
         use super::*;
@@ -311,6 +354,15 @@ mod with_root {
                     string: "answer",
                 }
                 => r#"<Flatten><float>42</float><string>answer</string></Flatten>"#);
+            serialize_as!(empty_struct:
+                ExternallyTagged::Empty {}
+                => "<Empty/>");
+            serialize_as!(value:
+                ExternallyTagged::Value {
+                    float: 42.0,
+                    string: "answer"
+                }
+                => r#"<Value string="answer">42</Value>"#);
         }
 
         mod internally_tagged {
@@ -341,6 +393,15 @@ mod with_root {
                     string: "answer",
                 }
                 => r#"<root><tag>Flatten</tag><float>42</float><string>answer</string></root>"#);
+            serialize_as!(empty_struct:
+                InternallyTagged::Empty {}
+                => r#"<root tag="Empty"/>"#);
+            serialize_as!(value:
+                InternallyTagged::Value {
+                    float: 42.0,
+                    string: "answer"
+                }
+                => r#"<root tag="Value" string="answer">42</root>"#);
         }
 
         mod adjacently_tagged {
@@ -374,6 +435,15 @@ mod with_root {
                     string: "answer",
                 }
                 => r#"<root tag="Flatten"><content><float>42</float><string>answer</string></content></root>"#);
+            serialize_as!(empty_struct:
+                AdjacentlyTagged::Empty {}
+                => r#"<root tag="Empty"><content/></root>"#);
+            serialize_as!(value:
+                AdjacentlyTagged::Value {
+                    float: 42.0,
+                    string: "answer",
+                }
+                => r#"<root tag="Value"><content string="answer">42</content></root>"#);
         }
 
         mod untagged {
@@ -409,6 +479,15 @@ mod with_root {
                     string: "answer",
                 }
                 => r#"<root><float>42</float><string>answer</string></root>"#);
+            serialize_as!(empty_struct:
+                Untagged::Empty {}
+                => "<root/>");
+            serialize_as!(value:
+                Untagged::Value {
+                    float: 42.0,
+                    string: "answer"
+                }
+                => r#"<root string="answer">42</root>"#);
         }
     }
 }

From 0336dcbca6574fa6e63c44c05bc2206b678d44b5 Mon Sep 17 00:00:00 2001
From: Mingun <alexander_sergey@mail.ru>
Date: Tue, 30 Aug 2022 20:52:00 +0500
Subject: [PATCH 10/11] Change `DeError::Unsupported` to store `Cow` instead of
 plain `&str`

---
 Changelog.md          |  4 ++++
 src/de/escape.rs      |  2 +-
 src/de/map.rs         |  4 +++-
 src/de/mod.rs         |  2 +-
 src/de/simple_type.rs | 16 ++++++++--------
 src/de/var.rs         |  2 +-
 src/errors.rs         | 18 ++++++++++--------
 src/se/mod.rs         |  4 +++-
 8 files changed, 31 insertions(+), 21 deletions(-)

diff --git a/Changelog.md b/Changelog.md
index 36db39d9..f20f4bdc 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -16,6 +16,10 @@
 
 ### Misc Changes
 
+- [#468]: Content of `DeError::Unsupported` changed from `&'static str` to `Cow<'static, str>`
+
+[#468]: https://github.com/tafia/quick-xml/pull/468
+
 ## 0.24.0 -- 2022-08-28
 
 ### New Features
diff --git a/src/de/escape.rs b/src/de/escape.rs
index 976ab109..2a05a250 100644
--- a/src/de/escape.rs
+++ b/src/de/escape.rs
@@ -81,7 +81,7 @@ impl<'de, 'a> serde::Deserializer<'de> for EscapedDeserializer<'a> {
         V: Visitor<'de>,
     {
         Err(DeError::Unsupported(
-            "binary data content is not supported by XML format",
+            "binary data content is not supported by XML format".into(),
         ))
     }
 
diff --git a/src/de/map.rs b/src/de/map.rs
index 08538ec9..76524e68 100644
--- a/src/de/map.rs
+++ b/src/de/map.rs
@@ -752,7 +752,9 @@ where
                         self.map.de.reader.decoder(),
                     )
                     .deserialize_seq(visitor),
-                    e => Err(DeError::Custom(format!("Unsupported event {:?}", e))),
+                    e => Err(DeError::Unsupported(
+                        format!("unsupported event {:?}", e).into(),
+                    )),
                 };
                 // TODO: May be assert that here we expect only matching closing tag?
                 self.map.de.read_to_end(e.name())?;
diff --git a/src/de/mod.rs b/src/de/mod.rs
index a0235526..e2593363 100644
--- a/src/de/mod.rs
+++ b/src/de/mod.rs
@@ -81,7 +81,7 @@ macro_rules! deserialize_primitives {
         where
             V: Visitor<'de>,
         {
-            Err(DeError::Unsupported("binary data content is not supported by XML format"))
+            Err(DeError::Unsupported("binary data content is not supported by XML format".into()))
         }
 
         /// Forwards deserialization to the [`deserialize_bytes`](#method.deserialize_bytes).
diff --git a/src/de/simple_type.rs b/src/de/simple_type.rs
index 3c2b2ac3..19211099 100644
--- a/src/de/simple_type.rs
+++ b/src/de/simple_type.rs
@@ -47,7 +47,7 @@ macro_rules! unsupported {
             $($(_: $type,)*)?
             _visitor: V
         ) -> Result<V::Value, Self::Error> {
-            Err(DeError::Unsupported($message))
+            Err(DeError::Unsupported($message.into()))
         }
     };
 }
@@ -345,7 +345,7 @@ impl<'de> VariantAccess<'de> for AtomicUnitOnly {
         T: DeserializeSeed<'de>,
     {
         Err(DeError::Unsupported(
-            "enum newtype variants are not supported as `xs:list` items",
+            "enum newtype variants are not supported as `xs:list` items".into(),
         ))
     }
 
@@ -354,7 +354,7 @@ impl<'de> VariantAccess<'de> for AtomicUnitOnly {
         V: Visitor<'de>,
     {
         Err(DeError::Unsupported(
-            "enum tuple variants are not supported as `xs:list` items",
+            "enum tuple variants are not supported as `xs:list` items".into(),
         ))
     }
 
@@ -367,7 +367,7 @@ impl<'de> VariantAccess<'de> for AtomicUnitOnly {
         V: Visitor<'de>,
     {
         Err(DeError::Unsupported(
-            "enum struct variants are not supported as `xs:list` items",
+            "enum struct variants are not supported as `xs:list` items".into(),
         ))
     }
 }
@@ -648,7 +648,7 @@ impl<'de, 'a> Deserializer<'de> for SimpleTypeDeserializer<'de, 'a> {
         V: Visitor<'de>,
     {
         Err(DeError::Unsupported(
-            "binary data content is not supported by XML format",
+            "binary data content is not supported by XML format".into(),
         ))
     }
 
@@ -796,7 +796,7 @@ impl<'de> VariantAccess<'de> for SimpleTypeUnitOnly {
         T: DeserializeSeed<'de>,
     {
         Err(DeError::Unsupported(
-            "enum newtype variants are not supported for XSD `simpleType`s",
+            "enum newtype variants are not supported for XSD `simpleType`s".into(),
         ))
     }
 
@@ -805,7 +805,7 @@ impl<'de> VariantAccess<'de> for SimpleTypeUnitOnly {
         V: Visitor<'de>,
     {
         Err(DeError::Unsupported(
-            "enum tuple variants are not supported for XSD `simpleType`s",
+            "enum tuple variants are not supported for XSD `simpleType`s".into(),
         ))
     }
 
@@ -818,7 +818,7 @@ impl<'de> VariantAccess<'de> for SimpleTypeUnitOnly {
         V: Visitor<'de>,
     {
         Err(DeError::Unsupported(
-            "enum struct variants are not supported for XSD `simpleType`s",
+            "enum struct variants are not supported for XSD `simpleType`s".into(),
         ))
     }
 }
diff --git a/src/de/var.rs b/src/de/var.rs
index 513e896d..2034cedc 100644
--- a/src/de/var.rs
+++ b/src/de/var.rs
@@ -43,7 +43,7 @@ where
             }
             _ => {
                 return Err(DeError::Unsupported(
-                    "Invalid event for Enum, expecting `Text` or `Start`",
+                    "Invalid event for Enum, expecting `Text` or `Start`".into(),
                 ))
             }
         };
diff --git a/src/errors.rs b/src/errors.rs
index 0f23590f..746912a5 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -3,6 +3,8 @@
 use crate::escape::EscapeError;
 use crate::events::attributes::AttrError;
 use crate::utils::write_byte_string;
+use std::fmt;
+use std::io::Error as IoError;
 use std::str::Utf8Error;
 use std::string::FromUtf8Error;
 
@@ -10,7 +12,7 @@ use std::string::FromUtf8Error;
 #[derive(Debug)]
 pub enum Error {
     /// IO error
-    Io(::std::io::Error),
+    Io(IoError),
     /// Input decoding error. If `encoding` feature is disabled, contains `None`,
     /// otherwise contains the UTF-8 decoding error
     NonDecodable(Option<Utf8Error>),
@@ -39,10 +41,10 @@ pub enum Error {
     UnknownPrefix(Vec<u8>),
 }
 
-impl From<::std::io::Error> for Error {
+impl From<IoError> for Error {
     /// Creates a new `Error::Io` from the given error
     #[inline]
-    fn from(error: ::std::io::Error) -> Error {
+    fn from(error: IoError) -> Error {
         Error::Io(error)
     }
 }
@@ -81,8 +83,8 @@ impl From<AttrError> for Error {
 /// A specialized `Result` type where the error is hard-wired to [`Error`].
 pub type Result<T> = std::result::Result<T, Error>;
 
-impl std::fmt::Display for Error {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Error::Io(e) => write!(f, "I/O error: {}", e),
             Error::NonDecodable(None) => write!(f, "Malformed input, decoding impossible"),
@@ -132,7 +134,7 @@ pub mod serialize {
 
     use super::*;
     use crate::utils::write_byte_string;
-    use std::fmt;
+    use std::borrow::Cow;
     #[cfg(feature = "overlapped-lists")]
     use std::num::NonZeroUsize;
     use std::num::{ParseFloatError, ParseIntError};
@@ -186,7 +188,7 @@ pub mod serialize {
         /// An attempt to deserialize to a type, that is not supported by the XML
         /// store at current position, for example, attempt to deserialize `struct`
         /// from attribute or attempt to deserialize binary data.
-        Unsupported(&'static str),
+        Unsupported(Cow<'static, str>),
         /// Too many events were skipped while deserializing a sequence, event limit
         /// exceeded. The limit was provided as an argument
         #[cfg(feature = "overlapped-lists")]
@@ -214,7 +216,7 @@ pub mod serialize {
                 }
                 DeError::UnexpectedEof => write!(f, "Unexpected `Event::Eof`"),
                 DeError::ExpectedStart => write!(f, "Expecting `Event::Start`"),
-                DeError::Unsupported(s) => write!(f, "Unsupported operation {}", s),
+                DeError::Unsupported(s) => write!(f, "Unsupported operation: {}", s),
                 #[cfg(feature = "overlapped-lists")]
                 DeError::TooManyEvents(s) => write!(f, "Deserializer buffers {} events, limit exceeded", s),
             }
diff --git a/src/se/mod.rs b/src/se/mod.rs
index df7556c7..4f6d95a0 100644
--- a/src/se/mod.rs
+++ b/src/se/mod.rs
@@ -209,7 +209,9 @@ impl<'r, 'w, W: Write> ser::Serializer for &'w mut Serializer<'r, W> {
     fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, DeError> {
         // TODO: I imagine you'd want to use base64 here.
         // Not sure how to roundtrip effectively though...
-        Err(DeError::Unsupported("serialize_bytes"))
+        Err(DeError::Unsupported(
+            "`serialize_bytes` not supported yet".into(),
+        ))
     }
 
     fn serialize_none(self) -> Result<Self::Ok, DeError> {

From b2d57e6db1316048c9722bdae70f5426191b9ba7 Mon Sep 17 00:00:00 2001
From: Mingun <alexander_sergey@mail.ru>
Date: Tue, 30 Aug 2022 18:23:59 +0500
Subject: [PATCH 11/11] Ensure that map keys are restricted to only types that
 can be serialized as primitives

Co-authored-by: Daniel Alley <dalley@redhat.com>
---
 Changelog.md  |   1 +
 src/errors.rs |   7 ++
 src/se/key.rs | 297 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/se/mod.rs |  78 +++++++++++++
 src/se/var.rs |  21 ++--
 src/utils.rs  |  22 ++++
 6 files changed, 418 insertions(+), 8 deletions(-)
 create mode 100644 src/se/key.rs

diff --git a/Changelog.md b/Changelog.md
index f20f4bdc..22d67156 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -17,6 +17,7 @@
 ### Misc Changes
 
 - [#468]: Content of `DeError::Unsupported` changed from `&'static str` to `Cow<'static, str>`
+- [#468]: Ensure that map keys are restricted to only types that can be serialized as primitives
 
 [#468]: https://github.com/tafia/quick-xml/pull/468
 
diff --git a/src/errors.rs b/src/errors.rs
index 746912a5..57f8f3b1 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -294,4 +294,11 @@ pub mod serialize {
             Self::InvalidFloat(e)
         }
     }
+
+    impl From<fmt::Error> for DeError {
+        #[inline]
+        fn from(e: fmt::Error) -> Self {
+            Self::Custom(e.to_string())
+        }
+    }
 }
diff --git a/src/se/key.rs b/src/se/key.rs
new file mode 100644
index 00000000..0adf84a1
--- /dev/null
+++ b/src/se/key.rs
@@ -0,0 +1,297 @@
+use crate::errors::serialize::DeError;
+use serde::ser::{Impossible, Serialize, Serializer};
+use serde::serde_if_integer128;
+use std::fmt::Write;
+
+/// A serializer, that ensures, that only plain types can be serialized,
+/// so result can be used as an XML tag or attribute name.
+///
+/// This serializer does not check that name does not contain characters that
+/// [not allowed] in XML names, because in some cases it should pass names
+/// that would be filtered on higher level.
+///
+/// [not allowed]: https://www.w3.org/TR/REC-xml/#sec-common-syn
+pub struct XmlNameSerializer<W: Write> {
+    /// Writer to which this serializer writes content
+    pub writer: W,
+}
+
+impl<W: Write> XmlNameSerializer<W> {
+    #[inline]
+    fn write_str(&mut self, value: &str) -> Result<(), DeError> {
+        Ok(self.writer.write_str(value)?)
+    }
+}
+
+impl<W: Write> Serializer for XmlNameSerializer<W> {
+    type Ok = W;
+    type Error = DeError;
+
+    type SerializeSeq = Impossible<Self::Ok, Self::Error>;
+    type SerializeTuple = Impossible<Self::Ok, Self::Error>;
+    type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
+    type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
+    type SerializeMap = Impossible<Self::Ok, Self::Error>;
+    type SerializeStruct = Impossible<Self::Ok, Self::Error>;
+    type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;
+
+    write_primitive!();
+
+    fn serialize_str(mut self, value: &str) -> Result<Self::Ok, Self::Error> {
+        self.write_str(value)?;
+        Ok(self.writer)
+    }
+
+    /// We cannot store anything, so the absence of a unit and presence of it
+    /// does not differ, so serialization of unit returns `Err(Unsupported)`
+    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
+        Err(DeError::Unsupported(
+            "unit type `()` cannot be serialized as an XML tag name".into(),
+        ))
+    }
+
+    /// We cannot store both a variant discriminant and a variant value,
+    /// so serialization of enum newtype variant returns `Err(Unsupported)`
+    fn serialize_newtype_variant<T: ?Sized + Serialize>(
+        self,
+        name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        _value: &T,
+    ) -> Result<Self::Ok, DeError> {
+        Err(DeError::Unsupported(
+            format!(
+                "enum newtype variant `{}::{}` cannot be serialized as an XML tag name",
+                name, variant
+            )
+            .into(),
+        ))
+    }
+
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+        Err(DeError::Unsupported(
+            "sequence cannot be serialized as an XML tag name".into(),
+        ))
+    }
+
+    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+        Err(DeError::Unsupported(
+            "tuple cannot be serialized as an XML tag name".into(),
+        ))
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+        Err(DeError::Unsupported(
+            format!(
+                "tuple struct `{}` cannot be serialized as an XML tag name",
+                name
+            )
+            .into(),
+        ))
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+        Err(DeError::Unsupported(
+            format!(
+                "enum tuple variant `{}::{}` cannot be serialized as an XML tag name",
+                name, variant
+            )
+            .into(),
+        ))
+    }
+
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+        Err(DeError::Unsupported(
+            "map cannot be serialized as an XML tag name".into(),
+        ))
+    }
+
+    fn serialize_struct(
+        self,
+        name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStruct, Self::Error> {
+        Err(DeError::Unsupported(
+            format!("struct `{}` cannot be serialized as an XML tag name", name).into(),
+        ))
+    }
+
+    fn serialize_struct_variant(
+        self,
+        name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant, Self::Error> {
+        Err(DeError::Unsupported(
+            format!(
+                "enum struct variant `{}::{}` cannot be serialized as an XML tag name",
+                name, variant
+            )
+            .into(),
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::utils::Bytes;
+    use pretty_assertions::assert_eq;
+    use serde::Serialize;
+    use std::collections::BTreeMap;
+
+    #[derive(Debug, Serialize, PartialEq)]
+    struct Unit;
+
+    #[derive(Debug, Serialize, PartialEq)]
+    #[serde(rename = "<\"&'>")]
+    struct UnitEscaped;
+
+    #[derive(Debug, Serialize, PartialEq)]
+    struct Newtype(bool);
+
+    #[derive(Debug, Serialize, PartialEq)]
+    struct Tuple(&'static str, usize);
+
+    #[derive(Debug, Serialize, PartialEq)]
+    struct Struct {
+        key: &'static str,
+        val: usize,
+    }
+
+    #[derive(Debug, Serialize, PartialEq)]
+    enum Enum {
+        Unit,
+        #[serde(rename = "<\"&'>")]
+        UnitEscaped,
+        Newtype(bool),
+        Tuple(&'static str, usize),
+        Struct {
+            key: &'static str,
+            val: usize,
+        },
+    }
+
+    /// Checks that given `$data` successfully serialized as `$expected`
+    macro_rules! serialize_as {
+        ($name:ident: $data:expr => $expected:literal) => {
+            #[test]
+            fn $name() {
+                let ser = XmlNameSerializer {
+                    writer: String::new(),
+                };
+
+                let buffer = $data.serialize(ser).unwrap();
+                assert_eq!(buffer, $expected);
+            }
+        };
+    }
+
+    /// Checks that attempt to serialize given `$data` results to a
+    /// serialization error `$kind` with `$reason`
+    macro_rules! err {
+        ($name:ident: $data:expr => $kind:ident($reason:literal)) => {
+            #[test]
+            fn $name() {
+                let mut buffer = String::new();
+                let ser = XmlNameSerializer {
+                    writer: &mut buffer,
+                };
+
+                match $data.serialize(ser).unwrap_err() {
+                    DeError::$kind(e) => assert_eq!(e, $reason),
+                    e => panic!(
+                        "Expected `{}({})`, found `{:?}`",
+                        stringify!($kind),
+                        $reason,
+                        e
+                    ),
+                }
+                assert_eq!(buffer, "");
+            }
+        };
+    }
+
+    serialize_as!(false_: false => "false");
+    serialize_as!(true_:  true  => "true");
+
+    serialize_as!(i8_:    -42i8                => "-42");
+    serialize_as!(i16_:   -4200i16             => "-4200");
+    serialize_as!(i32_:   -42000000i32         => "-42000000");
+    serialize_as!(i64_:   -42000000000000i64   => "-42000000000000");
+    serialize_as!(isize_: -42000000000000isize => "-42000000000000");
+
+    serialize_as!(u8_:    42u8                => "42");
+    serialize_as!(u16_:   4200u16             => "4200");
+    serialize_as!(u32_:   42000000u32         => "42000000");
+    serialize_as!(u64_:   42000000000000u64   => "42000000000000");
+    serialize_as!(usize_: 42000000000000usize => "42000000000000");
+
+    serde_if_integer128! {
+        serialize_as!(i128_: -420000000000000000000000000000i128 => "-420000000000000000000000000000");
+        serialize_as!(u128_:  420000000000000000000000000000u128 => "420000000000000000000000000000");
+    }
+
+    serialize_as!(f32_: 4.2f32 => "4.2");
+    serialize_as!(f64_: 4.2f64 => "4.2");
+
+    serialize_as!(char_non_escaped: 'h' => "h");
+    serialize_as!(char_lt:   '<' => "<");
+    serialize_as!(char_gt:   '>' => ">");
+    serialize_as!(char_amp:  '&' => "&");
+    serialize_as!(char_apos: '\'' => "'");
+    serialize_as!(char_quot: '"' => "\"");
+
+    serialize_as!(str_valid_name: "valid-name" => "valid-name");
+    serialize_as!(str_space: "string with spaces" => "string with spaces");
+    serialize_as!(str_lt:   "string<" => "string<");
+    serialize_as!(str_gt:   "string>" => "string>");
+    serialize_as!(str_amp:  "string&" => "string&");
+    serialize_as!(str_apos: "string'" => "string'");
+    serialize_as!(str_quot: "string\"" => "string\"");
+
+    err!(bytes: Bytes(b"<\"escaped & bytes'>")
+        => Unsupported("`serialize_bytes` not supported yet"));
+
+    serialize_as!(option_none: Option::<&str>::None => "");
+    serialize_as!(option_some: Some("non-escaped-string") => "non-escaped-string");
+
+    err!(unit: ()
+        => Unsupported("unit type `()` cannot be serialized as an XML tag name"));
+    serialize_as!(unit_struct: Unit => "Unit");
+    serialize_as!(unit_struct_escaped: UnitEscaped => "<\"&'>");
+
+    serialize_as!(enum_unit: Enum::Unit => "Unit");
+    serialize_as!(enum_unit_escaped: Enum::UnitEscaped => "<\"&'>");
+
+    serialize_as!(newtype: Newtype(true) => "true");
+    err!(enum_newtype: Enum::Newtype(false)
+        => Unsupported("enum newtype variant `Enum::Newtype` cannot be serialized as an XML tag name"));
+
+    err!(seq: vec![1, 2, 3]
+        => Unsupported("sequence cannot be serialized as an XML tag name"));
+    err!(tuple: ("<\"&'>", "with\t\r\n spaces", 3usize)
+        => Unsupported("tuple cannot be serialized as an XML tag name"));
+    err!(tuple_struct: Tuple("first", 42)
+        => Unsupported("tuple struct `Tuple` cannot be serialized as an XML tag name"));
+    err!(enum_tuple: Enum::Tuple("first", 42)
+        => Unsupported("enum tuple variant `Enum::Tuple` cannot be serialized as an XML tag name"));
+
+    err!(map: BTreeMap::from([("_1", 2), ("_3", 4)])
+        => Unsupported("map cannot be serialized as an XML tag name"));
+    err!(struct_: Struct { key: "answer", val: 42 }
+        => Unsupported("struct `Struct` cannot be serialized as an XML tag name"));
+    err!(enum_struct: Enum::Struct { key: "answer", val: 42 }
+        => Unsupported("enum struct variant `Enum::Struct` cannot be serialized as an XML tag name"));
+}
diff --git a/src/se/mod.rs b/src/se/mod.rs
index 4f6d95a0..42fed721 100644
--- a/src/se/mod.rs
+++ b/src/se/mod.rs
@@ -1,5 +1,83 @@
 //! Module to handle custom serde `Serializer`
 
+/// Implements writing primitives to the underlying writer.
+/// Implementor must provide `write_str(self, &str) -> Result<(), DeError>` method
+macro_rules! write_primitive {
+    ($method:ident ( $ty:ty )) => {
+        fn $method(mut self, value: $ty) -> Result<Self::Ok, Self::Error> {
+            self.write_str(&value.to_string())?;
+            Ok(self.writer)
+        }
+    };
+    () => {
+        fn serialize_bool(mut self, value: bool) -> Result<Self::Ok, Self::Error> {
+            self.write_str(if value { "true" } else { "false" })?;
+            Ok(self.writer)
+        }
+
+        write_primitive!(serialize_i8(i8));
+        write_primitive!(serialize_i16(i16));
+        write_primitive!(serialize_i32(i32));
+        write_primitive!(serialize_i64(i64));
+
+        write_primitive!(serialize_u8(u8));
+        write_primitive!(serialize_u16(u16));
+        write_primitive!(serialize_u32(u32));
+        write_primitive!(serialize_u64(u64));
+
+        serde_if_integer128! {
+            write_primitive!(serialize_i128(i128));
+            write_primitive!(serialize_u128(u128));
+        }
+
+        write_primitive!(serialize_f32(f32));
+        write_primitive!(serialize_f64(f64));
+
+        fn serialize_char(self, value: char) -> Result<Self::Ok, Self::Error> {
+            self.serialize_str(&value.to_string())
+        }
+
+        fn serialize_bytes(self, _value: &[u8]) -> Result<Self::Ok, Self::Error> {
+            //TODO: customization point - allow user to decide how to encode bytes
+            Err(DeError::Unsupported(
+                "`serialize_bytes` not supported yet".into(),
+            ))
+        }
+
+        fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
+            Ok(self.writer)
+        }
+
+        fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, Self::Error> {
+            value.serialize(self)
+        }
+
+        fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
+            self.serialize_str(name)
+        }
+
+        fn serialize_unit_variant(
+            self,
+            _name: &'static str,
+            _variant_index: u32,
+            variant: &'static str,
+        ) -> Result<Self::Ok, Self::Error> {
+            self.serialize_str(variant)
+        }
+
+        fn serialize_newtype_struct<T: ?Sized + Serialize>(
+            self,
+            _name: &'static str,
+            value: &T,
+        ) -> Result<Self::Ok, Self::Error> {
+            value.serialize(self)
+        }
+    };
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+mod key;
 mod var;
 
 use self::var::{Map, Seq, Struct, Tuple};
diff --git a/src/se/var.rs b/src/se/var.rs
index 76e09a56..eb154406 100644
--- a/src/se/var.rs
+++ b/src/se/var.rs
@@ -2,6 +2,7 @@ use crate::{
     de::{INNER_VALUE, UNFLATTEN_PREFIX},
     errors::{serialize::DeError, Error},
     events::{BytesEnd, BytesStart, Event},
+    se::key::XmlNameSerializer,
     se::Serializer,
     writer::Writer,
 };
@@ -64,17 +65,21 @@ where
         key: &K,
         value: &V,
     ) -> Result<(), DeError> {
-        // TODO: Is it possible to ensure our key is never a composite type?
-        // Anything which isn't a "primitive" would lead to malformed XML here...
-        write!(self.parent.writer.inner(), "<").map_err(Error::Io)?;
-        key.serialize(&mut *self.parent)?;
-        write!(self.parent.writer.inner(), ">").map_err(Error::Io)?;
+        let key = key.serialize(XmlNameSerializer {
+            writer: String::new(),
+        })?;
+
+        let writer = self.parent.writer.inner();
+        writer.write_all(b"<").map_err(Error::Io)?;
+        writer.write_all(key.as_bytes()).map_err(Error::Io)?;
+        writer.write_all(b">").map_err(Error::Io)?;
 
         value.serialize(&mut *self.parent)?;
 
-        write!(self.parent.writer.inner(), "</").map_err(Error::Io)?;
-        key.serialize(&mut *self.parent)?;
-        write!(self.parent.writer.inner(), ">").map_err(Error::Io)?;
+        let writer = self.parent.writer.inner();
+        writer.write_all(b"</").map_err(Error::Io)?;
+        writer.write_all(key.as_bytes()).map_err(Error::Io)?;
+        writer.write_all(b">").map_err(Error::Io)?;
         Ok(())
     }
 }
diff --git a/src/utils.rs b/src/utils.rs
index 130532a3..185cff40 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -3,6 +3,8 @@ use std::fmt::{self, Debug, Formatter};
 
 #[cfg(feature = "serialize")]
 use serde::de::{Deserialize, Deserializer, Error, Visitor};
+#[cfg(feature = "serialize")]
+use serde::ser::{Serialize, Serializer};
 
 pub fn write_cow_string(f: &mut Formatter, cow_string: &Cow<[u8]>) -> fmt::Result {
     match cow_string {
@@ -76,6 +78,16 @@ impl<'de> Deserialize<'de> for ByteBuf {
     }
 }
 
+#[cfg(feature = "serialize")]
+impl Serialize for ByteBuf {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_bytes(&self.0)
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /// Wrapper around `&[u8]` that has a human-readable debug representation:
@@ -117,6 +129,16 @@ impl<'de> Deserialize<'de> for Bytes<'de> {
     }
 }
 
+#[cfg(feature = "serialize")]
+impl<'de> Serialize for Bytes<'de> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_bytes(self.0)
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #[cfg(test)]