Add tests for Reader::read_event_buffered to ensure that proper events generated for corresponding inputs

failures:
    reader::test::borrowed::read_event_buffered::cdata
    reader::test::borrowed::read_event_buffered::comment
    reader::test::borrowed::read_event_buffered::declaration
    reader::test::borrowed::read_event_buffered::doctype
    reader::test::borrowed::read_event_buffered::empty
    reader::test::borrowed::read_event_buffered::end
    reader::test::borrowed::read_event_buffered::processing_instruction
    reader::test::borrowed::read_event_buffered::start
    reader::test::buffered::read_event_buffered::cdata
    reader::test::buffered::read_event_buffered::comment
    reader::test::buffered::read_event_buffered::declaration
    reader::test::buffered::read_event_buffered::doctype
    reader::test::buffered::read_event_buffered::empty
    reader::test::buffered::read_event_buffered::end
    reader::test::buffered::read_event_buffered::processing_instruction
    reader::test::buffered::read_event_buffered::start

Author: Mingun

Changelog.md

@@ -61,9 +61,11 @@
 - [#387]: Added a bunch of tests for sequences deserialization
 - [#393]: Added more tests for namespace resolver
 - [#393]: Added tests for reserved names (started with "xml"i) -- see <https://www.w3.org/TR/xml-names11/#xmlReserved>
+- [#363]: Add tests for `Reader::read_event_buffered` to ensure that proper events generated for corresponding inputs
 
 [#8]: https://github.com/Mingun/fast-xml/pull/8
 [#9]: https://github.com/Mingun/fast-xml/pull/9
+[#363]: https://github.com/tafia/quick-xml/issues/363
 [#387]: https://github.com/tafia/quick-xml/pull/387
 [#391]: https://github.com/tafia/quick-xml/pull/391
 [#393]: https://github.com/tafia/quick-xml/pull/393

src/reader.rs

@@ -2244,6 +2244,116 @@ mod test {
                     }
                 }
             }
+
+            /// Ensures, that no empty `Text` events are generated
+            mod read_event_buffered {
+                use crate::events::{BytesCData, BytesDecl, BytesEnd, BytesStart, BytesText, Event};
+                use crate::reader::Reader;
+                use pretty_assertions::assert_eq;
+
+                #[test]
+                fn declaration() {
+                    let mut reader = Reader::from_str("<?xml ?>");
+
+                    assert_eq!(
+                        reader.read_event_buffered($buf).unwrap(),
+                        Event::Decl(BytesDecl::from_start(BytesStart::borrowed(b"xml ", 3)))
+                    );
+                }
+
+                #[test]
+                fn doctype() {
+                    let mut reader = Reader::from_str("<!DOCTYPE x>");
+
+                    assert_eq!(
+                        reader.read_event_buffered($buf).unwrap(),
+                        Event::DocType(BytesText::from_escaped(b"x".as_ref()))
+                    );
+                }
+
+                #[test]
+                fn processing_instruction() {
+                    let mut reader = Reader::from_str("<?xml-stylesheet?>");
+
+                    assert_eq!(
+                        reader.read_event_buffered($buf).unwrap(),
+                        Event::PI(BytesText::from_escaped(b"xml-stylesheet".as_ref()))
+                    );
+                }
+
+                #[test]
+                fn start() {
+                    let mut reader = Reader::from_str("<tag>");
+
+                    assert_eq!(
+                        reader.read_event_buffered($buf).unwrap(),
+                        Event::Start(BytesStart::borrowed_name(b"tag"))
+                    );
+                }
+
+                #[test]
+                fn end() {
+                    let mut reader = Reader::from_str("</tag>");
+                    // Because we expect invalid XML, do not check that
+                    // the end name paired with the start name
+                    reader.check_end_names(false);
+
+                    assert_eq!(
+                        reader.read_event_buffered($buf).unwrap(),
+                        Event::End(BytesEnd::borrowed(b"tag"))
+                    );
+                }
+
+                #[test]
+                fn empty() {
+                    let mut reader = Reader::from_str("<tag/>");
+
+                    assert_eq!(
+                        reader.read_event_buffered($buf).unwrap(),
+                        Event::Empty(BytesStart::borrowed_name(b"tag"))
+                    );
+                }
+
+                #[test]
+                fn text() {
+                    let mut reader = Reader::from_str("text");
+
+                    assert_eq!(
+                        reader.read_event_buffered($buf).unwrap(),
+                        Event::Text(BytesText::from_escaped(b"text".as_ref()))
+                    );
+                }
+
+                #[test]
+                fn cdata() {
+                    let mut reader = Reader::from_str("<![CDATA[]]>");
+
+                    assert_eq!(
+                        reader.read_event_buffered($buf).unwrap(),
+                        Event::CData(BytesCData::from_str(""))
+                    );
+                }
+
+                #[test]
+                fn comment() {
+                    let mut reader = Reader::from_str("<!---->");
+
+                    assert_eq!(
+                        reader.read_event_buffered($buf).unwrap(),
+                        Event::Comment(BytesText::from_escaped(b"".as_ref()))
+                    );
+                }
+
+                #[test]
+                fn eof() {
+                    let mut reader = Reader::from_str("");
+
+                    assert_eq!(
+                        reader.read_event_buffered($buf).unwrap(),
+                        Event::Eof
+                    );
+                }
+            }
         };
     }