tamer: obj::xmlo::reader::mock: Extract into crate::test::quick_xml

Other mocks exist here, and here it can be re-used for the upcoming XML
frontend.

tamer/src/obj/xmlo/reader/mod.rs

@@ -138,7 +138,7 @@ use crate::test::quick_xml::MockBytesStart as BytesStart;
 #[cfg(test)]
 use crate::test::quick_xml::MockXmlEvent as XmlEvent;
 #[cfg(test)]
-use mock::MockXmlReader as XmlReader;
+use crate::test::quick_xml::MockXmlReader as XmlReader;
 #[cfg(not(test))]
 use quick_xml::events::BytesStart;
 #[cfg(not(test))]
@@ -891,90 +891,4 @@ impl std::error::Error for XmlParseError {
 }
 
 #[cfg(test)]
-mod mock {
-    use super::*;
-    use quick_xml::Result as XmlResult;
-
-    pub struct MockXmlReader<B: BufRead> {
-        _reader: B,
-
-        pub check_end: Option<bool>,
-
-        /// Closure yielding the next event for `read_event`.
-        ///
-        /// This exists exclusively to avoid adding a lifetime parameter to
-        ///   the mock when providing stub data.
-        /// A closure must be set before calling `read_event` to avoid a
-        ///   panic.
-        pub next_event: Option<
-            Box<dyn for<'a> Fn(&'a mut Vec<u8>, u8) -> XmlResult<XmlEvent<'a>>>,
-        >,
-
-        pub event_i: u8,
-
-        /// Next string to yield for a text node.
-        pub next_text: Option<XmlResult<String>>,
-
-        pub given_text_ele: Option<String>,
-
-        pub read_to_end_name: Option<String>,
-    }
-
-    impl<B: BufRead> MockXmlReader<B> {
-        pub fn from_reader(reader: B) -> Self {
-            Self {
-                _reader: reader,
-                check_end: None,
-                next_event: None,
-                event_i: 0,
-                next_text: None,
-                given_text_ele: None,
-                read_to_end_name: None,
-            }
-        }
-
-        pub fn check_end_names(&mut self, val: bool) -> &mut Self {
-            self.check_end = Some(val);
-            self
-        }
-
-        pub fn read_event<'a, 'b>(
-            &'a mut self,
-            buf: &'b mut Vec<u8>,
-        ) -> XmlResult<XmlEvent<'b>> {
-            let result =
-                (self.next_event.as_ref().expect("missing mock next_event"))(
-                    buf,
-                    self.event_i,
-                );
-
-            self.event_i += 1;
-            result
-        }
-
-        pub fn read_text<K: AsRef<[u8]>>(
-            &mut self,
-            end: K,
-            _buf: &mut Vec<u8>,
-        ) -> XmlResult<String> {
-            self.given_text_ele =
-                Some(String::from_utf8(end.as_ref().to_vec()).unwrap());
-
-            self.next_text.take().expect("missing mock next_text")
-        }
-
-        pub fn read_to_end<K: AsRef<[u8]>>(
-            &mut self,
-            end: K,
-            _buf: &mut Vec<u8>,
-        ) -> XmlResult<()> {
-            self.read_to_end_name =
-                Some(String::from_utf8(end.as_ref().to_vec()).unwrap());
-
-            Ok(())
-        }
-    }
-}
-
-#[cfg(test)]
-pub mod test;
+mod test;

tamer/src/test/quick_xml/mod.rs

@@ -20,6 +20,7 @@
 use quick_xml::Result as XmlResult;
 use std::borrow::Cow;
 use std::cell::Cell;
+use std::io::BufRead;
 
 pub enum MockXmlEvent<'a> {
     Start(MockBytesStart<'a>),
@@ -125,3 +126,83 @@ impl<'a> MockAttribute<'a> {
         }
     }
 }
+
+pub struct MockXmlReader<B: BufRead> {
+    _reader: B,
+
+    pub check_end: Option<bool>,
+
+    /// Closure yielding the next event for `read_event`.
+    ///
+    /// This exists exclusively to avoid adding a lifetime parameter to
+    ///   the mock when providing stub data.
+    /// A closure must be set before calling `read_event` to avoid a
+    ///   panic.
+    pub next_event: Option<
+        Box<dyn for<'a> Fn(&'a mut Vec<u8>, u8) -> XmlResult<MockXmlEvent<'a>>>,
+    >,
+
+    pub event_i: u8,
+
+    /// Next string to yield for a text node.
+    pub next_text: Option<XmlResult<String>>,
+
+    pub given_text_ele: Option<String>,
+
+    pub read_to_end_name: Option<String>,
+}
+
+impl<B: BufRead> MockXmlReader<B> {
+    pub fn from_reader(reader: B) -> Self {
+        Self {
+            _reader: reader,
+            check_end: None,
+            next_event: None,
+            event_i: 0,
+            next_text: None,
+            given_text_ele: None,
+            read_to_end_name: None,
+        }
+    }
+
+    pub fn check_end_names(&mut self, val: bool) -> &mut Self {
+        self.check_end = Some(val);
+        self
+    }
+
+    pub fn read_event<'a, 'b>(
+        &'a mut self,
+        buf: &'b mut Vec<u8>,
+    ) -> XmlResult<MockXmlEvent<'b>> {
+        let result =
+            (self.next_event.as_ref().expect("missing mock next_event"))(
+                buf,
+                self.event_i,
+            );
+
+        self.event_i += 1;
+        result
+    }
+
+    pub fn read_text<K: AsRef<[u8]>>(
+        &mut self,
+        end: K,
+        _buf: &mut Vec<u8>,
+    ) -> XmlResult<String> {
+        self.given_text_ele =
+            Some(String::from_utf8(end.as_ref().to_vec()).unwrap());
+
+        self.next_text.take().expect("missing mock next_text")
+    }
+
+    pub fn read_to_end<K: AsRef<[u8]>>(
+        &mut self,
+        end: K,
+        _buf: &mut Vec<u8>,
+    ) -> XmlResult<()> {
+        self.read_to_end_name =
+            Some(String::from_utf8(end.as_ref().to_vec()).unwrap());
+
+        Ok(())
+    }
+}