nobug 0.7.0

#[allow(unused_imports)]
use crate::*;

/// Asserts that a condition is true.
///
/// This defines the underlying machinery for the other assertion macros below.
///
/// # Arguments
///
/// * `cond` - The condition to check.
/// * `fmt`  - can be either a literal string or a sequence of tokens within parenthesis
///            that are concat!()'ed to form a format string.
/// * `args` - Optional comma separated Arguments for the message.
///
/// # Semantics
///
/// * When the assertion fails it will abort the program and panic in test mode.
/// * The condition is always checked and when it fails it ends in a call that yields 'Never'.
///   Thus the compiler can make assumptions about the code after the assertion.
///
/// # Example
///
/// ```
/// # use nobug::ASSERT;
/// ASSERT!(true, "this must always be true");
/// ```
#[macro_export]
macro_rules! ASSERT {
    ($cond:expr, ($($fmt:tt)*) $(,$($args:expr),*)?) => {{
        $crate::TRACE_NOBUG!(($($fmt)*) $(,$($args),*)?);
        #[cfg(all(debug_assertions,test))] $crate::set_testing();
        if !$cond {
            $crate::DIE!(($($fmt)*) $(,$($args),*)?)
        }
    }};
    ($cond:expr, $fmt:literal $(,$($args:expr),*)?) => {{
        $crate::TRACE_NOBUG!($fmt $(,$($args),*)?);
        #[cfg(all(debug_assertions,test))] $crate::set_testing();
        if !$cond {
            $crate::DIE!($fmt $(,$($args),*)?)
        }
    }};
    ($cond:expr) => {{
        $crate::TRACE_NOBUG!("ASSERTION FAILED: {}", stringify!($cond));
        #[cfg(all(debug_assertions,test))] $crate::set_testing();
        if !$cond {
            $crate::DIE!("ASSERTION FAILED: {}", stringify!($cond))
        }
    }};
}

/// Asserts that a condition is true only in debug mode.
#[macro_export]
macro_rules! ASSERT_DBG {
    ($($tt:tt)*) => {
        #[cfg(debug_assertions)]
        $crate::ASSERT!($($tt)*);
    }
}

#[test]
fn test_assert() {
    ASSERT!(true);
}

#[test]
#[cfg(debug_assertions)]
#[should_panic = "ASSERTION FAILED: false"]
fn test_assert1() {
    ASSERT!(false);
}

#[test]
#[cfg(debug_assertions)]
#[should_panic = "foo"]
fn test_assert2() {
    ASSERT!(false, "foo");
}

#[test]
#[cfg(debug_assertions)]
#[should_panic = "foo 42"]
fn test_assert3() {
    ASSERT!(false, "foo {}", 42);
}

/// Assert some condition only once. Returns `true` on success.
///
/// This is a special form which is mainly useful within test blocks in the `FIXME!`/`FIXED!`
/// macros when the bug can be checked without local context only once.  It can be used to to
/// do expensive tests on immutable data as well. By returning `true` on success this can be
/// nested in other assertions and annotations.
///
/// ```rust
/// # use nobug::{FIXED, ASSERT_ONCE};
/// FIXED!({ASSERT_ONCE!(true)} "this was an error");
/// ```
#[macro_export]
macro_rules! ASSERT_ONCE {
($($code:tt)*) => {
        {
            $crate::ONCE!($crate::ASSERT!($($code)*));
            true
        }
    };
}

#[test]
#[cfg(debug_assertions)]
#[should_panic = "ASSERTION FAILED"]
fn test_assert_once() {
    ASSERT_ONCE!(false, "ASSERTION FAILED");
}

#[test]
#[cfg(debug_assertions)]
fn test_fixme_assert_once() {
    for i in 0..10 {
        FIXME!({ASSERT_ONCE!(i == 0)} "not to be used this way in real code");
    }
}

