>;
/// Read input until start of markup (the `<`) is found, start of general entity
/// reference (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 end of general reference (the `;`) is found, start of
/// another general reference (the `&`) is found or end of input is reached.
///
/// This method must be called when current character is `&`.
///
/// # 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_ref(&mut self, buf: B, position: &mut u64) -> ReadRefResult<'r>;
/// 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 str, 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 str), 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(DtdParser),
}
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(DtdParser::BeforeInternalSubset(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 feed(&mut self, buf: &[u8], chunk: &[u8]) -> Option {
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
// 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
// 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(i);
}
// End sequence `-|->` was splitted at |
// buf --/ \-- chunk
if i == 1 && buf.ends_with(b"-") && chunk[0] == b'-' {
return Some(i);
}
// End sequence `--|>` was splitted at |
// buf --/ \-- chunk
if i == 0 && buf.ends_with(b"--") {
return Some(i);
}
}
}
}
Self::CData => {
for i in memchr::memchr_iter(b'>', chunk) {
if chunk[..i].ends_with(b"]]") {
return Some(i);
}
// End sequence `]|]>` was splitted at |
// buf --/ \-- chunk
if i == 1 && buf.ends_with(b"]") && chunk[0] == b']' {
return Some(i);
}
// End sequence `]]|>` was splitted at |
// buf --/ \-- chunk
if i == 0 && buf.ends_with(b"]]") {
return Some(i);
}
}
}
Self::DocType(parser) => return parser.feed(buf, chunk),
}
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,
// constructor of the XML source on which internal functions will be called
$source:path,
$skip:literal,
// 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, DtdParser};
/// 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 = 0;
let mut input = &b"other content"[$skip..];
// ^= 0
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 = 0;
let mut input = &b" 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 = 0;
let mut input = &b"other content"[$skip..];
// ^= 0 ^= 12
let (ty, bytes) = $source(&mut input)
.read_bang_element(buf, &mut position)
$(.$await)?
.unwrap();
assert_eq!(
(ty, bytes),
(BangType::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 = 0;
let mut input = &b"content]]>other content]]>"[$skip..];
// ^= 0 ^= 29
let (ty, bytes) = $source(&mut input)
.read_bang_element(buf, &mut position)
$(.$await)?
.unwrap();
assert_eq!(
(ty, bytes),
(BangType::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 = 0;
let mut input = &b"other content"[$skip..];
// ^= 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 = 0;
let mut input = &b"other content"[$skip..];
// ^= 0 ^= 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 = 0;
let mut input = &b"other content"[$skip..];
// ^= 0 ^= 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 = 0;
let mut input = &b"other content"[$skip..];
// ^= 0 ^= 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 = 0;
let mut input = &b"other content"[$skip..];
// ^= 0 ^= 7
let (ty, bytes) = $source(&mut input)
.read_bang_element(buf, &mut position)
$(.$await)?
.unwrap();
assert_eq!(
(ty, bytes),
(BangType::Comment, "")
);
assert_eq!(position, 7);
}
#[$test]
$($async)? fn with_content() {
let buf = $buf;
let mut position = 0;
let mut input = &b"comment<--->other content"[$skip..];
// ^= 0 ^= 18
let (ty, bytes) = $source(&mut input)
.read_bang_element(buf, &mut position)
$(.$await)?
.unwrap();
assert_eq!(
(ty, bytes),
(BangType::Comment, "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 = 0;
let mut input = &b" 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 = 0;
let mut input = &b" 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 = 0;
let mut input = &b"other content"[$skip..];
// ^= 0 ^= 10
let (ty, bytes) = $source(&mut input)
.read_bang_element(buf, &mut position)
$(.$await)?
.unwrap();
assert_eq!(
(ty, bytes),
(BangType::DocType(DtdParser::Finished), "")
);
assert_eq!(position, 10);
}
#[$test]
$($async)? fn not_closed() {
let buf = $buf;
let mut position = 0;
let mut input = &b" 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 = 0;
let mut input = &b" 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 = 0;
let mut input = &b" 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 = 0;
let mut input = &b"other content"[$skip..];
// ^= 0 ^= 10
let (ty, bytes) = $source(&mut input)
.read_bang_element(buf, &mut position)
$(.$await)?
.unwrap();
assert_eq!(
(ty, bytes),
(BangType::DocType(DtdParser::Finished), "")
);
assert_eq!(position, 10);
}
#[$test]
$($async)? fn not_closed() {
let buf = $buf;
let mut position = 0;
let mut input = &b" assert_eq!(cause, SyntaxError::UnclosedDoctype),
x => panic!(
"Expected `Err(Syntax(_))`, but got `{:?}`",
x
),
}
assert_eq!(position, 23);
}
}
}
}
mod read_text {
use super::*;
use crate::reader::ReadTextResult;
use pretty_assertions::assert_eq;
#[$test]
$($async)? fn empty() {
let buf = $buf;
let mut position = 1;
let mut input = b"".as_ref();
// ^= 1
match $source(&mut input).read_text(buf, &mut position) $(.$await)? {
ReadTextResult::UpToEof(bytes) => assert_eq!(bytes, ""),
x => panic!("Expected `UpToEof(_)`, but got `{:?}`", x),
}
assert_eq!(position, 1);
}
#[$test]
$($async)? fn markup() {
let buf = $buf;
let mut position = 1;
let mut input = b"<".as_ref();
// ^= 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, 1);
}
#[$test]
$($async)? fn ref_() {
let buf = $buf;
let mut position = 1;
let mut input = b"&".as_ref();
// ^= 1
match $source(&mut input).read_text(buf, &mut position) $(.$await)? {
ReadTextResult::Ref(b) => assert_eq!(b, $buf),
x => panic!("Expected `Ref(_)`, but got `{:?}`", x),
}
assert_eq!(position, 1);
}
#[$test]
$($async)? fn up_to_markup() {
let buf = $buf;
let mut position = 1;
let mut input = b"a<".as_ref();
// ^= 2
match $source(&mut input).read_text(buf, &mut position) $(.$await)? {
ReadTextResult::UpToMarkup(bytes) => assert_eq!(bytes, "a"),
x => panic!("Expected `UpToMarkup(_)`, but got `{:?}`", x),
}
assert_eq!(position, 2);
}
#[$test]
$($async)? fn up_to_ref() {
let buf = $buf;
let mut position = 1;
let mut input = b"a&".as_ref();
// ^= 2
match $source(&mut input).read_text(buf, &mut position) $(.$await)? {
ReadTextResult::UpToRef(bytes) => assert_eq!(bytes, "a"),
x => panic!("Expected `UpToRef(_)`, but got `{:?}`", x),
}
assert_eq!(position, 2);
}
#[$test]
$($async)? fn up_to_eof() {
let buf = $buf;
let mut position = 1;
let mut input = b"a".as_ref();
// ^= 2
match $source(&mut input).read_text(buf, &mut position) $(.$await)? {
ReadTextResult::UpToEof(bytes) => assert_eq!(bytes, "a"),
x => panic!("Expected `UpToEof(_)`, but got `{:?}`", x),
}
assert_eq!(position, 2);
}
}
mod read_ref {
use super::*;
use crate::reader::ReadRefResult;
use pretty_assertions::assert_eq;
// Empty input is not allowed for `read_ref` so not tested.
// Borrowed source triggers debug assertion,
// buffered do nothing due to implementation details.
#[$test]
$($async)? fn up_to_eof() {
let buf = $buf;
let mut position = 1;
let mut input = b"&".as_ref();
// ^= 2
match $source(&mut input).read_ref(buf, &mut position) $(.$await)? {
ReadRefResult::UpToEof(bytes) => assert_eq!(bytes, "&"),
x => panic!("Expected `UpToEof(_)`, but got `{:?}`", x),
}
assert_eq!(position, 2);
}
#[$test]
$($async)? fn up_to_ref() {
let buf = $buf;
let mut position = 1;
let mut input = b"&&".as_ref();
// ^= 2
match $source(&mut input).read_ref(buf, &mut position) $(.$await)? {
ReadRefResult::UpToRef(bytes) => assert_eq!(bytes, "&"),
x => panic!("Expected `UpToRef(_)`, but got `{:?}`", x),
}
assert_eq!(position, 2);
}
#[$test]
$($async)? fn up_to_markup() {
let buf = $buf;
let mut position = 1;
let mut input = b"&<".as_ref();
// ^= 2
match $source(&mut input).read_ref(buf, &mut position) $(.$await)? {
ReadRefResult::UpToMarkup(bytes) => assert_eq!(bytes, "&"),
x => panic!("Expected `UpToMarkup(_)`, but got `{:?}`", x),
}
assert_eq!(position, 2);
}
#[$test]
$($async)? fn empty_ref() {
let buf = $buf;
let mut position = 1;
let mut input = b"&;".as_ref();
// ^= 3
match $source(&mut input).read_ref(buf, &mut position) $(.$await)? {
ReadRefResult::Ref(bytes) => assert_eq!(bytes, "&;"),
x => panic!("Expected `Ref(_)`, but got `{:?}`", x),
}
assert_eq!(position, 3);
}
#[$test]
$($async)? fn normal() {
let buf = $buf;
let mut position = 1;
let mut input = b"<".as_ref();
// ^= 5
match $source(&mut input).read_ref(buf, &mut position) $(.$await)? {
ReadRefResult::Ref(bytes) => assert_eq!(bytes, "<"),
x => panic!("Expected `Ref(_)`, but got `{:?}`", x),
}
assert_eq!(position, 5);
}
}
mod read_element {
use super::*;
use crate::errors::{Error, SyntaxError};
use crate::parser::ElementParser;
use pretty_assertions::assert_eq;
/// Checks that nothing was read from empty buffer
/// `<` read in peek_one that is called before read_with, that is why it in the input buffer
/// peek_one, however, does not increment position for simplicity of the code
#[$test]
$($async)? fn empty() {
let buf = $buf;
let mut position = 0;
let mut input = &b"<"[$skip..];
// ^= 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 = 0;
let mut input = &b"<>"[$skip..];
// ^= 2
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
"<>"
);
assert_eq!(position, 2);
}
#[$test]
$($async)? fn normal() {
let buf = $buf;
let mut position = 0;
let mut input = &b""[$skip..];
// ^= 5
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
""
);
assert_eq!(position, 5);
}
#[$test]
$($async)? fn empty_ns_empty_tag() {
let buf = $buf;
let mut position = 0;
let mut input = &b"<:>"[$skip..];
// ^= 3
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
"<:>"
);
assert_eq!(position, 3);
}
#[$test]
$($async)? fn empty_ns() {
let buf = $buf;
let mut position = 0;
let mut input = &b"<:tag>"[$skip..];
// ^= 6
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
"<:tag>"
);
assert_eq!(position, 6);
}
#[$test]
$($async)? fn with_attributes() {
let buf = $buf;
let mut position = 0;
let mut input = &br#""#[$skip..];
// ^= 39
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
r#""#
);
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 = 0;
let mut input = &b""[$skip..];
// ^= 3
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
""
);
assert_eq!(position, 3);
}
#[$test]
$($async)? fn normal() {
let buf = $buf;
let mut position = 0;
let mut input = &b""[$skip..];
// ^= 6
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
""
);
assert_eq!(position, 6);
}
#[$test]
$($async)? fn empty_ns_empty_tag() {
let buf = $buf;
let mut position = 0;
let mut input = &b"<:/>"[$skip..];
// ^= 4
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
"<:/>"
);
assert_eq!(position, 4);
}
#[$test]
$($async)? fn empty_ns() {
let buf = $buf;
let mut position = 0;
let mut input = &b"<:tag/>"[$skip..];
// ^= 7
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
"<:tag/>"
);
assert_eq!(position, 7);
}
#[$test]
$($async)? fn with_attributes() {
let buf = $buf;
let mut position = 0;
let mut input = &br#""#[$skip..];
// ^= 42
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
r#""#
);
assert_eq!(position, 42);
}
}
mod close {
use super::*;
use pretty_assertions::assert_eq;
#[$test]
$($async)? fn empty_tag() {
let buf = $buf;
let mut position = 0;
let mut input = &b""[$skip..];
// ^= 4
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
""
);
assert_eq!(position, 4);
}
#[$test]
$($async)? fn normal() {
let buf = $buf;
let mut position = 0;
let mut input = &b""[$skip..];
// ^= 6
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
""
);
assert_eq!(position, 6);
}
#[$test]
$($async)? fn empty_ns_empty_tag() {
let buf = $buf;
let mut position = 0;
let mut input = &b""[$skip..];
// ^= 4
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
""
);
assert_eq!(position, 4);
}
#[$test]
$($async)? fn empty_ns() {
let buf = $buf;
let mut position = 0;
let mut input = &b""[$skip..];
// ^= 7
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
""
);
assert_eq!(position, 7);
}
#[$test]
$($async)? fn with_attributes() {
let buf = $buf;
let mut position = 0;
let mut input = &br#""#[$skip..];
// ^= 40
assert_eq!(
$source(&mut input).read_with(ElementParser::default(), buf, &mut position) $(.$await)? .unwrap(),
r#""#
);
assert_eq!(position, 40);
}
}
}
/// Ensures, that no empty `Text` events are generated
mod $read_event {
use crate::events::{BytesCData, BytesComment, 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(BytesComment::new("").unwrap())
);
}
#[$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;
}