#![deny(missing_docs)]
pub mod prelude {
pub use crate::{
assert_done,
assert_finished,
assert_done_and_eq,
assert_finished_and_eq,
assert_error,
assert_error_and_eq,
assert_needed,
assert_needs,
};
}
#[macro_export]
macro_rules! assert_done {
($e:expr $(,)?) => (
assert_done!($e, "parser did not complete");
);
($e:expr, $($arg:tt)+) => ({
if let ::std::result::Result::Ok((_, _)) = $e {
assert!(true);
} else {
assert!(false, $($arg)+);
}
})
}
#[cfg(test)]
mod assert_done_test {
use super::prelude::*;
#[test]
fn no_msg() {
let result: nom::IResult<&str, &str> = Ok(("foo", "bar"));
assert_done!(result);
}
#[test]
fn with_msg() {
let result: nom::IResult<&str, &str> = Ok(("foo", "bar"));
assert_done!(result, "should be done");
}
#[test]
#[should_panic]
fn panic_no_msg() {
let result: nom::IResult<&str, &str> = Err(nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
assert_done!(result,);
}
#[test]
#[should_panic]
fn panic_with_msg() {
let result: nom::IResult<&str, &str> = Err(nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
assert_done!(result, "should be done");
}
}
#[macro_export]
macro_rules! assert_finished {
($e:expr $(,)?) => {
assert_finished!($e, "parser did not complete");
};
($e:expr, $($arg:tt)+) => ({
if let ::std::result::Result::Ok((i, _)) = $e {
assert!(i.is_empty());
} else {
assert!(false, $($arg)+);
}
})
}
#[cfg(test)]
mod assert_finished_tests {
use super::prelude::*;
#[test]
fn no_msg() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_finished!(r);
}
#[test]
fn with_msg() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_finished!(r, "should be finished");
}
#[test]
#[should_panic]
fn panic_ok_no_msg() {
let r: nom::IResult<&str, &str> = Ok((" ", "foo"));
assert_finished!(r);
}
#[test]
#[should_panic]
fn panic_ok_with_msg() {
let r: nom::IResult<&str, &str> = Ok((" ", "foo"));
assert_finished!(r, "should be finished");
}
#[test]
#[should_panic]
fn panic_err_no_msg() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
assert_finished!(r);
}
#[test]
#[should_panic]
fn panic_err_with_msg() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
assert_finished!(r, "should be finished");
}
}
#[macro_export]
macro_rules! assert_done_and_eq {
($e:expr, $a:expr $(,)?) => {
assert_done_and_eq!($e, $a, "parser did not complete");
};
($e:expr, $a:expr, $($arg:tt)+) => ({
if let ::std::result::Result::Ok((_, o)) = $e {
assert_eq!(o, $a);
} else {
assert!(false, $($arg)+);
}
});
}
#[cfg(test)]
mod assert_done_and_eq_tests {
use super::prelude::*;
#[test]
fn no_msg() {
let r: nom::IResult<&str, &str> = Ok((" ", "foo"));
assert_done_and_eq!(r, "foo");
}
#[test]
fn with_msg() {
let r: nom::IResult<&str, &str> = Ok((" ", "foo"));
assert_done_and_eq!(r, "foo", "should be done");
}
#[test]
#[should_panic]
fn panic_no_msg() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
assert_done_and_eq!(r, "foo");
}
#[test]
#[should_panic]
fn panic_with_msg() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
assert_done_and_eq!(r, "foo", "should be done");
}
}
#[macro_export]
macro_rules! assert_finished_and_eq {
($r:expr, $o:expr $(,)?) => {
assert_finished_and_eq!($r, $o, "parser did not complete");
};
($r:expr, $o:expr, $($arg:tt)+) => ({
if let ::std::result::Result::Ok((i, o)) = $r {
assert!(i.is_empty());
assert_eq!(o, $o);
} else {
assert!(false, $($arg)+);
}
})
}
#[cfg(test)]
mod assert_finished_and_eq_tests {
use super::prelude::*;
#[test]
fn no_msg() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_finished_and_eq!(r, "foo");
}
#[test]
fn with_msg() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_finished_and_eq!(r, "foo", "should be finished");
}
#[test]
#[should_panic]
fn panic_ok_no_msg() {
let r: nom::IResult<&str, &str> = Ok((" ", "foo"));
assert_finished_and_eq!(r, "foo");
}
#[test]
#[should_panic]
fn panic_ok_with_msg() {
let r: nom::IResult<&str, &str> = Ok((" ", "foo"));
assert_finished_and_eq!(r, "foo", "should be finished");
}
#[test]
#[should_panic]
fn panic_err_no_msg() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
assert_finished_and_eq!(r, "foo");
}
#[test]
#[should_panic]
fn panic_err_with_msg() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
assert_finished_and_eq!(r, "foo", "should be finished");
}
}
#[macro_export]
macro_rules! assert_error {
($e:expr $(,)?) => {
assert_error!($e, "parser did not error");
};
($e:expr, $($arg:tt)+) => ({
if let ::std::result::Result::Err(_) = $e {
assert!(true);
} else {
assert!(false, $($arg)+);
}
})
}
#[cfg(test)]
mod assert_error_tests {
use super::prelude::*;
#[test]
fn no_msg() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
assert_error!(r);
}
#[test]
fn with_msg() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
assert_error!(r, "should be an error");
}
#[test]
#[should_panic]
fn panic_no_msg() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_error!(r);
}
#[test]
#[should_panic]
fn panic_with_msg() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_error!(r, "should be an error");
}
}
#[macro_export]
macro_rules! assert_error_and_eq {
($r:expr, $err:expr $(,)?) => {
assert_error_and_eq!($r, $err, "parser did not error");
};
($r:expr, $err:expr, $($arg:tt)+) => ({
if let ::std::result::Result::Err(err) = $r {
assert_eq!(err, $err);
} else {
assert!(false, $($arg)+);
}
})
}
#[cfg(test)]
mod assert_error_and_eq_tests {
use super::prelude::*;
#[test]
fn no_msg() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
assert_error_and_eq!(r, nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
}
#[test]
fn with_msg() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
assert_error_and_eq!(r, nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)), "should be an error");
}
#[test]
#[should_panic]
fn panic_no_msg() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_error_and_eq!(r, nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)));
}
#[test]
#[should_panic]
fn panic_with_msg() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_error_and_eq!(r, nom::Err::Error(nom::error::Error::new("", nom::error::ErrorKind::Count)), "should be an error");
}
}
#[macro_export]
macro_rules! assert_needed {
($e:expr $(,)?) => {
assert_needed!($e, "parser is not incomplete");
};
($e:expr, $($arg:tt)+) => ({
if let ::std::result::Result::Err(::nom::Err::Incomplete(..)) = $e {
assert!(true);
} else {
assert!(false, $($arg)+);
}
})
}
#[cfg(test)]
mod assert_needed_tests {
use super::prelude::*;
#[test]
fn no_msg() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Incomplete(nom::Needed::Unknown));
assert_needed!(r);
}
#[test]
fn with_msg() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Incomplete(nom::Needed::Unknown));
assert_needed!(r, "should be Needed");
}
#[test]
#[should_panic]
fn panic_no_msg() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_needed!(r);
}
#[test]
#[should_panic]
fn panic_with_msg() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_needed!(r, "should be Needed");
}
}
#[macro_export]
macro_rules! assert_needs {
($e:expr, ? $(,)? ) => {
if let ::std::result::Result::Err(::nom::Err::Incomplete(e)) = $e {
if let ::nom::Needed::Unknown = e {
assert!(true);
} else {
assert!(false, "parser is incomplete, but Needed is known");
}
} else {
assert!(false, "parser is not incomplete");
}
};
($e:expr, ?, $($arg:tt)+) => {
if let ::std::result::Result::Err(::nom::Err::Incomplete(e)) = $e {
if let ::nom::Needed::Unknown = e {
assert!(true);
} else {
assert!(false, $($arg)+);
}
} else {
assert!(false, $($arg)+);
}
};
($e:expr, $i:expr $(,)?) => {
if let ::std::result::Result::Err(::nom::Err::Incomplete(e)) = $e {
if let ::nom::Needed::Size(i) = e {
assert_eq!($i, i.into());
} else {
assert!(false, "parser is incomplete, but Needed is unknown");
}
} else {
assert!(false, "parser is not incomplete");
}
};
($e:expr, $i:expr, $($arg:tt)+) => ({
if let ::std::result::Result::Err(::nom::Err::Incomplete(e)) = $e {
if let ::nom::Needed::Size(i) = e {
assert_eq!($i, i.into());
} else {
assert!(false, $($arg)+);
}
} else {
assert!(false, $($arg)+);
}
});
}
#[cfg(test)]
mod assert_needs_tests {
use super::prelude::*;
use std::num::NonZeroUsize;
#[test]
fn no_msg_size() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Incomplete(nom::Needed::Size(NonZeroUsize::new(2).unwrap())));
assert_needs!(r, 2usize);
}
#[test]
fn no_msg_unknown() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Incomplete(nom::Needed::Unknown));
assert_needs!(r, ?);
}
#[test]
fn with_msg_size() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Incomplete(nom::Needed::Size(NonZeroUsize::new(2).unwrap())));
assert_needs!(r, 2usize, "should be Needed(2)");
}
#[test]
fn with_msg_unknown() {
let r: nom::IResult<&str, &str> = Err(nom::Err::Incomplete(nom::Needed::Unknown));
assert_needs!(r, ?, "should be Needed(Unknown)");
}
#[test]
#[should_panic]
fn panic_no_msg_size() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_needs!(r, 2usize);
}
#[test]
#[should_panic]
fn panic_no_msg_unknown() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_needs!(r, ?);
}
#[test]
#[should_panic]
fn panic_with_msg_unknown() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_needs!(r, ?, "Should be Needed(Unknown)");
}
#[test]
#[should_panic]
fn panic_with_msg_size() {
let r: nom::IResult<&str, &str> = Ok(("", "foo"));
assert_needs!(r, 2usize, "Should be Needed(2)");
}
}