//! Macros for testing `nom` parsers
//!
//! Often when I'm testing `nom` parsers, I end up defining a lot of little
//! macros like this, so I thought I would bundle them all up into a crate
//! so I didn't have to define them over and over
//!
#![deny(missing_docs)] // <- this doesn't appear to check macros?

/// Instead of importing the helper macros individually, this can be
/// star-imported to get all of them
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]
/// This macro checks to make sure that the IResult it is
/// passed is `Done`
///
/// # Examples
///
/// ```
/// use nom_test_helpers::assert_done;
/// use nom::{named, tag};
///
/// # fn main() {
/// named!(abcd<&str, &str>, tag!("abcd"));
/// let r = abcd("abcd");
/// assert_done!(r);
/// # }
/// ```
macro_rules! assert_done {
    ($e:expr) => {
        {
            if let ::std::result::Result::Ok((_, _)) = $e {
                assert!(true);
            } else {
                assert!(false, "parser did not complete");
            }
        }
    }
}

#[macro_export]
/// Internal only, really, and not even necessary :P
macro_rules! assert_empty {
    ($v:expr) => {
        assert!($v.is_empty())
    }
}

#[macro_export]
/// This does the same thing as `assert_done!`, except that
/// this also asserts that the input slice is empty
///
/// # Examples
///
/// ```
/// use nom_test_helpers::assert_finished;
///
/// # fn main() {
/// let r: nom::IResult<&str, &str> = Ok(("", "efgh"));
/// assert_finished!(r);
/// # }
/// ```
macro_rules! assert_finished {
    ($e:expr) => {
        {
            if let ::std::result::Result::Ok((i, _)) = $e {
                $crate::assert_empty!(i);
            } else {
                assert!(false, "parser did not complete");
            }
        }
    }
}

#[macro_export]
/// This checks that the `IResult` is `Done`, and lets you
/// check that the value returned as the `O` type of the 
/// `IResult` is equal to the second parameter
///
/// # Examples
///
/// ```
/// use nom_test_helpers::assert_done_and_eq;
///
/// # fn main() {
/// let r: nom::IResult<&[u8], &[u8]> = Ok((b"abcd", b"efgh"));
/// assert_done_and_eq!(r, b"efgh");
/// # }
/// ```
macro_rules! assert_done_and_eq {
    ($e:expr, $a:expr) => {
        {
            if let ::std::result::Result::Ok((_, o)) = $e {
                assert_eq!(o, $a);
            } else {
                assert!(false, "parser did not complete");
            }
        }
    }
}

#[macro_export]
/// Same as `assert_done_and_eq!`, but asserts that
/// the input slice is empty
///
/// # Examples
///
/// ```
/// use nom_test_helpers::assert_finished_and_eq;
///
/// # fn main() {
/// let r: nom::IResult<&str, &str> = Ok(("", "sup"));
/// assert_finished_and_eq!(r, "sup");
/// # }
/// ```
macro_rules! assert_finished_and_eq {
    ($r:expr, $o:expr) => {
        {
            if let ::std::result::Result::Ok((i, o)) = $r {
                $crate::assert_empty!(i);
                assert_eq!(o, $o);
            } else {
                assert!(false, "parser did not complete");
            }
        }
    }
}

#[macro_export]
/// This asserts that the `IResult` is an `Err`
/// 
/// # Examples
/// 
/// ```
/// use nom_test_helpers::assert_error;
///
/// # fn main() {
/// let r: nom::IResult<&[u8], &[u8]> = Err(nom::Err::Error(nom::error::Error::new(&b""[..], nom::error::ErrorKind::Count)));
/// assert_error!(r);
/// # }
macro_rules! assert_error {
    ($e:expr) => {
        {
            if let ::std::result::Result::Err(_) = $e {
                assert!(true);
            } else {
                assert!(false, "parser did not error");
            }
        }
    }
}

#[macro_export]
/// This asserts that the `IResult` is an `Err` and that the error
/// is what is expected
///
/// # Examples
///
/// ```
/// use nom_test_helpers::assert_error_and_eq;
///
/// # fn main() {
/// let r: nom::IResult<&[u8], &[u8]> = Err(nom::Err::Error(nom::error::Error::new(&b""[..], nom::error::ErrorKind::Count)));
/// assert_error_and_eq!(r, nom::Err::Error(nom::error::Error::new(&b""[..], nom::error::ErrorKind::Count)));
/// # }
macro_rules! assert_error_and_eq {
    ($r:expr, $err:expr) => {
        {
            if let ::std::result::Result::Err(err) = $r {
                assert_eq!(err, $err);
            } else {
                assert!(false, "parser did not error");
            }
        }
    }
}

#[macro_export]
/// This asserts that the `IResult` is an `Incomplete`
///
/// # Examples
///
/// ```
/// use std::num::NonZeroUsize;
/// use nom_test_helpers::assert_needed;
/// use nom::Needed;
///
/// # fn main() {
/// let r: nom::IResult<&[u8], &[u8]> = Err(nom::Err::Incomplete(Needed::Size(NonZeroUsize::new(1).unwrap())));
/// assert_needed!(r);
/// # }
/// ```
macro_rules! assert_needed {
    ($e:expr) => {
        {
            if let ::std::result::Result::Err(::nom::Err::Incomplete(..)) = $e {
                assert!(true);
            } else {
                assert!(false, "parser is not incomplete");
            }
        }
    }
}

#[macro_export]
/// This lets the user specify how much input the parser should need
///
/// # Examples
///
/// ```
/// use nom_test_helpers::assert_needs;
/// use nom::Needed;
///
/// # fn main() {
/// let r: nom::IResult<&[u8], &[u8]> = Err(nom::Err::Incomplete(Needed::Unknown));
/// assert_needs!(r, ?);
/// # }
/// ```
///
/// ```
/// use std::num::NonZeroUsize;
/// use nom_test_helpers::assert_needs;
/// use nom::Needed;
///
/// # fn main() {
/// let r: nom::IResult<&[u8], &[u8]> = Err(nom::Err::Incomplete(Needed::Size(NonZeroUsize::new(2).unwrap())));
/// assert_needs!(r, 2usize);
/// # }
/// ```
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, $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");
            }
        }
    }
}