>;
/// Read input until start of markup (the `<`) is found or end of input is reached.
///
/// # Parameters
/// - `buf`: Buffer that could be filled from an input (`Self`) and
/// from which [events] could borrow their data
/// - `position`: Will be increased by amount of bytes consumed
///
/// [events]: crate::events::Event
fn read_text(&mut self, buf: B, position: &mut u64) -> ReadTextResult<'r, B>;
/// Read input until processing instruction is finished.
///
/// This method expect that start sequence of a parser already was read.
///
/// Returns a slice of data read up to the end of the thing being parsed.
/// The end of thing and the returned content is determined by the used parser.
///
/// If input (`Self`) is exhausted and no bytes was read, or if the specified
/// parser could not find the ending sequence of the thing, returns `SyntaxError`.
///
/// # Parameters
/// - `buf`: Buffer that could be filled from an input (`Self`) and
/// from which [events] could borrow their data
/// - `position`: Will be increased by amount of bytes consumed
///
/// A `P` type parameter is used to preserve state between calls to the underlying
/// reader which provides bytes fed into the parser.
///
/// [events]: crate::events::Event
fn read_with(&mut self, parser: P, buf: B, position: &mut u64) -> Result<&'r [u8], Error>
where
P: Parser;
/// Read input until comment or CDATA is finished.
///
/// This method expect that `<` already was read.
///
/// Returns a slice of data read up to end of comment or CDATA (`>`),
/// which does not include into result.
///
/// If input (`Self`) is exhausted and nothing was read, returns `None`.
///
/// # Parameters
/// - `buf`: Buffer that could be filled from an input (`Self`) and
/// from which [events] could borrow their data
/// - `position`: Will be increased by amount of bytes consumed
///
/// [events]: crate::events::Event
fn read_bang_element(
&mut self,
buf: B,
position: &mut u64,
) -> Result<(BangType, &'r [u8]), Error>;
/// Consume and discard all the whitespace until the next non-whitespace
/// character or EOF.
///
/// # Parameters
/// - `position`: Will be increased by amount of bytes consumed
fn skip_whitespace(&mut self, position: &mut u64) -> io::Result<()>;
/// Return one character without consuming it, so that future `read_*` calls
/// will still include it. On EOF, return `None`.
fn peek_one(&mut self) -> io::Result>;
}
/// Possible elements started with `
CData,
///
Comment,
/// . Contains balance of '<' (+1) and '>' (-1)
DocType(i32),
}
impl BangType {
#[inline(always)]
const fn new(byte: Option) -> Result {
Ok(match byte {
Some(b'[') => Self::CData,
Some(b'-') => Self::Comment,
Some(b'D') | Some(b'd') => Self::DocType(0),
_ => return Err(SyntaxError::InvalidBangMarkup),
})
}
/// If element is finished, returns its content up to `>` symbol and
/// an index of this symbol, otherwise returns `None`
///
/// # Parameters
/// - `buf`: buffer with data consumed on previous iterations
/// - `chunk`: data read on current iteration and not yet consumed from reader
#[inline(always)]
fn parse<'b>(&mut self, buf: &[u8], chunk: &'b [u8]) -> Option<(&'b [u8], usize)> {
match self {
Self::Comment => {
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 {
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
// will not end with `--->` sequence because this is a special case of
// `--` in the comment (https://www.w3.org/TR/xml11/#sec-comments)
return Some((&chunk[..i], i + 1)); // +1 for `>`
}
// End sequence `-|->` was splitted at |
// buf --/ \-- chunk
if i == 1 && buf.ends_with(b"-") && chunk[0] == b'-' {
return Some((&chunk[..i], i + 1)); // +1 for `>`
}
// End sequence `--|>` was splitted at |
// buf --/ \-- chunk
if i == 0 && buf.ends_with(b"--") {
return Some((&[], i + 1)); // +1 for `>`
}
}
}
}
Self::CData => {
for i in memchr::memchr_iter(b'>', chunk) {
if chunk[..i].ends_with(b"]]") {
return Some((&chunk[..i], i + 1)); // +1 for `>`
}
// End sequence `]|]>` was splitted at |
// buf --/ \-- chunk
if i == 1 && buf.ends_with(b"]") && chunk[0] == b']' {
return Some((&chunk[..i], i + 1)); // +1 for `>`
}
// End sequence `]]|>` was splitted at |
// buf --/ \-- chunk
if i == 0 && buf.ends_with(b"]]") {
return Some((&[], i + 1)); // +1 for `>`
}
}
}
Self::DocType(ref mut balance) => {
for i in memchr::memchr2_iter(b'<', b'>', chunk) {
if chunk[i] == b'<' {
*balance += 1;
} else {
if *balance == 0 {
return Some((&chunk[..i], i + 1)); // +1 for `>`
}
*balance -= 1;
}
}
}
}
None
}
#[inline]
const fn to_err(&self) -> SyntaxError {
match self {
Self::CData => SyntaxError::UnclosedCData,
Self::Comment => SyntaxError::UnclosedComment,
Self::DocType(_) => SyntaxError::UnclosedDoctype,
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
#[cfg(test)]
mod test {
/// Checks the internal implementation of the various reader methods
macro_rules! check {
(
#[$test:meta]
$read_event:ident,
$read_until_close:ident,
// constructor of the XML source on which internal functions will be called
$source:path,
// constructor of the buffer to which read data will stored
$buf:expr
$(, $async:ident, $await:ident)?
) => {
mod read_bang_element {
use super::*;
use crate::errors::{Error, SyntaxError};
use crate::reader::BangType;
use crate::utils::Bytes;
/// Checks that reading CDATA content works correctly
mod cdata {
use super::*;
use pretty_assertions::assert_eq;
/// Checks that if input begins like CDATA element, but CDATA start sequence
/// is not finished, parsing ends with an error
#[$test]
#[ignore = "start CDATA sequence fully checked outside of `read_bang_element`"]
$($async)? fn not_properly_start() {
let buf = $buf;
let mut position = 1;
let mut input = b"![]]>other content".as_ref();
// ^= 1
match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedCData),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 1);
}
/// Checks that if CDATA startup sequence was matched, but an end sequence
/// is not found, parsing ends with an error
#[$test]
$($async)? fn not_closed() {
let buf = $buf;
let mut position = 1;
let mut input = b"![CDATA[other content".as_ref();
// ^= 1 ^= 22
match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedCData),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 22);
}
/// Checks that CDATA element without content inside parsed successfully
#[$test]
$($async)? fn empty() {
let buf = $buf;
let mut position = 1;
let mut input = b"![CDATA[]]>other content".as_ref();
// ^= 1 ^= 12
let (ty, bytes) = $source(&mut input)
.read_bang_element(buf, &mut position)
$(.$await)?
.unwrap();
assert_eq!(
(ty, Bytes(bytes)),
(BangType::CData, Bytes(b"![CDATA[]]"))
);
assert_eq!(position, 12);
}
/// Checks that CDATA element with content parsed successfully.
/// Additionally checks that sequences inside CDATA that may look like
/// a CDATA end sequence do not interrupt CDATA parsing
#[$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 (ty, bytes) = $source(&mut input)
.read_bang_element(buf, &mut position)
$(.$await)?
.unwrap();
assert_eq!(
(ty, Bytes(bytes)),
(BangType::CData, Bytes(b"![CDATA[cdata]] ]>content]]"))
);
assert_eq!(position, 29);
}
}
/// Checks that reading XML comments works correctly. According to the [specification],
/// comment data can contain any sequence except `--`:
///
/// ```peg
/// comment = '<--' (!'--' char)* '-->';
/// char = [#x1-#x2C]
/// / [#x2E-#xD7FF]
/// / [#xE000-#xFFFD]
/// / [#x10000-#x10FFFF]
/// ```
///
/// The presence of this limitation, however, is simply a poorly designed specification
/// (maybe for purpose of building of LL(1) XML parser) and quick-xml does not check for
/// presence of these sequences by default. This tests allow such content.
///
/// [specification]: https://www.w3.org/TR/xml11/#dt-comment
mod comment {
use super::*;
use pretty_assertions::assert_eq;
#[$test]
#[ignore = "start comment sequence fully checked outside of `read_bang_element`"]
$($async)? fn not_properly_start() {
let buf = $buf;
let mut position = 1;
let mut input = b"!- -->other content".as_ref();
// ^= 1
match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedComment),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 1);
}
#[$test]
$($async)? fn not_properly_end() {
let buf = $buf;
let mut position = 1;
let mut input = b"!->other content".as_ref();
// ^= 1 ^= 17
match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedComment),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 17);
}
#[$test]
$($async)? fn not_closed1() {
let buf = $buf;
let mut position = 1;
let mut input = b"!--other content".as_ref();
// ^= 1 ^= 17
match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedComment),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 17);
}
#[$test]
$($async)? fn not_closed2() {
let buf = $buf;
let mut position = 1;
let mut input = b"!-->other content".as_ref();
// ^= 1 ^= 18
match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedComment),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 18);
}
#[$test]
$($async)? fn not_closed3() {
let buf = $buf;
let mut position = 1;
let mut input = b"!--->other content".as_ref();
// ^= 1 ^= 19
match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedComment),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 19);
}
#[$test]
$($async)? fn empty() {
let buf = $buf;
let mut position = 1;
let mut input = b"!---->other content".as_ref();
// ^= 1 ^= 7
let (ty, bytes) = $source(&mut input)
.read_bang_element(buf, &mut position)
$(.$await)?
.unwrap();
assert_eq!(
(ty, Bytes(bytes)),
(BangType::Comment, Bytes(b"!----"))
);
assert_eq!(position, 7);
}
#[$test]
$($async)? fn with_content() {
let buf = $buf;
let mut position = 1;
let mut input = b"!--->comment<--->other content".as_ref();
// ^= 1 ^= 18
let (ty, bytes) = $source(&mut input)
.read_bang_element(buf, &mut position)
$(.$await)?
.unwrap();
assert_eq!(
(ty, Bytes(bytes)),
(BangType::Comment, Bytes(b"!--->comment<---"))
);
assert_eq!(position, 18);
}
}
/// Checks that reading DOCTYPE definition works correctly
mod doctype {
use super::*;
mod uppercase {
use super::*;
use pretty_assertions::assert_eq;
#[$test]
$($async)? fn not_properly_start() {
let buf = $buf;
let mut position = 1;
let mut input = b"!D other content".as_ref();
// ^= 1 ^= 17
match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedDoctype),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 17);
}
#[$test]
$($async)? fn without_space() {
let buf = $buf;
let mut position = 1;
let mut input = b"!DOCTYPEother content".as_ref();
// ^= 1 ^= 22
match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedDoctype),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 22);
}
#[$test]
$($async)? fn empty() {
let buf = $buf;
let mut position = 1;
let mut input = b"!DOCTYPE>other content".as_ref();
// ^= 1 ^= 10
let (ty, bytes) = $source(&mut input)
.read_bang_element(buf, &mut position)
$(.$await)?
.unwrap();
assert_eq!(
(ty, Bytes(bytes)),
(BangType::DocType(0), Bytes(b"!DOCTYPE"))
);
assert_eq!(position, 10);
}
#[$test]
$($async)? fn not_closed() {
let buf = $buf;
let mut position = 1;
let mut input = b"!DOCTYPE other content".as_ref();
// ^= 1 ^23
match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedDoctype),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 23);
}
}
mod lowercase {
use super::*;
use pretty_assertions::assert_eq;
#[$test]
$($async)? fn not_properly_start() {
let buf = $buf;
let mut position = 1;
let mut input = b"!d other content".as_ref();
// ^= 1 ^= 17
match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedDoctype),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 17);
}
#[$test]
$($async)? fn without_space() {
let buf = $buf;
let mut position = 1;
let mut input = b"!doctypeother content".as_ref();
// ^= 1 ^= 22
match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedDoctype),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 22);
}
#[$test]
$($async)? fn empty() {
let buf = $buf;
let mut position = 1;
let mut input = b"!doctype>other content".as_ref();
// ^= 1 ^= 10
let (ty, bytes) = $source(&mut input)
.read_bang_element(buf, &mut position)
$(.$await)?
.unwrap();
assert_eq!(
(ty, Bytes(bytes)),
(BangType::DocType(0), Bytes(b"!doctype"))
);
assert_eq!(position, 10);
}
#[$test]
$($async)? fn not_closed() {
let buf = $buf;
let mut position = 1;
let mut input = b"!doctype other content".as_ref();
// ^= 1 ^= 23
match $source(&mut input).read_bang_element(buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedDoctype),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 23);
}
}
}
}
mod read_element {
use super::*;
use crate::errors::{Error, SyntaxError};
use crate::parser::ElementParser;
use crate::utils::Bytes;
use pretty_assertions::assert_eq;
/// Checks that nothing was read from empty buffer
#[$test]
$($async)? fn empty() {
let buf = $buf;
let mut position = 1;
let mut input = b"".as_ref();
// ^= 1
match $source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? {
Err(Error::Syntax(cause)) => assert_eq!(cause, SyntaxError::UnclosedTag),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 1);
}
mod open {
use super::*;
use pretty_assertions::assert_eq;
#[$test]
$($async)? fn empty_tag() {
let buf = $buf;
let mut position = 1;
let mut input = b">".as_ref();
// ^= 2
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(b"")
);
assert_eq!(position, 2);
}
#[$test]
$($async)? fn normal() {
let buf = $buf;
let mut position = 1;
let mut input = b"tag>".as_ref();
// ^= 5
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(b"tag")
);
assert_eq!(position, 5);
}
#[$test]
$($async)? fn empty_ns_empty_tag() {
let buf = $buf;
let mut position = 1;
let mut input = b":>".as_ref();
// ^= 3
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(b":")
);
assert_eq!(position, 3);
}
#[$test]
$($async)? fn empty_ns() {
let buf = $buf;
let mut position = 1;
let mut input = b":tag>".as_ref();
// ^= 6
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(b":tag")
);
assert_eq!(position, 6);
}
#[$test]
$($async)? fn with_attributes() {
let buf = $buf;
let mut position = 1;
let mut input = br#"tag attr-1=">" attr2 = '>' 3attr>"#.as_ref();
// ^= 39
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(br#"tag attr-1=">" attr2 = '>' 3attr"#)
);
assert_eq!(position, 39);
}
}
mod self_closed {
use super::*;
use pretty_assertions::assert_eq;
#[$test]
$($async)? fn empty_tag() {
let buf = $buf;
let mut position = 1;
let mut input = b"/>".as_ref();
// ^= 3
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(b"/")
);
assert_eq!(position, 3);
}
#[$test]
$($async)? fn normal() {
let buf = $buf;
let mut position = 1;
let mut input = b"tag/>".as_ref();
// ^= 6
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(b"tag/")
);
assert_eq!(position, 6);
}
#[$test]
$($async)? fn empty_ns_empty_tag() {
let buf = $buf;
let mut position = 1;
let mut input = b":/>".as_ref();
// ^= 4
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(b":/")
);
assert_eq!(position, 4);
}
#[$test]
$($async)? fn empty_ns() {
let buf = $buf;
let mut position = 1;
let mut input = b":tag/>".as_ref();
// ^= 7
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(b":tag/")
);
assert_eq!(position, 7);
}
#[$test]
$($async)? fn with_attributes() {
let buf = $buf;
let mut position = 1;
let mut input = br#"tag attr-1="/>" attr2 = '/>' 3attr/>"#.as_ref();
// ^= 42
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(br#"tag attr-1="/>" attr2 = '/>' 3attr/"#)
);
assert_eq!(position, 42);
}
}
mod close {
use super::*;
use pretty_assertions::assert_eq;
#[$test]
$($async)? fn empty_tag() {
let buf = $buf;
let mut position = 1;
let mut input = b"/ >".as_ref();
// ^= 4
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(b"/ ")
);
assert_eq!(position, 4);
}
#[$test]
$($async)? fn normal() {
let buf = $buf;
let mut position = 1;
let mut input = b"/tag>".as_ref();
// ^= 6
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(b"/tag")
);
assert_eq!(position, 6);
}
#[$test]
$($async)? fn empty_ns_empty_tag() {
let buf = $buf;
let mut position = 1;
let mut input = b"/:>".as_ref();
// ^= 4
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(b"/:")
);
assert_eq!(position, 4);
}
#[$test]
$($async)? fn empty_ns() {
let buf = $buf;
let mut position = 1;
let mut input = b"/:tag>".as_ref();
// ^= 7
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(b"/:tag")
);
assert_eq!(position, 7);
}
#[$test]
$($async)? fn with_attributes() {
let buf = $buf;
let mut position = 1;
let mut input = br#"/tag attr-1=">" attr2 = '>' 3attr>"#.as_ref();
// ^= 40
assert_eq!(
Bytes($source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap()),
Bytes(br#"/tag attr-1=">" attr2 = '>' 3attr"#)
);
assert_eq!(position, 40);
}
}
}
/// Ensures, that no empty `Text` events are generated
mod $read_event {
use crate::events::{BytesCData, BytesDecl, BytesEnd, BytesPI, BytesStart, BytesText, Event};
use crate::reader::Reader;
use pretty_assertions::assert_eq;
/// When `encoding` feature is enabled, encoding should be detected
/// from BOM (UTF-8) and BOM should be stripped.
///
/// When `encoding` feature is disabled, UTF-8 is assumed and BOM
/// character should be stripped for consistency
#[$test]
$($async)? fn bom_from_reader() {
let mut reader = Reader::from_reader("\u{feff}\u{feff}".as_bytes());
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::Text(BytesText::from_escaped("\u{feff}"))
);
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::Eof
);
}
/// When parsing from &str, encoding is fixed (UTF-8), so
/// - when `encoding` feature is disabled, the behavior the
/// same as in `bom_from_reader` text
/// - when `encoding` feature is enabled, the behavior should
/// stay consistent, so the first BOM character is stripped
#[$test]
$($async)? fn bom_from_str() {
let mut reader = Reader::from_str("\u{feff}\u{feff}");
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::Text(BytesText::from_escaped("\u{feff}"))
);
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::Eof
);
}
#[$test]
$($async)? fn declaration() {
let mut reader = Reader::from_str("");
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::Decl(BytesDecl::from_start(BytesStart::from_content("xml ", 3)))
);
}
#[$test]
$($async)? fn doctype() {
let mut reader = Reader::from_str("");
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::DocType(BytesText::from_escaped("x"))
);
}
#[$test]
$($async)? fn processing_instruction() {
let mut reader = Reader::from_str("\" ?>");
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::PI(BytesPI::new("xml-stylesheet '? >\" "))
);
}
/// Lone closing tags are not allowed, so testing it together with start tag
#[$test]
$($async)? fn start_and_end() {
let mut reader = Reader::from_str("");
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::Start(BytesStart::new("tag"))
);
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::End(BytesEnd::new("tag"))
);
}
#[$test]
$($async)? fn empty() {
let mut reader = Reader::from_str("");
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::Empty(BytesStart::new("tag"))
);
}
#[$test]
$($async)? fn text() {
let mut reader = Reader::from_str("text");
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::Text(BytesText::from_escaped("text"))
);
}
#[$test]
$($async)? fn cdata() {
let mut reader = Reader::from_str("");
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::CData(BytesCData::new(""))
);
}
#[$test]
$($async)? fn comment() {
let mut reader = Reader::from_str("");
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::Comment(BytesText::from_escaped(""))
);
}
#[$test]
$($async)? fn eof() {
let mut reader = Reader::from_str("");
assert_eq!(
reader.$read_event($buf) $(.$await)? .unwrap(),
Event::Eof
);
}
}
};
}
// Export macros for the child modules:
// - buffered_reader
// - slice_reader
pub(super) use check;
}