/// Checks preconditions.
///
/// # Arguments
///
/// * `cond` - The condition(s) to check.
/// * `fmt`  - can be either a literal string or a sequence of tokens within parenthesis
///            that are concat!()'ed to form a format string.
/// * `args` - Optional comma separated Arguments for the message.
///
/// the `cond` part has specializations for `const { }` expressions and the common comparisons
/// when both sides are in parenthesis eg. `(x) == (y)`. This requires that the arguments
/// implement `Debug` and giving more detailed error messages.
///
/// Multiple checks can be grouped as list of conditions with messages in brackets separated by semicolons.
/// The specializations from above are then not available, consequently they don't need to implement `Debug`.
///
/// # Example
///
/// ```
/// # use nobug::REQUIRE;
/// fn foo(x: u32, y: u32) {
///     REQUIRE!((x) > (0), "x must be positive");
///     // or
///     REQUIRE!([
///       x > 0, "x must be positive";
///       x < y, "{} must be less than {}", x, y;
///     ]);
///     REQUIRE!(const { true }, "its not true");
///     // ...
/// }
/// ```
#[macro_export]
macro_rules! REQUIRE {
    ([$($cond:expr $(, $fmt:literal $(,$args:expr)*)?;)*]) => {
        $($crate::REQUIRE!($cond $(,$fmt $(,$args)*)?);)*
    };
    (const { $cond:expr } $(, $fmt:literal $(, $($args:expr),*)?)?) => {
            $crate::CFG_IF! {
                if #[cfg(feature = "const_expr")] {
                    $crate::ASSERT!(
                        (const { $cond }),
                        ("PRECONDITION FAILED: {}" $(, ": ", $fmt)?),
                        stringify!($cond) $($(,$($args),*)?)?
                    );
                } else {
                    const COND: bool = $cond;
                    $crate::ASSERT!(
                        COND,
                        ("PRECONDITION FAILED: {}" $(, ": ", $fmt)?),
                        stringify!($cond) $($(,$($args),*)?)?
                    );
                }
            }
    };
    (($lhs:expr) == ($rhs:expr) $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($lhs == $rhs,
            ("PRECONDITION FAILED: {} == {}" $(, ": ", $fmt)? , "\n  lhs: {:?}\n  rhs: {:?}"),
            stringify!($lhs), stringify!($rhs)
            $($(, $($args),*)?)?, $lhs, $rhs)
    };
    (($lhs:expr) != ($rhs:expr) $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($lhs != $rhs,
            ("PRECONDITION FAILED: {} != {}" $(, ": ", $fmt)? , "\n  lhs: {:?}\n  rhs: {:?}"),
            stringify!($lhs), stringify!($rhs)
            $($(, $($args),*)?)?, $lhs, $rhs)
    };
    (($lhs:expr) < ($rhs:expr) $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($lhs < $rhs,
            ("PRECONDITION FAILED: {} < {}" $(, ": ", $fmt)? , "\n  lhs: {:?}\n  rhs: {:?}"),
            stringify!($lhs), stringify!($rhs)
            $($(, $($args),*)?)?, $lhs, $rhs)
    };
    (($lhs:expr) <= ($rhs:expr) $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($lhs <= $rhs,
            ("PRECONDITION FAILED: {} <= {}" $(, ": ", $fmt)? , "\n  lhs: {:?}\n  rhs: {:?}"),
            stringify!($lhs), stringify!($rhs)
            $($(, $($args),*)?)?, $lhs, $rhs)
    };
    (($lhs:expr) > ($rhs:expr) $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($lhs > $rhs,
            ("PRECONDITION FAILED: {} > {}" $(, ": ", $fmt)? , "\n  lhs: {:?}\n  rhs: {:?}"),
            stringify!($lhs), stringify!($rhs)
            $($(, $($args),*)?)?, $lhs, $rhs)
    };
    (($lhs:expr) >= ($rhs:expr) $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($lhs >= $rhs,
            ("PRECONDITION FAILED: {} >= {}" $(, ": ", $fmt)? , "\n  lhs: {:?}\n  rhs: {:?}"),
            stringify!($lhs), stringify!($rhs)
            $($(, $($args),*)?)?, $lhs, $rhs)
    };
    ($cond:expr $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($cond, ("PRECONDITION FAILED: {}" $(, ": ", $fmt)?), stringify!($cond)
            $($(, $($args),*)?)?)
    };
}

/// Checks preconditions only in debug mode.
#[macro_export]
macro_rules! REQUIRE_DBG {
    ($($tt:tt)*) => {
        #[cfg(debug_assertions)]
        $crate::REQUIRE!($($tt)*);
    }
}

#[test]
fn test_require() {
    let yes = true;
    REQUIRE!(true);
    REQUIRE!(const { true });
    REQUIRE!((yes) == (true));
}

