Change expected enum representation in tests according to new policy

New representation policy is compatible with serde>=1.0.181 and also more correct
and consistent with general mapping rules.

General rules of new policy:
- In `$value` field the representation is always the same as top-level representation;
- In `$text` field the representation is always the same as in normal field, but surrounding tags with field name are removed;
- In normal field the representation is always contains a tag with field name.

The tables below summarizes the representation policy. For examples in fields only content
at place of `...` is shown:
```
<Container>...</Container>
```

The struct which contains field looks like:
```
struct Container {
  field: Enum,

  #[serde(rename = "$text")]
  text: Enum,

  #[serde(rename = "$value")]
  value: Enum,
}
```

Normal enum variant
-------------------

### Old (before this commit) representation
|Kind   |Top-level, in normal and `$value` fields |In `$text` field|
|-------|-----------------------------------------|----------------|
|Unit   |`<Unit/>`                                |_(empty)_       |
|Newtype|`<Newtype>42</Newtype>`                  |`42`            |
|Tuple  |`<Tuple>42</Tuple><Tuple>answer</Tuple>` |`42 answer`     |
|Struct |`<Struct><q>42</q><a>answer</a></Struct>`|Err(Unsupported)|

### New (since this commit)
|Kind   |Top-level and in `$value` field          |In normal field      |In `$text` field|
|-------|-----------------------------------------|---------------------|----------------|
|Unit   |`<Unit/>`                                |`<field>Unit</field>`|`Unit`          |
|Newtype|`<Newtype>42</Newtype>`                  |Err(Unsupported)     |Err(Unsupported)|
|Tuple  |`<Tuple>42</Tuple><Tuple>answer</Tuple>` |Err(Unsupported)     |Err(Unsupported)|
|Struct |`<Struct><q>42</q><a>answer</a></Struct>`|Err(Unsupported)     |Err(Unsupported)|

`$text` enum variant
--------------------

`<field>` in top-level serialization is the name of top-level element, serialization is impossible if it is not defined in the serializer.

### Old (before this commit) representation
|Kind   |In `$value` field              |In normal field           |In `$text` field|
|-------|-------------------------------|--------------------------|----------------|
|Unit   |_(empty)_                      |`<field/>`                |_(empty)_       |
|Newtype|`42`                           |`<field>42</field>`       |`42`            |
|Tuple  |`42 answer`                    |`<field>42 answer</field>`|`42 answer`     |
|Struct |Err(Unsupported)               |Err(Unsupported)          |Err(Unsupported)|

### New (since this commit)
|Kind   |Top-level and in `$value` field|In normal field           |In `$text` field|
|-------|-------------------------------|--------------------------|----------------|
|Unit   |_(empty)_                      |`<field/>`                |_(empty)_       |
|Newtype|`42`                           |Err(Unsupported)          |Err(Unsupported)|
|Tuple  |`42 answer`                    |Err(Unsupported)          |Err(Unsupported)|
|Struct |Err(Unsupported)               |Err(Unsupported)          |Err(Unsupported)|

failures (28):
  --lib (14)
    se::element::tests::expand_empty_elements::enum_unit
    se::element::tests::expand_empty_elements::enum_unit_escaped
    se::element::tests::with_indent::attributes::enum_
    se::element::tests::with_indent::enum_newtype
    se::element::tests::with_indent::enum_struct
    se::element::tests::with_indent::enum_tuple
    se::element::tests::with_indent::enum_unit
    se::element::tests::with_indent::enum_unit_escaped
    se::element::tests::without_indent::attributes::enum_
    se::element::tests::without_indent::enum_newtype
    se::element::tests::without_indent::enum_struct
    se::element::tests::without_indent::enum_tuple
    se::element::tests::without_indent::enum_unit
    se::element::tests::without_indent::enum_unit_escaped
  serde-se (14):
    without_root::enum_::externally_tagged::normal_field2::empty_struct
    without_root::enum_::externally_tagged::normal_field2::newtype
    without_root::enum_::externally_tagged::normal_field2::struct_
    without_root::enum_::externally_tagged::normal_field2::tuple
    without_root::enum_::externally_tagged::normal_field2::unit
    without_root::enum_::externally_tagged::normal_field::empty_struct
    without_root::enum_::externally_tagged::normal_field::newtype
    without_root::enum_::externally_tagged::normal_field::struct_
    without_root::enum_::externally_tagged::normal_field::tuple
    without_root::enum_::externally_tagged::normal_field::unit
    without_root::enum_::externally_tagged::text_variant::normal_field::newtype
    without_root::enum_::externally_tagged::text_variant::normal_field::tuple
    without_root::enum_::externally_tagged::text_variant::normal_field::unit
    without_root::enum_::externally_tagged::text_variant::text_field::unit

