diff --git a/Changelog.md b/Changelog.md
index 3f4ae2ec..2fd133ec 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -18,8 +18,12 @@
 
 ### Bug Fixes
 
+- [#936]: Fix incorrect result of `.read_text()` when it is called after reading `Text` or `GeneralRef` event.
+
 ### Misc Changes
 
+[#936]: https://github.com/tafia/quick-xml/pull/936
+
 
 ## 0.39.0 -- 2026-01-11
 
diff --git a/src/parser/pi.rs b/src/parser/pi.rs
index 77088aaf..18c24804 100644
--- a/src/parser/pi.rs
+++ b/src/parser/pi.rs
@@ -74,12 +74,12 @@ impl Parser for PiParser {
 
     #[inline]
     fn eof_error(self, content: &[u8]) -> SyntaxError {
-        // Check if content starts with "?xml" followed by whitespace, '?' or end.
+        // Check if content starts with "<?xml" followed by whitespace, '?' or end.
         // This determines whether to report an unclosed XML declaration or PI.
         // FIXME: Add support for UTF-8/ASCII incompatible encodings (UTF-16)
-        let is_xml_decl = content.starts_with(b"?xml")
+        let is_xml_decl = content.starts_with(b"<?xml")
             && content
-                .get(4)
+                .get(5)
                 .map_or(true, |&b| is_whitespace(b) || b == b'?');
         if is_xml_decl {
             SyntaxError::UnclosedXmlDecl
diff --git a/src/reader/buffered_reader.rs b/src/reader/buffered_reader.rs
index 27aa74c0..1074002d 100644
--- a/src/reader/buffered_reader.rs
+++ b/src/reader/buffered_reader.rs
@@ -73,21 +73,15 @@ macro_rules! impl_buffered_source {
                 match memchr::memchr2(b'<', b'&', available) {
                     // Special handling is needed only on the first iteration.
                     // On next iterations we already read something and should emit Text event
-                    Some(0) if read == 0 && available[0] == b'<' => {
-                        self $(.$reader)? .consume(1);
-                        *position += 1;
-                        return ReadTextResult::Markup(buf);
-                    }
+                    Some(0) if read == 0 && available[0] == b'<' => return ReadTextResult::Markup(buf),
                     // Do not consume `&` because it may be lone and we would be need to
                     // return it as part of Text event
                     Some(0) if read == 0 => return ReadTextResult::Ref(buf),
                     Some(i) if available[i] == b'<' => {
                         buf.extend_from_slice(&available[..i]);
 
-                        // +1 to skip `<`
-                        let used = i + 1;
-                        self $(.$reader)? .consume(used);
-                        read += used as u64;
+                        self $(.$reader)? .consume(i);
+                        read += i as u64;
 
                         *position += read;
                         return ReadTextResult::UpToMarkup(&buf[start..]);
@@ -137,10 +131,10 @@ macro_rules! impl_buffered_source {
                 // should explicitly skip it at first iteration lest we confuse
                 // it with the end
                 if read == 0 {
-                    debug_assert_eq!(
-                        available.first(),
-                        Some(&b'&'),
-                        "`read_ref` must be called at `&`"
+                    debug_assert!(
+                        available.starts_with(b"&"),
+                        "`read_ref` must be called at `&`:\n{:?}",
+                        crate::utils::Bytes(available)
                     );
                     // If that ampersand is lone, then it will be part of text
                     // and we should keep it
@@ -151,31 +145,31 @@ macro_rules! impl_buffered_source {
                 }
 
                 match memchr::memchr3(b';', b'&', b'<', available) {
-                    // Do not consume `&` because it may be lone and we would be need to
-                    // return it as part of Text event
-                    Some(i) if available[i] == b'&' => {
+                    Some(i) if available[i] == b';' => {
                         buf.extend_from_slice(&available[..i]);
 
-                        self $(.$reader)? .consume(i);
-                        read += i as u64;
+                        // +1 -- skip the end `;`
+                        let used = i + 1;
+                        self $(.$reader)? .consume(used);
+                        read += used as u64;
 
                         *position += read;
 
-                        return ReadRefResult::UpToRef(&buf[start..]);
+                        return ReadRefResult::Ref(&buf[start..]);
                     }
+                    // Do not consume `&` because it may be lone and we would be need to
+                    // return it as part of Text event
                     Some(i) => {
-                        let is_end = available[i] == b';';
+                        let is_amp = available[i] == b'&';
                         buf.extend_from_slice(&available[..i]);
 
-                        // +1 -- skip the end `;` or `<`
-                        let used = i + 1;
-                        self $(.$reader)? .consume(used);
-                        read += used as u64;
+                        self $(.$reader)? .consume(i);
+                        read += i as u64;
 
                         *position += read;
 
-                        return if is_end {
-                            ReadRefResult::Ref(&buf[start..])
+                        return if is_amp {
+                            ReadRefResult::UpToRef(&buf[start..])
                         } else {
                             ReadRefResult::UpToMarkup(&buf[start..])
                         };
@@ -243,14 +237,20 @@ macro_rules! impl_buffered_source {
             buf: &'b mut Vec<u8>,
             position: &mut u64,
         ) -> Result<(BangType, &'b [u8])> {
-            // Peeked one bang ('!') before being called, so it's guaranteed to
-            // start with it.
+            // Peeked '<!' before being called, so it's guaranteed to start with it.
             let start = buf.len();
-            let mut read = 1;
+            let mut read = 2;
+            buf.push(b'<');
             buf.push(b'!');
-            self $(.$reader)? .consume(1);
+            self $(.$reader)? .consume(2);
 
-            let mut bang_type = BangType::new(self.peek_one() $(.$await)? ?)?;
+            let mut bang_type = loop {
+                break match self $(.$reader)? .fill_buf() $(.$await)? {
+                    Ok(n) => BangType::new(n.first().cloned())?,
+                    Err(ref e) if e.kind() == io::ErrorKind::Interrupted => continue,
+                    Err(e) => return Err(Error::Io(e.into())),
+                };
+            };
 
             loop {
                 match self $(.$reader)? .fill_buf() $(.$await)? {
@@ -310,13 +310,19 @@ macro_rules! impl_buffered_source {
 
         #[inline]
         $($async)? fn peek_one(&mut self) -> io::Result<Option<u8>> {
-            loop {
+            let available = loop {
                 break match self $(.$reader)? .fill_buf() $(.$await)? {
-                    Ok(n) => Ok(n.first().cloned()),
+                    Ok(n) => n,
                     Err(ref e) if e.kind() == io::ErrorKind::Interrupted => continue,
-                    Err(e) => Err(e),
+                    Err(e) => return Err(e),
                 };
-            }
+            };
+            debug_assert!(
+                available.starts_with(b"<"),
+                "markup must start from '<':\n{:?}",
+                crate::utils::Bytes(available)
+            );
+            Ok(available.get(1).cloned())
         }
     };
 }
diff --git a/src/reader/mod.rs b/src/reader/mod.rs
index e227e189..2cc828bd 100644
--- a/src/reader/mod.rs
+++ b/src/reader/mod.rs
@@ -416,9 +416,8 @@ macro_rules! read_until_close {
             {
                 Ok((bang_type, bytes)) => $self.state.emit_bang(bang_type, bytes),
                 Err(e) => {
-                    // We want to report error at `<`, but offset was increased,
-                    // so return it back (-1 for `<`)
-                    $self.state.last_error_offset = start - 1;
+                    // We want to report error at `<`
+                    $self.state.last_error_offset = start;
                     Err(e)
                 }
             },
@@ -438,9 +437,8 @@ macro_rules! read_until_close {
             {
                 Ok(bytes) => $self.state.emit_end(bytes),
                 Err(e) => {
-                    // We want to report error at `<`, but offset was increased,
-                    // so return it back (-1 for `<`)
-                    $self.state.last_error_offset = start - 1;
+                    // We want to report error at `<`
+                    $self.state.last_error_offset = start;
                     Err(e)
                 }
             },
@@ -451,9 +449,8 @@ macro_rules! read_until_close {
             {
                 Ok(bytes) => $self.state.emit_question_mark(bytes),
                 Err(e) => {
-                    // We want to report error at `<`, but offset was increased,
-                    // so return it back (-1 for `<`)
-                    $self.state.last_error_offset = start - 1;
+                    // We want to report error at `<`
+                    $self.state.last_error_offset = start;
                     Err(e)
                 }
             },
@@ -464,17 +461,15 @@ macro_rules! read_until_close {
             {
                 Ok(bytes) => Ok($self.state.emit_start(bytes)),
                 Err(e) => {
-                    // We want to report error at `<`, but offset was increased,
-                    // so return it back (-1 for `<`)
-                    $self.state.last_error_offset = start - 1;
+                    // We want to report error at `<`
+                    $self.state.last_error_offset = start;
                     Err(e)
                 }
             },
             // `<` - syntax error, tag not closed
             Ok(None) => {
-                // We want to report error at `<`, but offset was increased,
-                // so return it back (-1 for `<`)
-                $self.state.last_error_offset = start - 1;
+                // We want to report error at `<`
+                $self.state.last_error_offset = start;
                 Err(Error::Syntax(SyntaxError::UnclosedTag))
             }
             Err(e) => Err(Error::Io(e.into())),
@@ -879,13 +874,7 @@ impl<R> Reader<R> {
     /// (` `, `\t`, `\r`, and `\n`) if [`Config::trim_text_end`] is set this is position
     /// before trim, not the position of the last byte of the [`Event::Text`] content.
     pub const fn buffer_position(&self) -> u64 {
-        // when internal state is InsideMarkup, we have actually read until '<',
-        // which we don't want to show
-        if let ParseState::InsideMarkup = self.state.state {
-            self.state.offset - 1
-        } else {
-            self.state.offset
-        }
+        self.state.offset
     }
 
     /// Gets the last error byte position in the input data. If there is no errors
@@ -1183,8 +1172,8 @@ impl BangType {
                 for i in memchr::memchr_iter(b'>', chunk) {
                     // Need to read at least 6 symbols (`!---->`) for properly finished comment
                     // <!----> - XML comment
-                    //  012345 - i
-                    if buf.len() + i > 4 {
+                    // 0123456 - i
+                    if buf.len() + i > 5 {
                         if chunk[..i].ends_with(b"--") {
                             // We cannot strip last `--` from the buffer because we need it in case of
                             // check_comments enabled option. XML standard requires that comment
@@ -1270,7 +1259,7 @@ mod test {
                     $($async)? fn not_properly_start() {
                         let buf = $buf;
                         let mut position = 1;
-                        let mut input = b"![]]>other content".as_ref();
+                        let mut input = b"<![]]>other content".as_ref();
                         //                ^= 1
 
                         match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
@@ -1288,9 +1277,9 @@ mod test {
                     #[$test]
                     $($async)? fn not_closed() {
                         let buf = $buf;
-                        let mut position = 1;
-                        let mut input = b"![CDATA[other content".as_ref();
-                        //                ^= 1                 ^= 22
+                        let mut position = 0;
+                        let mut input = b"<![CDATA[other content".as_ref();
+                        //                ^= 0                  ^= 22
 
                         match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
                             Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedCData),
@@ -1306,9 +1295,9 @@ mod test {
                     #[$test]
                     $($async)? fn empty() {
                         let buf = $buf;
-                        let mut position = 1;
-                        let mut input = b"![CDATA[]]>other content".as_ref();
-                        //                ^= 1       ^= 12
+                        let mut position = 0;
+                        let mut input = b"<![CDATA[]]>other content".as_ref();
+                        //                ^= 0        ^= 12
 
                         let (ty, bytes) = $source(&mut input)
                             .read_bang_element(buf, &mut position)
@@ -1316,7 +1305,7 @@ mod test {
                             .unwrap();
                         assert_eq!(
                             (ty, Bytes(bytes)),
-                            (BangType::CData, Bytes(b"![CDATA[]]"))
+                            (BangType::CData, Bytes(b"<![CDATA[]]"))
                         );
                         assert_eq!(position, 12);
                     }
@@ -1327,9 +1316,9 @@ mod test {
                     #[$test]
                     $($async)? fn with_content() {
                         let buf = $buf;
-                        let mut position = 1;
-                        let mut input = b"![CDATA[cdata]] ]>content]]>other content]]>".as_ref();
-                        //                ^= 1                        ^= 29
+                        let mut position = 0;
+                        let mut input = b"<![CDATA[cdata]] ]>content]]>other content]]>".as_ref();
+                        //                ^= 0                         ^= 29
 
                         let (ty, bytes) = $source(&mut input)
                             .read_bang_element(buf, &mut position)
@@ -1337,7 +1326,7 @@ mod test {
                             .unwrap();
                         assert_eq!(
                             (ty, Bytes(bytes)),
-                            (BangType::CData, Bytes(b"![CDATA[cdata]] ]>content]]"))
+                            (BangType::CData, Bytes(b"<![CDATA[cdata]] ]>content]]"))
                         );
                         assert_eq!(position, 29);
                     }
@@ -1368,7 +1357,7 @@ mod test {
                     $($async)? fn not_properly_start() {
                         let buf = $buf;
                         let mut position = 1;
-                        let mut input = b"!- -->other content".as_ref();
+                        let mut input = b"<!- -->other content".as_ref();
                         //                ^= 1
 
                         match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
@@ -1384,9 +1373,9 @@ mod test {
                     #[$test]
                     $($async)? fn not_properly_end() {
                         let buf = $buf;
-                        let mut position = 1;
-                        let mut input = b"!->other content".as_ref();
-                        //                ^= 1            ^= 17
+                        let mut position = 0;
+                        let mut input = b"<!->other content".as_ref();
+                        //                ^= 0             ^= 17
 
                         match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
                             Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedComment),
@@ -1401,9 +1390,9 @@ mod test {
                     #[$test]
                     $($async)? fn not_closed1() {
                         let buf = $buf;
-                        let mut position = 1;
-                        let mut input = b"!--other content".as_ref();
-                        //                ^= 1            ^= 17
+                        let mut position = 0;
+                        let mut input = b"<!--other content".as_ref();
+                        //                ^= 0             ^= 17
 
                         match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
                             Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedComment),
@@ -1418,9 +1407,9 @@ mod test {
                     #[$test]
                     $($async)? fn not_closed2() {
                         let buf = $buf;
-                        let mut position = 1;
-                        let mut input = b"!-->other content".as_ref();
-                        //                ^= 1             ^= 18
+                        let mut position = 0;
+                        let mut input = b"<!-->other content".as_ref();
+                        //                ^= 0              ^= 18
 
                         match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
                             Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedComment),
@@ -1435,9 +1424,9 @@ mod test {
                     #[$test]
                     $($async)? fn not_closed3() {
                         let buf = $buf;
-                        let mut position = 1;
-                        let mut input = b"!--->other content".as_ref();
-                        //                ^= 1              ^= 19
+                        let mut position = 0;
+                        let mut input = b"<!--->other content".as_ref();
+                        //                ^= 0               ^= 19
 
                         match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
                             Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedComment),
@@ -1452,9 +1441,9 @@ mod test {
                     #[$test]
                     $($async)? fn empty() {
                         let buf = $buf;
-                        let mut position = 1;
-                        let mut input = b"!---->other content".as_ref();
-                        //                ^= 1  ^= 7
+                        let mut position = 0;
+                        let mut input = b"<!---->other content".as_ref();
+                        //                ^= 0   ^= 7
 
                         let (ty, bytes) = $source(&mut input)
                             .read_bang_element(buf, &mut position)
@@ -1462,7 +1451,7 @@ mod test {
                             .unwrap();
                         assert_eq!(
                             (ty, Bytes(bytes)),
-                            (BangType::Comment, Bytes(b"!----"))
+                            (BangType::Comment, Bytes(b"<!----"))
                         );
                         assert_eq!(position, 7);
                     }
@@ -1470,9 +1459,9 @@ mod test {
                     #[$test]
                     $($async)? fn with_content() {
                         let buf = $buf;
-                        let mut position = 1;
-                        let mut input = b"!--->comment<--->other content".as_ref();
-                        //                ^= 1             ^= 18
+                        let mut position = 0;
+                        let mut input = b"<!--->comment<--->other content".as_ref();
+                        //                ^= 0              ^= 18
 
                         let (ty, bytes) = $source(&mut input)
                             .read_bang_element(buf, &mut position)
@@ -1480,7 +1469,7 @@ mod test {
                             .unwrap();
                         assert_eq!(
                             (ty, Bytes(bytes)),
-                            (BangType::Comment, Bytes(b"!--->comment<---"))
+                            (BangType::Comment, Bytes(b"<!--->comment<---"))
                         );
                         assert_eq!(position, 18);
                     }
@@ -1497,9 +1486,9 @@ mod test {
                         #[$test]
                         $($async)? fn not_properly_start() {
                             let buf = $buf;
-                            let mut position = 1;
-                            let mut input = b"!D other content".as_ref();
-                            //                ^= 1            ^= 17
+                            let mut position = 0;
+                            let mut input = b"<!D other content".as_ref();
+                            //                ^= 0             ^= 17
 
                             match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
                                 Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedDoctype),
@@ -1514,9 +1503,9 @@ mod test {
                         #[$test]
                         $($async)? fn without_space() {
                             let buf = $buf;
-                            let mut position = 1;
-                            let mut input = b"!DOCTYPEother content".as_ref();
-                            //                ^= 1                 ^= 22
+                            let mut position = 0;
+                            let mut input = b"<!DOCTYPEother content".as_ref();
+                            //                ^= 0                  ^= 22
 
                             match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
                                 Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedDoctype),
@@ -1531,9 +1520,9 @@ mod test {
                         #[$test]
                         $($async)? fn empty() {
                             let buf = $buf;
-                            let mut position = 1;
-                            let mut input = b"!DOCTYPE>other content".as_ref();
-                            //                ^= 1     ^= 10
+                            let mut position = 0;
+                            let mut input = b"<!DOCTYPE>other content".as_ref();
+                            //                ^= 0      ^= 10
 
                             let (ty, bytes) = $source(&mut input)
                                 .read_bang_element(buf, &mut position)
@@ -1541,7 +1530,7 @@ mod test {
                                 .unwrap();
                             assert_eq!(
                                 (ty, Bytes(bytes)),
-                                (BangType::DocType(DtdParser::Finished), Bytes(b"!DOCTYPE"))
+                                (BangType::DocType(DtdParser::Finished), Bytes(b"<!DOCTYPE"))
                             );
                             assert_eq!(position, 10);
                         }
@@ -1549,9 +1538,9 @@ mod test {
                         #[$test]
                         $($async)? fn not_closed() {
                             let buf = $buf;
-                            let mut position = 1;
-                            let mut input = b"!DOCTYPE other content".as_ref();
-                            //                ^= 1                  ^23
+                            let mut position = 0;
+                            let mut input = b"<!DOCTYPE other content".as_ref();
+                            //                ^= 0                   ^23
 
                             match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
                                 Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedDoctype),
@@ -1571,9 +1560,9 @@ mod test {
                         #[$test]
                         $($async)? fn not_properly_start() {
                             let buf = $buf;
-                            let mut position = 1;
-                            let mut input = b"!d other content".as_ref();
-                            //                ^= 1            ^= 17
+                            let mut position = 0;
+                            let mut input = b"<!d other content".as_ref();
+                            //                ^= 0             ^= 17
 
                             match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
                                 Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedDoctype),
@@ -1588,9 +1577,9 @@ mod test {
                         #[$test]
                         $($async)? fn without_space() {
                             let buf = $buf;
-                            let mut position = 1;
-                            let mut input = b"!doctypeother content".as_ref();
-                            //                ^= 1                 ^= 22
+                            let mut position = 0;
+                            let mut input = b"<!doctypeother content".as_ref();
+                            //                ^= 0                  ^= 22
 
                             match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
                                 Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedDoctype),
@@ -1605,9 +1594,9 @@ mod test {
                         #[$test]
                         $($async)? fn empty() {
                             let buf = $buf;
-                            let mut position = 1;
-                            let mut input = b"!doctype>other content".as_ref();
-                            //                ^= 1     ^= 10
+                            let mut position = 0;
+                            let mut input = b"<!doctype>other content".as_ref();
+                            //                ^= 0      ^= 10
 
                             let (ty, bytes) = $source(&mut input)
                                 .read_bang_element(buf, &mut position)
@@ -1615,7 +1604,7 @@ mod test {
                                 .unwrap();
                             assert_eq!(
                                 (ty, Bytes(bytes)),
-                                (BangType::DocType(DtdParser::Finished), Bytes(b"!doctype"))
+                                (BangType::DocType(DtdParser::Finished), Bytes(b"<!doctype"))
                             );
                             assert_eq!(position, 10);
                         }
@@ -1623,9 +1612,9 @@ mod test {
                         #[$test]
                         $($async)? fn not_closed() {
                             let buf = $buf;
-                            let mut position = 1;
-                            let mut input = b"!doctype other content".as_ref();
-                            //                ^= 1                  ^= 23
+                            let mut position = 0;
+                            let mut input = b"<!doctype other content".as_ref();
+                            //                ^= 0                   ^= 23
 
                             match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
                                 Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedDoctype),
@@ -1665,13 +1654,13 @@ mod test {
                     let buf = $buf;
                     let mut position = 1;
                     let mut input = b"<".as_ref();
-                    //                 ^= 2
+                    //                 ^= 1
 
                     match $source(&mut input).read_text(buf, &mut position) $(.$await)? {
                         ReadTextResult::Markup(b) => assert_eq!(b, $buf),
                         x => panic!("Expected `Markup(_)`, but got `{:?}`", x),
                     }
-                    assert_eq!(position, 2);
+                    assert_eq!(position, 1);
                 }
 
                 #[$test]
@@ -1693,13 +1682,13 @@ mod test {
                     let buf = $buf;
                     let mut position = 1;
                     let mut input = b"a<".as_ref();
-                    //                1 ^= 3
+                    //                  ^= 2
 
                     match $source(&mut input).read_text(buf, &mut position) $(.$await)? {
                         ReadTextResult::UpToMarkup(bytes) => assert_eq!(Bytes(bytes), Bytes(b"a")),
                         x => panic!("Expected `UpToMarkup(_)`, but got `{:?}`", x),
                     }
-                    assert_eq!(position, 3);
+                    assert_eq!(position, 2);
                 }
 
                 #[$test]
@@ -1774,13 +1763,13 @@ mod test {
                     let buf = $buf;
                     let mut position = 1;
                     let mut input = b"&<".as_ref();
-                    //                  ^= 3
+                    //                 ^= 2
 
                     match $source(&mut input).read_ref(buf, &mut position) $(.$await)? {
                         ReadRefResult::UpToMarkup(bytes) => assert_eq!(Bytes(bytes), Bytes(b"&")),
                         x => panic!("Expected `UpToMarkup(_)`, but got `{:?}`", x),
                     }
-                    assert_eq!(position, 3);
+                    assert_eq!(position, 2);
                 }
 
                 #[$test]
diff --git a/src/reader/slice_reader.rs b/src/reader/slice_reader.rs
index 45ec32b7..1cbd3f5a 100644
--- a/src/reader/slice_reader.rs
+++ b/src/reader/slice_reader.rs
@@ -265,18 +265,14 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {
     fn read_text(&mut self, _buf: (), position: &mut u64) -> ReadTextResult<'a, ()> {
         // Search for start of markup or an entity or character reference
         match memchr::memchr2(b'<', b'&', self) {
-            Some(0) if self[0] == b'<' => {
-                *self = &self[1..];
-                *position += 1;
-                ReadTextResult::Markup(())
-            }
+            Some(0) if self[0] == b'<' => ReadTextResult::Markup(()),
             // Do not consume `&` because it may be lone and we would be need to
             // return it as part of Text event
             Some(0) => ReadTextResult::Ref(()),
             Some(i) if self[i] == b'<' => {
-                let bytes = &self[..i];
-                *self = &self[i + 1..];
-                *position += i as u64 + 1;
+                let (bytes, rest) = self.split_at(i);
+                *self = rest;
+                *position += i as u64;
                 ReadTextResult::UpToMarkup(bytes)
             }
             Some(i) => {
@@ -296,32 +292,32 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {
 
     #[inline]
     fn read_ref(&mut self, _buf: (), position: &mut u64) -> ReadRefResult<'a> {
-        debug_assert_eq!(
-            self.first(),
-            Some(&b'&'),
-            "`read_ref` must be called at `&`"
+        debug_assert!(
+            self.starts_with(b"&"),
+            "`read_ref` must be called at `&`:\n{:?}",
+            crate::utils::Bytes(self)
         );
         // Search for the end of reference or a start of another reference or a markup
         match memchr::memchr3(b';', b'&', b'<', &self[1..]) {
+            Some(i) if self[i + 1] == b';' => {
+                let end = i + 1;
+                let bytes = &self[..end];
+                // +1 -- skip the end `;`
+                *self = &self[end + 1..];
+                *position += end as u64 + 1;
+
+                ReadRefResult::Ref(bytes)
+            }
             // Do not consume `&` because it may be lone and we would be need to
             // return it as part of Text event
-            Some(i) if self[i + 1] == b'&' => {
+            Some(i) => {
+                let is_amp = self[i + 1] == b'&';
                 let (bytes, rest) = self.split_at(i + 1);
                 *self = rest;
                 *position += i as u64 + 1;
 
-                ReadRefResult::UpToRef(bytes)
-            }
-            Some(i) => {
-                let end = i + 1;
-                let is_end = self[end] == b';';
-                let bytes = &self[..end];
-                // +1 -- skip the end `;` or `<`
-                *self = &self[end + 1..];
-                *position += end as u64 + 1;
-
-                if is_end {
-                    ReadRefResult::Ref(bytes)
+                if is_amp {
+                    ReadRefResult::UpToRef(bytes)
                 } else {
                     ReadRefResult::UpToMarkup(bytes)
                 }
@@ -357,9 +353,13 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {
     fn read_bang_element(&mut self, _buf: (), position: &mut u64) -> Result<(BangType, &'a [u8])> {
         // Peeked one bang ('!') before being called, so it's guaranteed to
         // start with it.
-        debug_assert_eq!(self[0], b'!');
+        debug_assert!(
+            self.starts_with(b"<!"),
+            "`read_bang_element` must be called at `<!`:\n{:?}",
+            crate::utils::Bytes(self)
+        );
 
-        let mut bang_type = BangType::new(self[1..].first().copied())?;
+        let mut bang_type = BangType::new(self.get(2).copied())?;
 
         if let Some((bytes, i)) = bang_type.parse(&[], self) {
             *position += i as u64;
@@ -384,7 +384,12 @@ impl<'a> XmlSource<'a, ()> for &'a [u8] {
 
     #[inline]
     fn peek_one(&mut self) -> io::Result<Option<u8>> {
-        Ok(self.first().copied())
+        debug_assert!(
+            self.starts_with(b"<"),
+            "markup must start from '<':\n{:?}",
+            crate::utils::Bytes(self)
+        );
+        Ok(self.get(1).copied())
     }
 }
 
diff --git a/src/reader/state.rs b/src/reader/state.rs
index ff08272d..9d708529 100644
--- a/src/reader/state.rs
+++ b/src/reader/state.rs
@@ -75,15 +75,15 @@ impl ReaderState {
     /// Returns `Comment`, `CData` or `DocType` event.
     ///
     /// `buf` contains data between `<` and `>`:
-    /// - CDATA: `![CDATA[...]]`
-    /// - Comment: `!--...--`
-    /// - Doctype (uppercase): `!D...`
-    /// - Doctype (lowercase): `!d...`
+    /// - CDATA: `<![CDATA[...]]`
+    /// - Comment: `<!--...--`
+    /// - Doctype (uppercase): `<!D...`
+    /// - Doctype (lowercase): `<!d...`
     pub fn emit_bang<'b>(&mut self, bang_type: BangType, buf: &'b [u8]) -> Result<Event<'b>> {
-        debug_assert_eq!(
-            buf.first(),
-            Some(&b'!'),
-            "CDATA, comment or DOCTYPE should start from '!'"
+        debug_assert!(
+            buf.starts_with(b"<!"),
+            "CDATA, comment or DOCTYPE must start from '<!':\n{:?}",
+            crate::utils::Bytes(buf)
         );
 
         let uncased_starts_with = |string: &[u8], prefix: &[u8]| {
@@ -92,31 +92,35 @@ impl ReaderState {
 
         let len = buf.len();
         match bang_type {
-            BangType::Comment if buf.starts_with(b"!--") => {
-                debug_assert!(buf.ends_with(b"--"));
+            BangType::Comment if buf.starts_with(b"<!--") => {
+                debug_assert!(
+                    buf.ends_with(b"--"),
+                    "comment must end with '--':\n{:?}",
+                    crate::utils::Bytes(buf)
+                );
                 if self.config.check_comments {
                     // search if '--' not in comments
-                    let mut haystack = &buf[3..len - 2];
+                    let mut haystack = &buf[4..len - 2];
                     let mut off = 0;
                     while let Some(p) = memchr::memchr(b'-', haystack) {
                         off += p + 1;
                         // if next byte after `-` is also `-`, return an error
-                        if buf[3 + off] == b'-' {
+                        if buf[4 + off] == b'-' {
                             // Explanation of the magic:
                             //
-                            // - `self.offset`` just after `>`,
-                            // - `buf` contains `!-- con--tent --`
+                            // - `self.offset` just after `>`,
+                            // - `buf` contains `<!-- con--tent --`
                             // - `p` is counted from byte after `<!--`
                             //
                             // <!-- con--tent -->:
-                            //  ~~~~~~~~~~~~~~~~ : - buf
-                            //   : ===========   : - zone of search (possible values of `p`)
-                            //   : |---p         : - p is counted from | (| is 0)
-                            //   : :   :         ^ - self.offset
-                            //   ^ :   :           - self.offset - len
-                            //     ^   :           - self.offset - len + 2
-                            //         ^           - self.offset - len + 2 + p
-                            self.last_error_offset = self.offset - len as u64 + 2 + p as u64;
+                            // ~~~~~~~~~~~~~~~~~ : - buf
+                            //  :  ===========   : - zone of search (possible values of `p`)
+                            //  :  |---p         : - p is counted from | (| is 0)
+                            //  :  :   :         ^ - self.offset
+                            //  ^  :   :           - self.offset - len
+                            //     ^   :           - self.offset - len + 3
+                            //         ^           - self.offset - len + 3 + p
+                            self.last_error_offset = self.offset - len as u64 + 3 + p as u64;
                             return Err(Error::IllFormed(IllFormedError::DoubleHyphenInComment));
                         }
                         // Continue search after single `-` (+1 to skip it)
@@ -124,8 +128,8 @@ impl ReaderState {
                     }
                 }
                 Ok(Event::Comment(BytesText::wrap(
-                    // Cut of `!--` and `--` from start and end
-                    &buf[3..len - 2],
+                    // Cut of `<!--` and `--` from start and end
+                    &buf[4..len - 2],
                     self.decoder(),
                 )))
             }
@@ -133,11 +137,15 @@ impl ReaderState {
             // https://www.w3.org/TR/xml11/#sec-cdata-sect
             // Even HTML5 required uppercase only:
             // https://html.spec.whatwg.org/multipage/parsing.html#markup-declaration-open-state
-            BangType::CData if buf.starts_with(b"![CDATA[") => {
-                debug_assert!(buf.ends_with(b"]]"));
+            BangType::CData if buf.starts_with(b"<![CDATA[") => {
+                debug_assert!(
+                    buf.ends_with(b"]]"),
+                    "CDATA must end with ']]':\n{:?}",
+                    crate::utils::Bytes(buf)
+                );
                 Ok(Event::CData(BytesCData::wrap(
-                    // Cut of `![CDATA[` and `]]` from start and end
-                    &buf[8..len - 2],
+                    // Cut of `<![CDATA[` and `]]` from start and end
+                    &buf[9..len - 2],
                     self.decoder(),
                 )))
             }
@@ -145,11 +153,11 @@ impl ReaderState {
             // https://www.w3.org/TR/xml11/#sec-prolog-dtd
             // HTML5 allows mixed case for doctype declarations:
             // https://html.spec.whatwg.org/multipage/parsing.html#markup-declaration-open-state
-            BangType::DocType(DtdParser::Finished) if uncased_starts_with(buf, b"!DOCTYPE") => {
-                match buf[8..].iter().position(|&b| !is_whitespace(b)) {
+            BangType::DocType(DtdParser::Finished) if uncased_starts_with(buf, b"<!DOCTYPE") => {
+                match buf[9..].iter().position(|&b| !is_whitespace(b)) {
                     Some(start) => Ok(Event::DocType(BytesText::wrap(
-                        // Cut of `!DOCTYPE` and any number of spaces from start
-                        &buf[8 + start..],
+                        // Cut of `<!DOCTYPE` and any number of spaces from start
+                        &buf[9 + start..],
                         self.decoder(),
                     ))),
                     None => {
@@ -163,10 +171,10 @@ impl ReaderState {
             }
             _ => {
                 // <!....>
-                //  ^^^^^ - `buf` does not contain `<` and `>`, but `self.offset` is after `>`.
-                // ^------- We report error at that position, so we need to subtract 2 and buf len
-                self.last_error_offset = self.offset - len as u64 - 2;
-                Err(bang_type.to_err().into())
+                // ~~~~~~ - `buf` does not contain `>` and `self.offset` is after `>`.
+                // ^------- We report error at that position, so we need to subtract 1 and buf len
+                self.last_error_offset = self.offset - len as u64 - 1;
+                Err(Error::Syntax(bang_type.to_err()))
             }
         }
     }
@@ -176,14 +184,14 @@ impl ReaderState {
     ///
     /// `buf` contains data between `<` and `>`, for example `/tag`.
     pub fn emit_end<'b>(&mut self, buf: &'b [u8]) -> Result<Event<'b>> {
-        debug_assert_eq!(
-            buf.first(),
-            Some(&b'/'),
-            "closing tag should start from '/'"
+        debug_assert!(
+            buf.starts_with(b"</"),
+            "end tag must start from '</':\n{:?}",
+            crate::utils::Bytes(buf)
         );
 
-        // Strip the `/` character. `content` contains data between `</` and `>`
-        let content = &buf[1..];
+        // Strip the `</` characters. `content` contains data between `</` and `>`
+        let content = &buf[2..];
         // XML standard permits whitespaces after the markup name in closing tags.
         // Let's strip them from the buffer before comparing tag names.
         let name = if self.config.trim_markup_names_in_closing_tags {
@@ -209,8 +217,8 @@ impl ReaderState {
                         self.opened_buffer.truncate(start);
 
                         // Report error at start of the end tag at `<` character
-                        // -2 for `<` and `>`
-                        self.last_error_offset = self.offset - buf.len() as u64 - 2;
+                        // -1 for `>`
+                        self.last_error_offset = self.offset - buf.len() as u64 - 1;
                         return Err(Error::IllFormed(IllFormedError::MismatchedEndTag {
                             expected,
                             found: decoder.decode(name).unwrap_or_default().into_owned(),
@@ -223,8 +231,8 @@ impl ReaderState {
             None => {
                 if !self.config.allow_unmatched_ends {
                     // Report error at start of the end tag at `<` character
-                    // -2 for `<` and `>`
-                    self.last_error_offset = self.offset - buf.len() as u64 - 2;
+                    // -1 for `>`
+                    self.last_error_offset = self.offset - buf.len() as u64 - 1;
                     return Err(Error::IllFormed(IllFormedError::UnmatchedEndTag(
                         decoder.decode(name).unwrap_or_default().into_owned(),
                     )));
@@ -240,15 +248,23 @@ impl ReaderState {
     ///
     /// Returns `Decl` or `PI` event
     pub fn emit_question_mark<'b>(&mut self, buf: &'b [u8]) -> Result<Event<'b>> {
-        debug_assert!(!buf.is_empty());
-        debug_assert_eq!(buf[0], b'?');
+        debug_assert!(
+            buf.starts_with(b"<?"),
+            "processing instruction or XML declaration must start from '<?':\n{:?}",
+            crate::utils::Bytes(buf)
+        );
+        debug_assert!(
+            buf.ends_with(b"?"),
+            "processing instruction or XML declaration must end with '?':\n{:?}",
+            crate::utils::Bytes(buf)
+        );
 
         let len = buf.len();
         // We accept at least <??>
-        //                     ~~ - len = 2
-        if len > 1 && buf[len - 1] == b'?' {
-            // Cut of `?` and `?` from start and end
-            let content = &buf[1..len - 1];
+        //                    ~~~ - len = 3
+        if len > 2 {
+            // Cut of `<?` and `?` from start and end
+            let content = &buf[2..len - 1];
             let len = content.len();
 
             if content.starts_with(b"xml") && (len == 3 || is_whitespace(content[3])) {
@@ -272,9 +288,9 @@ impl ReaderState {
             }
         } else {
             // <?....>
-            //  ^^^^^ - `buf` does not contain `<`, but we want to report error at `<`,
-            //          so we move offset to it (-2 for `<` and `>`)
-            self.last_error_offset = self.offset - len as u64 - 2;
+            // ~~~~~~ - `buf` contains that and `self.offset` is after `>`.
+            // ^------- We report error at that position, so we need to subtract 1 and buf len
+            self.last_error_offset = self.offset - len as u64 - 1;
             Err(Error::Syntax(PiParser(false).eof_error(buf)))
         }
     }
@@ -284,6 +300,14 @@ impl ReaderState {
     /// # Parameters
     /// - `content`: Content of a tag between `<` and `>`
     pub fn emit_start<'b>(&mut self, content: &'b [u8]) -> Event<'b> {
+        debug_assert!(
+            content.starts_with(b"<"),
+            "start or empty tag must start from '<':\n{:?}",
+            crate::utils::Bytes(content)
+        );
+
+        // strip `<`
+        let content = &content[1..];
         if let Some(content) = content.strip_suffix(b"/") {
             // This is self-closed tag `<something/>`
             let event = BytesStart::wrap(content, name_len(content), self.decoder());
diff --git a/tests/reader-errors.rs b/tests/reader-errors.rs
index 8f0d051f..58b4271a 100644
--- a/tests/reader-errors.rs
+++ b/tests/reader-errors.rs
@@ -13,7 +13,7 @@ mod syntax {
     mod tag {
         use super::*;
 
-        syntax_err!(unclosed1(".<")   => SyntaxError::UnclosedTag);
+        syntax_err!(unclosed1(".<")   => 1, SyntaxError::UnclosedTag);
         syntax_err!(unclosed2(".</")  => SyntaxError::UnclosedTag);
         syntax_err!(unclosed3(".<x")  => SyntaxError::UnclosedTag);
         syntax_err!(unclosed4(".< ")  => SyntaxError::UnclosedTag);
@@ -78,10 +78,10 @@ mod syntax {
     }
 
     // Incorrect after-bang symbol is detected early, so buffer_position() stay at `!`
-    syntax_err!(unclosed_bang1(".<!")   => 2, SyntaxError::InvalidBangMarkup);
-    syntax_err!(unclosed_bang2(".<!>")  => 2, SyntaxError::InvalidBangMarkup);
-    syntax_err!(unclosed_bang3(".<!a")  => 2, SyntaxError::InvalidBangMarkup);
-    syntax_err!(unclosed_bang4(".<!a>") => 2, SyntaxError::InvalidBangMarkup);
+    syntax_err!(unclosed_bang1(".<!")   => 1, SyntaxError::InvalidBangMarkup);
+    syntax_err!(unclosed_bang2(".<!>")  => 1, SyntaxError::InvalidBangMarkup);
+    syntax_err!(unclosed_bang3(".<!a")  => 1, SyntaxError::InvalidBangMarkup);
+    syntax_err!(unclosed_bang4(".<!a>") => 1, SyntaxError::InvalidBangMarkup);
 
     /// https://www.w3.org/TR/xml11/#NT-Comment
     mod comment {
diff --git a/tests/reader-read-text.rs b/tests/reader-read-text.rs
new file mode 100644
index 00000000..05d8f1de
--- /dev/null
+++ b/tests/reader-read-text.rs
@@ -0,0 +1,313 @@
+use quick_xml::events::{BytesCData, BytesDecl, BytesEnd, BytesPI, BytesStart, BytesText, Event};
+use quick_xml::name::QName;
+use quick_xml::reader::Reader;
+
+mod borrowed {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    /// Yes, this test contains invalid XML but since we can parse it, we check
+    /// that it does not break our parser
+    #[test]
+    fn decl() {
+        let mut reader = Reader::from_str(
+            "\
+            <root>\
+                <?xml version=\"1.0\"?>\
+                <root/>\
+                <root></root>\
+            </root>\
+            <element/>",
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Start(BytesStart::from_content("root", 4)),
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Decl(BytesDecl::new("1.0", None, None))
+        );
+        assert_eq!(
+            reader.read_text(QName(b"root")).unwrap(),
+            "<root/><root></root>"
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Empty(BytesStart::new("element"))
+        );
+        assert_eq!(reader.read_event().unwrap(), Event::Eof);
+    }
+
+    /// Yes, this test contains invalid XML but since we can parse it, we check
+    /// that it does not break our parser
+    #[test]
+    fn doctype() {
+        let mut reader = Reader::from_str(
+            "\
+            <root>\
+                <!DOCTYPE dtd>\
+                <root/>\
+                <root></root>\
+            </root>\
+            <element/>",
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Start(BytesStart::from_content("root", 4)),
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::DocType(BytesText::new("dtd"))
+        );
+        assert_eq!(
+            reader.read_text(QName(b"root")).unwrap(),
+            "<root/><root></root>"
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Empty(BytesStart::new("element"))
+        );
+        assert_eq!(reader.read_event().unwrap(), Event::Eof);
+    }
+
+    #[test]
+    fn pi() {
+        let mut reader = Reader::from_str(
+            "\
+            <root>\
+                <?pi?>\
+                <root/>\
+                <root></root>\
+            </root>\
+            <element/>",
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Start(BytesStart::from_content("root", 4)),
+        );
+        assert_eq!(reader.read_event().unwrap(), Event::PI(BytesPI::new("pi")));
+        assert_eq!(
+            reader.read_text(QName(b"root")).unwrap(),
+            "<root/><root></root>"
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Empty(BytesStart::new("element"))
+        );
+        assert_eq!(reader.read_event().unwrap(), Event::Eof);
+    }
+
+    #[test]
+    fn comment() {
+        let mut reader = Reader::from_str(
+            "\
+            <root>\
+                <!--comment-->\
+                <root/>\
+                <root></root>\
+            </root>\
+            <element/>",
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Start(BytesStart::from_content("root", 4)),
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Comment(BytesText::new("comment"))
+        );
+        assert_eq!(
+            reader.read_text(QName(b"root")).unwrap(),
+            "<root/><root></root>"
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Empty(BytesStart::new("element"))
+        );
+        assert_eq!(reader.read_event().unwrap(), Event::Eof);
+    }
+
+    #[test]
+    fn start() {
+        let mut reader = Reader::from_str(
+            "\
+            <root>\
+                <tag>\
+                <root/>\
+                <root></root>\
+            </root>\
+            <element/>",
+        );
+        reader.config_mut().check_end_names = false;
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Start(BytesStart::from_content("root", 4)),
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Start(BytesStart::new("tag")),
+        );
+        assert_eq!(
+            reader.read_text(QName(b"root")).unwrap(),
+            "<root/><root></root>"
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Empty(BytesStart::new("element"))
+        );
+        assert_eq!(reader.read_event().unwrap(), Event::Eof);
+    }
+
+    #[test]
+    fn end() {
+        let mut reader = Reader::from_str(
+            "\
+            <root>\
+                </tag>\
+                <root/>\
+                <root></root>\
+            </root>\
+            <element/>",
+        );
+        reader.config_mut().check_end_names = false;
+        reader.config_mut().allow_unmatched_ends = true;
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Start(BytesStart::from_content("root", 4)),
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::End(BytesEnd::new("tag")),
+        );
+        assert_eq!(
+            reader.read_text(QName(b"root")).unwrap(),
+            "<root/><root></root>"
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Empty(BytesStart::new("element"))
+        );
+        assert_eq!(reader.read_event().unwrap(), Event::Eof);
+    }
+
+    #[test]
+    fn empty() {
+        let mut reader = Reader::from_str(
+            "\
+            <root>\
+                <tag/>\
+                <root/>\
+                <root></root>\
+            </root>\
+            <element/>",
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Start(BytesStart::from_content("root", 4)),
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Empty(BytesStart::new("tag")),
+        );
+        assert_eq!(
+            reader.read_text(QName(b"root")).unwrap(),
+            "<root/><root></root>"
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Empty(BytesStart::new("element"))
+        );
+        assert_eq!(reader.read_event().unwrap(), Event::Eof);
+    }
+
+    #[test]
+    fn text() {
+        let mut reader = Reader::from_str(
+            "\
+            <root>\
+                text\
+                <root/>\
+                <root></root>\
+            </root>\
+            <element/>",
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Start(BytesStart::from_content("root", 4)),
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Text(BytesText::new("text"))
+        );
+        assert_eq!(
+            reader.read_text(QName(b"root")).unwrap(),
+            "<root/><root></root>"
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Empty(BytesStart::new("element"))
+        );
+        assert_eq!(reader.read_event().unwrap(), Event::Eof);
+    }
+
+    #[test]
+    fn cdata() {
+        let mut reader = Reader::from_str(
+            "\
+            <root>\
+                <![CDATA[cdata]]>\
+                <root/>\
+                <root></root>\
+            </root>\
+            <element/>",
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Start(BytesStart::from_content("root", 4)),
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::CData(BytesCData::new("cdata"))
+        );
+        assert_eq!(
+            reader.read_text(QName(b"root")).unwrap(),
+            "<root/><root></root>"
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Empty(BytesStart::new("element"))
+        );
+        assert_eq!(reader.read_event().unwrap(), Event::Eof);
+    }
+
+    #[test]
+    fn dangling_amp() {
+        let mut reader = Reader::from_str(
+            "\
+            <root>\
+                &\
+                <root/>\
+                <root></root>\
+            </root>\
+            <element/>",
+        );
+        reader.config_mut().allow_dangling_amp = true;
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Start(BytesStart::from_content("root", 4)),
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Text(BytesText::from_escaped("&"))
+        );
+        assert_eq!(
+            reader.read_text(QName(b"root")).unwrap(),
+            "<root/><root></root>"
+        );
+        assert_eq!(
+            reader.read_event().unwrap(),
+            Event::Empty(BytesStart::new("element"))
+        );
+        assert_eq!(reader.read_event().unwrap(), Event::Eof);
+    }
+}