#[test]
#[cfg(debug_assertions)]
#[should_panic = "PRECONDITION FAILED: false"]
fn test_require1() {
    REQUIRE!(false);
}

#[test]
fn test_braced() {
    REQUIRE!({ true }, "foo {}", 42);
}

#[test]
#[cfg(debug_assertions)]
#[should_panic = "PRECONDITION FAILED: false: foo"]
fn test_require2() {
    REQUIRE!(false, "foo");
}

#[test]
#[cfg(debug_assertions)]
#[should_panic = "PRECONDITION FAILED: false: foo 42"]
fn test_require3() {
    REQUIRE!(false, "foo {}", 42);
}

#[test]
#[cfg(debug_assertions)]
#[should_panic = "PRECONDITION FAILED: false: baz 43"]
fn test_require4() {
    REQUIRE!([
        true;
        true, "bar";
        false, "baz {}", 43;
    ]);
}

#[cfg(feature = "const_expr")]
#[cfg(debug_assertions)]
#[allow(clippy::items_after_test_module)]
#[cfg(test)]
mod test {
    struct ConstGeneric<const N: i32>;

    impl<const N: i32> ConstGeneric<N> {
        fn new() -> Self {
            REQUIRE!(const { N > 0 }, "N out of range");
            Self
        }
    }

    #[test]
    #[should_panic(expected = "N out of range")]
    fn test_const_generic() {
        let _a = ConstGeneric::<1>::new();
        let _b = ConstGeneric::<0>::new();
    }
}

/// Checks postconditions.
///
/// `ENSURE!` augments a expression/code-block with a list of conditions that must be true and
/// returns the result of the executed code.
///
/// # Example
///
/// With multiple conditions:
/// ```
/// # use nobug::ENSURE;
/// fn foo(x: u32, y: u32) -> u32 {
///     ENSURE!{
///         [
///             result < 100, "result must be less than 100";
///             result >= 50, "result must be greater or equal than 50";
///         ]
///         result = {
///             // code which result shall be checked ...
///             x + y
///         }
///     }
/// }
/// ```
///
/// When only one condition is checked then the brackets can be omitted:
/// ```
/// # use nobug::{ENSURE, CHECK};
/// fn foo(x: u32, y: u32) -> u32 {
///     ENSURE!{
///         result < 100, "result must be less than 100";
///         result = {
///             // code which result shall be checked ...
///             // ENSURE! catches returns too
///             if x > 100 {return 0;}
///             x + y
///         }
///     }
/// }
///
/// CHECK!((foo(20,30)) == (50));
/// ```
#[macro_export]
macro_rules! ENSURE {
    (
        [$($cond:expr $(, $fmt:literal $(, $($args:expr),*)? )?);* $(;)?]
        $result:ident = $code:expr) => {{
            let mut early_return = true;
            let $result = (|| {
                let result = $code;
                early_return = false;
                result
            })();
            $($crate::ASSERT!($cond, ("POSTCONDITON FAILED: {}" $(, ": ", $fmt)?), stringify!($cond) $($(, $($args),*)?)?);)*
            if early_return {
                return $result;
            }
            $result
        }};
    (
        $cond:expr $(, $fmt:literal $(, $($args:expr),*)? )?;
        $result:ident = $code:expr) => {{
            let mut early_return = true;
            let $result = (|| {
                let result = $code;
                early_return = false;
                result
            })();
            $crate::ASSERT!($cond, ("POSTCONDITON FAILED: {}" $(, ": ", $fmt)?), stringify!($cond) $($(, $($args),*)?)?);
            if early_return {
                return $result;
            }
            $result
        }};
}

/// Checks postconditions only in debug mode.
#[macro_export]
macro_rules! ENSURE_DBG {
    (
        [$($cond:expr $(, $fmt:literal $(, $($args:expr),*)? )?);* $(;)?]
        $result:ident = $code:expr) => {
            #[cfg(debug_assertions)]
            $crate::ENSURE!(
                [$($cond $(, $fmt $(, $($args),*)?)?);*]
                $result = $code
            );
            #[cfg(not(debug_assertions))]
            {$code}
        };
    (
        $cond:expr $(, $fmt:literal $(, $($args:expr),*)? )?;
        $result:ident = $code:expr) => {
            #[cfg(debug_assertions)]
            $crate::ENSURE!(
                $cond $(, $fmt $(, $($args),*)?)?;
                $result = $code
            );
            #[cfg(not(debug_assertions))]
            {$code}
        };
}

