Add test to ensure, that entities which expands to the XML fragments are parsed

Remove previous test because it is covered by the new one

Author: Mingun

Cargo.toml

@@ -233,6 +233,11 @@ name = "serde-de-enum"
 required-features = ["serialize"]
 path = "tests/serde-de-enum.rs"
 
+[[test]]
+name = "serde-de-references"
+required-features = ["serialize"]
+path = "tests/serde-de-references.rs"
+
 [[test]]
 name = "serde-de-seq"
 required-features = ["serialize"]

tests/serde-de-references.rs

@@ -0,0 +1,94 @@
+use std::borrow::Cow;
+use std::convert::Infallible;
+
+use quick_xml::de::Deserializer;
+use quick_xml::events::BytesText;
+use quick_xml::reader::{EntityResolver, EntityResolverFactory, ReplacementText};
+
+use pretty_assertions::assert_eq;
+use serde::Deserialize;
+
+#[derive(Clone, Copy)]
+struct TestEntityResolver {
+    capture_called: bool,
+}
+
+impl<'i> EntityResolverFactory<'i> for TestEntityResolver {
+    type CaptureError = Infallible;
+    type Resolver = Self;
+
+    fn new_resolver(&mut self) -> Self::Resolver {
+        *self
+    }
+}
+
+impl<'i> EntityResolver<'i> for TestEntityResolver {
+    type CaptureError = Infallible;
+
+    fn capture(&mut self, _doctype: BytesText) -> Result<(), Self::CaptureError> {
+        self.capture_called = true;
+        Ok(())
+    }
+
+    fn resolve<'e>(&self, entity: &str) -> Option<ReplacementText<'i, 'e>> {
+        assert!(
+            self.capture_called,
+            "`EntityResolver::capture` should be called before `EntityResolver::resolve(\"{}\")`",
+            entity,
+        );
+
+        match dbg!(entity) {
+            "text" => Some(ReplacementText::Internal(Cow::Borrowed(
+                b"&#x20;<![CDATA[second text]]>&#32;",
+            ))),
+            _ => Some(ReplacementText::Internal(Cow::Borrowed(
+                b"
+                <child1 attribute = '&lt;attribute value&gt;'>&text;</child1>
+                <child2/>
+            ",
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Deserialize)]
+struct Root {
+    child1: Child1,
+    child2: (),
+}
+
+#[derive(Debug, PartialEq, Deserialize)]
+struct Child1 {
+    #[serde(rename = "@attribute")]
+    attribute: String,
+
+    #[serde(rename = "$text")]
+    text: String,
+}
+
+#[test]
+fn entities() {
+    let mut de = Deserializer::from_str_with_resolver(
+        "
+        <!DOCTYPE root>
+        <root>&entity;</root>
+        ",
+        TestEntityResolver {
+            capture_called: false,
+        },
+    );
+
+    let data = Root::deserialize(&mut de).unwrap();
+
+    de.check_eof_reached();
+    assert_eq!(
+        data,
+        Root {
+            child1: Child1 {
+                attribute: "<attribute value>".to_string(),
+                text: " second text ".to_string(),
+            },
+            child2: (),
+        }
+    );
+}

tests/serde-de.rs

@@ -1,4 +1,3 @@
-use quick_xml::de::Deserializer;
 use quick_xml::utils::{ByteBuf, Bytes};
 use quick_xml::DeError;
 
@@ -1827,86 +1826,6 @@ mod borrow {
     }
 }
 
-/// Test for entity resolver
-mod resolve {
-    use super::*;
-    use pretty_assertions::assert_eq;
-    use quick_xml::events::BytesText;
-    use quick_xml::reader::{EntityResolver, EntityResolverFactory, ReplacementText};
-    use std::borrow::Cow;
-    use std::collections::BTreeMap;
-    use std::convert::Infallible;
-    use std::iter::FromIterator;
-
-    #[derive(Clone, Copy)]
-    struct TestEntityResolver {
-        capture_called: bool,
-    }
-
-    impl<'i> EntityResolverFactory<'i> for TestEntityResolver {
-        type CaptureError = Infallible;
-        type Resolver = Self;
-
-        fn new_resolver(&mut self) -> Self::Resolver {
-            *self
-        }
-    }
-
-    impl<'i> EntityResolver<'i> for TestEntityResolver {
-        type CaptureError = Infallible;
-
-        fn capture(&mut self, doctype: BytesText) -> Result<(), Self::CaptureError> {
-            self.capture_called = true;
-
-            assert_eq!(doctype.as_ref(), br#"dict[ <!ENTITY unc "unclassified"> ]"#);
-
-            Ok(())
-        }
-
-        fn resolve<'e>(&self, entity: &str) -> Option<ReplacementText<'i, 'e>> {
-            assert!(
-                self.capture_called,
-                "`EntityResolver::capture` should be called before `EntityResolver::resolve`"
-            );
-            match entity {
-                "t1" => Some(ReplacementText::Internal(Cow::Borrowed(b"test_one"))),
-                "t2" => Some(ReplacementText::Internal(Cow::Borrowed(b"test_two"))),
-                _ => None,
-            }
-        }
-    }
-
-    #[test]
-    fn resolve_custom_entity() {
-        let resolver = TestEntityResolver {
-            capture_called: false,
-        };
-        let mut de = Deserializer::with_resolver(
-            br#"
-            <!DOCTYPE dict[ <!ENTITY unc "unclassified"> ]>
-
-            <root>
-                <entity_one>&t1;</entity_one>
-                <entity_two>&t2;</entity_two>
-                <entity_three>non-entity</entity_three>
-            </root>
-            "#
-            .as_ref(),
-            resolver,
-        );
-
-        let data: BTreeMap<String, String> = BTreeMap::deserialize(&mut de).unwrap();
-        assert_eq!(
-            data,
-            BTreeMap::from_iter([
-                (String::from("entity_one"), String::from("test_one")),
-                (String::from("entity_two"), String::from("test_two")),
-                (String::from("entity_three"), String::from("non-entity")),
-            ])
-        );
-    }
-}
-
 /// Tests for https://github.com/tafia/quick-xml/pull/603.
 ///
 /// According to <https://www.w3.org/TR/xml11/#NT-prolog> comments,