src/se/element.rs

@@ -670,12 +670,12 @@ mod tests {
         serialize_as!(unit_struct: Unit => "<root/>");
         serialize_as!(unit_struct_escaped: UnitEscaped => "<root/>");
 
-        serialize_as!(enum_unit: Enum::Unit => "<Unit/>");
-        err!(enum_unit_escaped: Enum::UnitEscaped
-            => Unsupported("character `<` is not allowed at the start of an XML name `<\"&'>`"));
+        serialize_as!(enum_unit: Enum::Unit => "<root>Unit</root>");
+        serialize_as!(enum_unit_escaped: Enum::UnitEscaped => "<root>&lt;&quot;&amp;&apos;&gt;</root>");
 
         serialize_as!(newtype: Newtype(42) => "<root>42</root>");
-        serialize_as!(enum_newtype: Enum::Newtype(42) => "<Newtype>42</Newtype>");
+        err!(enum_newtype: Enum::Newtype(42)
+            => Unsupported("cannot serialize enum newtype variant `Enum::Newtype`"));
 
         serialize_as!(seq: vec![1, 2, 3]
             => "<root>1</root>\
@@ -689,9 +689,8 @@ mod tests {
         serialize_as!(tuple_struct: Tuple("first", 42)
             => "<root>first</root>\
                 <root>42</root>");
-        serialize_as!(enum_tuple: Enum::Tuple("first", 42)
-            => "<Tuple>first</Tuple>\
-                <Tuple>42</Tuple>");
+        err!(enum_tuple: Enum::Tuple("first", 42)
+            => Unsupported("cannot serialize enum tuple variant `Enum::Tuple`"));
 
         serialize_as!(map: BTreeMap::from([("_1", 2), ("_3", 4)])
             => "<root>\
@@ -704,12 +703,8 @@ mod tests {
                     <val>42</val>\
                     <val>42</val>\
                 </root>");
-        serialize_as!(enum_struct: Enum::Struct { key: "answer", val: (42, 42) }
-            => "<Struct>\
-                    <key>answer</key>\
-                    <val>42</val>\
-                    <val>42</val>\
-                </Struct>");
+        err!(enum_struct: Enum::Struct { key: "answer", val: (42, 42) }
+            => Unsupported("cannot serialize enum struct variant `Enum::Struct`"));
 
         /// Special field name `$text` should be serialized as text content.
         /// Sequences serialized as an `xs:list` content
@@ -1216,12 +1211,8 @@ mod tests {
             serialize_as!(struct_after: AttributesAfter { key: "answer", val: 42 }
                 => r#"<root val="42"><key>answer</key></root>"#);
 
-            serialize_as!(enum_: Enum::Attributes { key: "answer", val: (42, 42) }
-                => r#"<Attributes key="answer" val="42 42"/>"#);
-            serialize_as!(enum_before: Enum::AttributesBefore { key: "answer", val: 42 }
-                => r#"<AttributesBefore key="answer"><val>42</val></AttributesBefore>"#);
-            serialize_as!(enum_after: Enum::AttributesAfter { key: "answer", val: 42 }
-                => r#"<AttributesAfter val="42"><key>answer</key></AttributesAfter>"#);
+            err!(enum_: Enum::Attributes { key: "answer", val: (42, 42) }
+                => Unsupported("cannot serialize enum struct variant `Enum::Attributes`"));
 
             /// Test for https://github.com/tafia/quick-xml/issues/252
             mod optional {
@@ -1385,12 +1376,12 @@ mod tests {
         serialize_as!(unit_struct: Unit => "<root/>");
         serialize_as!(unit_struct_escaped: UnitEscaped => "<root/>");
 
-        serialize_as!(enum_unit: Enum::Unit => "<Unit/>");
-        err!(enum_unit_escaped: Enum::UnitEscaped
-            => Unsupported("character `<` is not allowed at the start of an XML name `<\"&'>`"));
+        serialize_as!(enum_unit: Enum::Unit => "<root>Unit</root>");
+        serialize_as!(enum_unit_escaped: Enum::UnitEscaped => "<root>&lt;&quot;&amp;&apos;&gt;</root>");
 
         serialize_as!(newtype: Newtype(42) => "<root>42</root>");
-        serialize_as!(enum_newtype: Enum::Newtype(42) => "<Newtype>42</Newtype>");
+        err!(enum_newtype: Enum::Newtype(42)
+            => Unsupported("cannot serialize enum newtype variant `Enum::Newtype`"));
 
         serialize_as!(seq: vec![1, 2, 3]
             => "<root>1</root>\n\
@@ -1404,9 +1395,8 @@ mod tests {
         serialize_as!(tuple_struct: Tuple("first", 42)
             => "<root>first</root>\n\
                 <root>42</root>");
-        serialize_as!(enum_tuple: Enum::Tuple("first", 42)
-            => "<Tuple>first</Tuple>\n\
-                <Tuple>42</Tuple>");
+        err!(enum_tuple: Enum::Tuple("first", 42)
+            => Unsupported("cannot serialize enum tuple variant `Enum::Tuple`"));
 
         serialize_as!(map: BTreeMap::from([("_1", 2), ("_3", 4)])
             => "<root>\n  \
@@ -1419,12 +1409,8 @@ mod tests {
                     <val>42</val>\n  \
                     <val>42</val>\n\
                 </root>");
-        serialize_as!(enum_struct: Enum::Struct { key: "answer", val: (42, 42) }
-            => "<Struct>\n  \
-                    <key>answer</key>\n  \
-                    <val>42</val>\n  \
-                    <val>42</val>\n\
-                </Struct>");
+        err!(enum_struct: Enum::Struct { key: "answer", val: (42, 42) }
+            => Unsupported("cannot serialize enum struct variant `Enum::Struct`"));
 
         /// Special field name `$text` should be serialized as text content.
         /// Sequences serialized as an `xs:list` content
@@ -1960,16 +1946,8 @@ mod tests {
                         <key>answer</key>\n\
                     </root>");
 
-            serialize_as!(enum_: Enum::Attributes { key: "answer", val: (42, 42) }
-                => r#"<Attributes key="answer" val="42 42"/>"#);
-            serialize_as!(enum_before: Enum::AttributesBefore { key: "answer", val: 42 }
-                => "<AttributesBefore key=\"answer\">\n  \
-                        <val>42</val>\n\
-                    </AttributesBefore>");
-            serialize_as!(enum_after: Enum::AttributesAfter { key: "answer", val: 42 }
-                => "<AttributesAfter val=\"42\">\n  \
-                        <key>answer</key>\n\
-                    </AttributesAfter>");
+            err!(enum_: Enum::Attributes { key: "answer", val: (42, 42) }
+                => Unsupported("cannot serialize enum struct variant `Enum::Attributes`"));
 
             /// Test for https://github.com/tafia/quick-xml/issues/252
             mod optional {
@@ -2052,48 +2030,14 @@ mod tests {
             };
         }
 
-        /// 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 = ElementSerializer {
-                        ser: ContentSerializer {
-                            writer: &mut buffer,
-                            level: QuoteLevel::Full,
-                            indent: Indent::None,
-                            write_indent: false,
-                            expand_empty_elements: false,
-                        },
-                        key: XmlName("root"),
-                    };
-
-                    match $data.serialize(ser).unwrap_err() {
-                        DeError::$kind(e) => assert_eq!(e, $reason),
-                        e => panic!(
-                            "Expected `{}({})`, found `{:?}`",
-                            stringify!($kind),
-                            $reason,
-                            e
-                        ),
-                    }
-                    // We can write something before fail
-                    // assert_eq!(buffer, "");
-                }
-            };
-        }
-
         serialize_as!(option_some_empty: Some("") => "<root></root>");
         serialize_as!(option_some_empty_str: Some("") => "<root></root>");
 
         serialize_as!(unit: () => "<root></root>");
         serialize_as!(unit_struct: Unit => "<root></root>");
         serialize_as!(unit_struct_escaped: UnitEscaped => "<root></root>");
 
-        serialize_as!(enum_unit: Enum::Unit => "<Unit></Unit>");
-        err!(enum_unit_escaped: Enum::UnitEscaped
-            => Unsupported("character `<` is not allowed at the start of an XML name `<\"&'>`"));
+        serialize_as!(enum_unit: Enum::Unit => "<root>Unit</root>");
+        serialize_as!(enum_unit_escaped: Enum::UnitEscaped => "<root>&lt;&quot;&amp;&apos;&gt;</root>");
     }
 }