/// Asserts that a condition is true.
///
/// This takes the same arguments as [`REQUIRE!()`] but is intended to be used in test suites.
/// When the condition check succeeds it returns `true` (which might be ignored).
/// There is no `_DBG` variant because assertions in tests should be checked unconditionally.
///
/// # Example
///
/// ```
/// # use nobug::CHECK;
/// CHECK!((1) == (1));
/// CHECK!((1) != (2));
/// CHECK!((1) < (2));
/// CHECK!((1) <= (1));
/// CHECK!((2) > (1));
/// CHECK!((2) >= (2));
/// CHECK!({ true });
/// # if false {
/// CHECK!([
///     true;
///     true, "bar";
///     false, "baz {}", 43;
/// ]);
/// # }
/// ```
#[macro_export]
macro_rules! CHECK {
    ([$($cond:expr $(, $fmt:literal $(,$args:expr)*)?;)*]) => {
        $($crate::CHECK!($cond $(,$fmt $(,$args)*)?);)*
        true
    };
    (const { $cond:expr } $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::CFG_IF! {
            if #[cfg(feature = "const_expr")] {
                $crate::ASSERT!(
                    (const { $cond }),
                    ("TEST FAILED: {}" $(, ": ", $fmt)?),
                    stringify!($cond) $($(,$($args),*)?)?
                );
                true
            } else {
                const COND: bool = $cond;
                $crate::ASSERT!(
                    COND,
                    ("TEST FAILED: {}" $(, ": ", $fmt)?),
                    stringify!($cond) $($(,$($args),*)?)?
                );
                true
            }
        }
    };
    (($lhs:expr) == ($rhs:expr) $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($lhs == $rhs,
            ("TEST FAILED: {} == {}" $(, ": ", $fmt)? , "\n  lhs: {:?}\n  rhs: {:?}"),
            stringify!($lhs), stringify!($rhs)
            $($(, $($args),*)?)?, $lhs, $rhs);
        true
    };
    (($lhs:expr) != ($rhs:expr) $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($lhs != $rhs,
            ("TEST FAILED: {} != {}" $(, ": ", $fmt)? , "\n  lhs: {:?}\n  rhs: {:?}"),
            stringify!($lhs), stringify!($rhs)
            $($(, $($args),*)?)?, $lhs, $rhs);
        true
    };
    (($lhs:expr) < ($rhs:expr) $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($lhs < $rhs,
            ("TEST FAILED: {} < {}" $(, ": ", $fmt)? , "\n  lhs: {:?}\n  rhs: {:?}"),
            stringify!($lhs), stringify!($rhs)
            $($(, $($args),*)?)?, $lhs, $rhs);
        true
    };
    (($lhs:expr) <= ($rhs:expr) $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($lhs <= $rhs,
            ("TEST FAILED: {} <= {}" $(, ": ", $fmt)? , "\n  lhs: {:?}\n  rhs: {:?}"),
            stringify!($lhs), stringify!($rhs)
            $($(, $($args),*)?)?, $lhs, $rhs);
        true
    };
    (($lhs:expr) > ($rhs:expr) $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($lhs > $rhs,
            ("TEST FAILED: {} > {}" $(, ": ", $fmt)? , "\n  lhs: {:?}\n  rhs: {:?}"),
            stringify!($lhs), stringify!($rhs)
            $($(, $($args),*)?)?, $lhs, $rhs);
        true
    };
    (($lhs:expr) >= ($rhs:expr) $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($lhs >= $rhs,
            ("TEST FAILED: {} >= {}" $(, ": ", $fmt)? , "\n  lhs: {:?}\n  rhs: {:?}"),
            stringify!($lhs), stringify!($rhs)
            $($(, $($args),*)?)?, $lhs, $rhs);
        true
    };
    ($cond:expr $(, $fmt:literal $(, $($args:expr),*)?)?) => {
        $crate::ASSERT!($cond, ("TEST FAILED: {}" $(, ": ", $fmt)?), stringify!($cond)
            $($(, $($args),*)?)?);
        true
    };
}

#[test]
fn test_check() {
    CHECK!(const { true });
}