Add tests for deserialization of sequences from empty xs:list representation

failures:

---- fixed_name::fixed_size::xs_list::empty stdout ----
[tests\helpers\mod.rs:14] source = "\n                    <root>\n                        <item/>\n                    </root>\n                    "
thread 'fixed_name::fixed_size::xs_list::empty' panicked at tests/serde-de-seq.rs:871:18:
called `Result::unwrap()` on an `Err` value: UnexpectedEof
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

---- fixed_name::variable_size::xs_list::empty stdout ----
[tests\helpers\mod.rs:14] source = "\n                    <root>\n                        <item/>\n                    </root>\n                    "
thread 'fixed_name::variable_size::xs_list::empty' panicked at tests/serde-de-seq.rs:1697:18:
called `Result::unwrap()` on an `Err` value: UnexpectedEof

---- variable_name::fixed_size::xs_list::empty stdout ----
[tests\helpers\mod.rs:14] source = "\n                    <root>\n                        <item/>\n                    </root>\n                    "
thread 'variable_name::fixed_size::xs_list::empty' panicked at tests/serde-de-seq.rs:2967:18:
called `Result::unwrap()` on an `Err` value: UnexpectedEof

---- variable_name::variable_size::xs_list::empty stdout ----
[tests\helpers\mod.rs:14] source = "\n                    <root>\n                        <item/>\n                    </root>\n                    "
thread 'variable_name::variable_size::xs_list::empty' panicked at tests/serde-de-seq.rs:4066:18:
called `Result::unwrap()` on an `Err` value: UnexpectedEof

failures:
    fixed_name::fixed_size::xs_list::empty
    fixed_name::variable_size::xs_list::empty
    variable_name::fixed_size::xs_list::empty
    variable_name::variable_size::xs_list::empty

Author: Mingun

tests/serde-de-seq.rs

@@ -802,6 +802,15 @@ mod fixed_name {
             use super::*;
             use pretty_assertions::assert_eq;
 
+            #[derive(Debug, Deserialize, PartialEq)]
+            struct List {
+                /// Outer list mapped to elements, inner -- to `xs:list`.
+                ///
+                /// `#[serde(default)]` is not required, because correct
+                /// XML will always contains at least 1 element.
+                item: [Vec<String>; 1],
+            }
+
             /// Special case: zero elements
             #[test]
             fn zero() {
@@ -832,15 +841,6 @@ mod fixed_name {
             /// Special case: one element
             #[test]
             fn one() {
-                #[derive(Debug, Deserialize, PartialEq)]
-                struct List {
-                    /// Outer list mapped to elements, inner -- to `xs:list`.
-                    ///
-                    /// `#[serde(default)]` is not required, because correct
-                    /// XML will always contains at least 1 element.
-                    item: [Vec<String>; 1],
-                }
-
                 let data: List = from_str(
                     r#"
                     <root>
@@ -858,6 +858,21 @@ mod fixed_name {
                 );
             }
 
+            /// Special case: empty `xs:list`
+            #[test]
+            fn empty() {
+                let data: List = from_str(
+                    r#"
+                    <root>
+                        <item/>
+                    </root>
+                    "#,
+                )
+                .unwrap();
+
+                assert_eq!(data, List { item: [vec![]] });
+            }
+
             /// Special case: outer list is always mapped to an elements sequence,
             /// not to an `xs:list`
             #[test]
@@ -1669,6 +1684,21 @@ mod fixed_name {
                 );
             }
 
+            /// Special case: empty `xs:list`
+            #[test]
+            fn empty() {
+                let data: List = from_str(
+                    r#"
+                    <root>
+                        <item/>
+                    </root>
+                    "#,
+                )
+                .unwrap();
+
+                assert_eq!(data, List { item: vec![vec![]] });
+            }
+
             /// Special case: outer list is always mapped to an elements sequence,
             /// not to an `xs:list`
             #[test]
@@ -2866,6 +2896,16 @@ mod variable_name {
             use super::*;
             use pretty_assertions::assert_eq;
 
+            #[derive(Debug, Deserialize, PartialEq)]
+            struct List {
+                /// Outer list mapped to elements, inner -- to `xs:list`.
+                ///
+                /// `#[serde(default)]` is not required, because correct
+                /// XML will always contains at least 1 element.
+                #[serde(rename = "$value")]
+                element: [Vec<String>; 1],
+            }
+
             /// Special case: zero elements
             #[test]
             fn zero() {
@@ -2897,16 +2937,6 @@ mod variable_name {
             /// Special case: one element
             #[test]
             fn one() {
-                #[derive(Debug, Deserialize, PartialEq)]
-                struct List {
-                    /// Outer list mapped to elements, inner -- to `xs:list`.
-                    ///
-                    /// `#[serde(default)]` is not required, because correct
-                    /// XML will always contains at least 1 element.
-                    #[serde(rename = "$value")]
-                    element: [Vec<String>; 1],
-                }
-
                 let data: List = from_str(
                     r#"
                     <root>
@@ -2924,6 +2954,21 @@ mod variable_name {
                 );
             }
 
+            /// Special case: empty `xs:list`
+            #[test]
+            fn empty() {
+                let data: List = from_str(
+                    r#"
+                    <root>
+                        <item/>
+                    </root>
+                    "#,
+                )
+                .unwrap();
+
+                assert_eq!(data, List { element: [vec![]] });
+            }
+
             /// Special case: outer list is always mapped to an elements sequence,
             /// not to an `xs:list`
             #[test]
@@ -4008,6 +4053,26 @@ mod variable_name {
                 );
             }
 
+            /// Special case: empty `xs:list`
+            #[test]
+            fn empty() {
+                let data: List = from_str(
+                    r#"
+                    <root>
+                        <item/>
+                    </root>
+                    "#,
+                )
+                .unwrap();
+
+                assert_eq!(
+                    data,
+                    List {
+                        element: vec![vec![]]
+                    }
+                );
+            }
+
             /// Special case: outer list is always mapped to an elements sequence,
             /// not to an `xs:list`
             #[test]