utmt 0.10.0

//! This crate offers a list of macros for `unittest` support. The aim of these macros is to extends existing rust `unittest` macros
//! by adding some new assertions and facilities.

/// Multi-assertion macro. This macro take at least 1 argument as an expression. Several expressions can be added.
///
/// # Argument
/// * `$cond` - Assertion condition. If several assertions, must be separated by a comma.
///
/// # Note
/// While an assertion condition is not valid, this macro doesn't stop to test the nex assertion. After the last assertion was done,
/// this macro show the list of assertion failed and the number of failures.
///
/// # Examples
///
/// ```rust
/// use utmt::assert_all;
///
/// assert_all!(true, !false, 1+1 == 2);
/// ```
///
/// ```should_panic
/// use utmt::assert_all;
/// assert_all!(compute(), 1+1==2, 1*2==6);
///
/// fn compute() -> bool {
///  false
/// }
/// ```
///
/// ```text
/// Example of output errors:
///
/// Assertion failed : compute()
/// Assertion failed : 1*2==6
///
///
/// thread 'test::test_assert_8' (124729) panicked at src/main.rs:46:9:
/// 2 assertion(s) failed.
/// ```
#[macro_export]
macro_rules! assert_all {
    (  $($cond:expr),+)  => {
        {
            use std::collections::HashMap;

            let mut errors: HashMap<usize, &str> = HashMap::new();

            $(
                let _ = match $cond {
                    true => {},
                    false => {
                        errors.insert(errors.len(), stringify!($cond));
                    }
                };
            )*

            if !errors.is_empty() {
                errors.iter().for_each(|(_, msg)| {
                    eprintln!("Assertion failed: {}", msg);
                });
                panic!("{} assertion(s) failed.", errors.len());
            }
        }
    };
}

/// Multi-assertion macro for method that return a `Result` value. Seval expressions of this type must be specified.
/// 
/// # Arguments
/// * `$cond` - Conditional expression that return a `Result` type.
/// 
/// # Note
/// While an assertion condition is not valid, this macro doesn't stop to test the nex assertion. After the last assertion was done,
/// this macro show the list of assertion failed and the number of failures.
///
/// # Examples
/// ```rust
/// use utmt::assert_all_match_result;
/// 
/// assert_all_match_result(result1(), result2());
/// 
/// fn result1() -> Result<(), &'static str> {
///     Ok(())
/// }
/// 
/// fn result2 -> Result<(), &'static str> {
///     Ok(())
/// }
/// ```
/// ```should_panic
/// use utmt::assert_all_match_result;
/// 
/// assert_all_match_result(result1, result2, result3);
/// 
/// fn result1() -> Result<(), &'static str> {
///     Ok(())
/// }
/// 
/// fn result2 -> Result<(), &'static str> {
///     Err("an error for this result")
/// }
/// 
/// fn result3 -> Result<(), &'static str> {
///     Ok(())
/// }
#[macro_export]
macro_rules! assert_all_match_result {
    ( $($cond:expr),+) => {
        {
            use std::collections::HashMap;
            
            let mut errors: HashMap<usize, (&str, &str)> = HashMap::new();
            
            $(
                let _ = match $cond {
                    Ok(_) => {},
                    Err(e) => {
                        errors.insert(errors.len(), (stringify!($cond), e.to_string().leak()));
                    }
                };
            )*
            
            if !errors.is_empty() {
                errors.iter().for_each(|(_, (msg, error))| {
                    eprintln!("Assertion failed: {}. Error: {}", msg, error);
                });
                panic!("{} assertion(s) failed.", errors.len());
            }
        }
    };
}

/// Assert the `Option<T>` value. If the value is `Some(...)` return `Ok(())`, otherwise a `Err` value.
///
/// # Arguments
///
/// * `$current`- Current value for matching option,
/// * `$msg`- (Optional) Specific message error.
///
/// # Returns
///
/// A `Result<(), &str>` as the test result.
///
/// # Examples
///
/// ```rust
/// use utmt::assert_match_option;
///
/// let value = Some("Hello");
/// let result = assert_match_option!(value);
///
/// assert_eq!(result, Ok(()));
/// ```
///
/// ```rust
/// use utmt::assert_match_option;
///
/// let result = assert_match_option!(None::<i16>, "None found");
///
/// assert_eq!(result, Err("None found"));
/// ```
#[macro_export]
macro_rules! assert_match_option {
    ($current:expr) => {
        assert_match_option!($current, "Assertion failed")
    };

    ($current:expr, $msg:literal) => {
        match $current {
            Some(_) => Ok(()),
            None => Err($msg)
        }
    };
}

/// Assert the `Option<T>` for a result that does not match the given argument. If the value is `None` return `Ok(())` result.
/// If the value is `Some(...)` return `None` result.
///
/// # Arguments
///
/// * `$current` - Current value that not matching option,
/// * `$msg` - Optional specific message error.
///
/// # Returns
///
/// A `Result<(), &str>` as the test result.
///
/// # Examples
///
/// ```rust
/// use utmt::assert_not_match_option;
///
/// let result = assert_not_match_option!(None::<String>);
///
/// assert_eq!(result, Ok(()))
/// ```
///
/// ```rust
/// use utmt::assert_not_match_option;
///
/// let result = assert_not_match_option!(Some('v'), "v error");
///
/// assert_eq!(result, Err("v error"));
/// ```
#[macro_export]
macro_rules! assert_not_match_option {
    ($current:expr) => {
        assert_not_match_option!($current, "Assertion failed")
    };

    ($current:expr, $msg:literal) => {
        match $current {
            Some(_) => Err($msg),
            None => Ok(())
        }
    };
}

/// Assert for a `Result<T, E>` value. If the value is a type of `Ok(_)` the result is `Ok(())`. If the value is a type of `Err(_)` the
/// result is a type of `Err(&str)`.
///
/// # Arguments
/// * `$current` - The result to test to.
/// * `$msg` - Optional specific message error.
///
/// # Returns
/// A type of `Result<(), &str>` for this assertion.
///
/// # Examples
/// ```rust
/// use utmt::assert_match_result;
///
/// let result = assert_match_result!(Ok::<i32, &str>(6));
/// assert_eq!(result, Ok(()));
/// ```
///
/// ```rust
/// use utmt::assert_match_result;
///
///let result = assert_match_result!(Err::<(), &str>("Foo"), "It's failed");
/// assert_eq!(result, Err("It's failed"));
/// ```
#[macro_export]
macro_rules! assert_match_result {
    ($current:expr) => {
        assert_match_result!($current, "Assertion failed")
    };

    ($current:expr, $msg:literal) => {
        match $current {
            Ok(_) => Ok(()),
            Err(_) => Err($msg)
        }
    };
}

/// Assert for a `Result<T, E>` value. If the value is a type of `Ok(_)` the result is `Ok(())`. If the value is a type of `Err(_)` the
/// result is the natural error from the method calling.
///
/// # Arguments
/// * `$current` - The result to test to.
/// 
/// # Return
/// A type of `Result<(), E>` for this assertion. `E` is corresponding to the natural error type of the function underlying test.
/// 
/// # Note
/// The difference with [`assert_match_result`] is about the `E` value of the `Result<T,E>`. With the [`assert_match_result`], the error
/// is always a type of ``&`static str ``. Here this type is the type of the caller.
/// 
/// # Examples
/// ```rust
/// use utmt::assert_match_natural_result;
/// 
/// let result = assert_match_natural_result!(Ok::<i32, &str>(6));
/// assert_eq!(result, Ok(()));
/// ```
/// ```rust
/// use utmt::assert_match_natural_result;
/// 
/// let result = assert_match_natural_result!(Err::<(), &str>("Foo"));
/// assert_eq!(result, Err("Foo"));
/// ```
#[macro_export]
macro_rules! assert_match_natural_result {
    ($current:expr) => {
        match $current {
            Ok(_) => Ok(()),
            Err(e) => Err(e)
        }
    };
}

/// Assert for a  not valid`Result<T, E>` value. If the value is a type of `Err(_)` the result is `Ok(())`. If the value is a type of `Ok(_)` the
/// result is a type of `Err(&str)`.
///
/// # Arguments
/// * `$current` - The result to test to.
/// * `$msg` - Optional specific message error.
///
/// # Returns
/// A type of `Result<(), &str>` for this assertion.
///
/// # Examples
/// ```rust
/// use utmt::assert_not_match_result;
///
/// let result = assert_not_match_result!(Err::<(), i32>(6));
/// assert_eq!(result, Ok(()));
/// ```
///
/// ```rust
/// use utmt::assert_not_match_result;
///
///let result = assert_not_match_result!(Err::<(), i32>(5), "It's failed");
/// assert_eq!(result, Ok(()));
/// ```
#[macro_export]
macro_rules! assert_not_match_result {
    ($current:expr) => {
        assert_not_match_result!($current, "Assertion failed")
    };

    ($current:expr, $msg:literal) => {
        match $current {
            Ok(_) => Err($msg),
            Err(_) => Ok(())
        }
    };
}

/// Assertion for matching specific values.
///
/// # Arguments
/// * `$current` - Current value.
/// * `$ok_value` - Awaiting valid value for assertion.
/// * `$nok_value` - Value that invalids this assertion.
/// * `$msg` - (Optional) Specific assertion message.
///
/// # Examples
/// ```
/// use utmt::assert_match_values;
/// use utmt::facility_match_values; // Warning: specific to doctest
///
/// assert_match_values!(true, true, false);
/// ```
///
/// ```should_panic
/// use utmt::assert_match_values;
/// use utmt::facility_match_values; // Warning: specific to doctest
///
/// assert_match_values!(false, true, false);
/// ```
#[macro_export]
macro_rules! assert_match_values {
    ($current:expr, $ok_value:pat, $nok_value:pat) => {
        assert_match_values!($current, $ok_value, $nok_value, "Assertion failed")
    };

    ($current:expr, $ok_value:pat, $nok_value:pat, $msg:literal) => {
        assert!(
            facility_match_values!($current, $ok_value, $nok_value).is_ok(),
            $msg
        );
    };
}

/// Assert on invalid values.
///
/// # Arguments
///
/// * `$current` - Current value.
/// * `$nok_value` - Value that set the assertion valid.
/// * `$ok_value` - Value to set the assertion in error.
/// * `$msg` - (Optional) Assertion error message.
///
/// # Examples
/// ```
/// use utmt::assert_not_match_values;
/// use utmt::facility_match_values; // Warning: specific to doctest
///
/// assert_not_match_values!(true, false, true);
/// ```
///
/// ```should_panic
/// use utmt::assert_not_match_values;
/// use utmt::facility_match_values; // Warning: specific to doctest
///
/// assert_not_match_values!(true, true, false);
/// ```
#[macro_export]
macro_rules! assert_not_match_values {
    ($current:expr, $nok_value:pat, $ok_value:pat) => {
        assert_not_match_values!($current, $nok_value, $ok_value, "Assertion failed")
    };

    ($current:expr, $nok_value:pat, $ok_value:pat, $msg:literal) => {
        assert!(
            facility_match_values!($current, $nok_value, $ok_value).is_err(),
            $msg
        );
    };
}

/// Assertion for a non value. If this option is none, the assertion is valid.
/// 
/// # Arguments
/// 
/// * `$value` - The value that would be a `None` value for a valid assertion.
/// * `$msg` - The optional assertion message.
/// 
/// # Examples
/// ```rust
/// use utmt::assert_none;
/// 
/// assert_none!(none_method());
/// 
/// fn none_method() -> Option<i32> {
///     None
/// }
/// ```
/// ```should_panic
/// use utmt::assert_none;
/// 
/// assert_none!(Some(4));
/// ```
#[macro_export]
macro_rules! assert_none {
    ($value:expr) => {
        assert_none!($value, "Assert none failure")
    };

    ($value:expr, $msg:literal) => {
        assert_eq!(None, $value, $msg)
    };
}

/// Assertion for an option value. If this option value is not none, the assertion is valid.
///
/// # Arguments
///
/// * `$value` - Value for assertion test
/// * `$msg` - Optional message parameter
///
/// # Examples
/// ```rust
/// use utmt::assert_not_none;
///
/// assert_not_none!(Some(1));
/// ```
///
/// ```should_panic
/// use utmt::assert_not_none;
///
/// assert_not_none!(a_function());
///
/// fn a_function() -> Option<i32> {
///     None
/// }
/// ```
#[macro_export]
macro_rules! assert_not_none {
    ($value:expr) => {
        assert_not_none!($value, "Assertion not none failed")
    };

    ($value:expr, $msg:literal) => {
        assert_ne!(None, $value, $msg)
    };
}

/// Assertion about slices equality.
///
/// # Arguments
/// * `awaiting` - The slice reference.
/// * `result` - The slice to test.
/// * `msg` - (Optional) The message for this assertion if failed.
///
/// # Examples
/// ```
/// // Compare 2 same slices
/// use utmt::assert_slices_eq;
///
/// let slice_ref = [1,2,3,4,5];
/// let slice_result = [1,2,3,4,5];
///
/// assert_slices_eq!(slice_ref, slice_result);
/// ```
///
/// ```should_panic
/// // Compare 2 different slices
/// use utmt::assert_slices_eq;
///
/// let slice_ref = [1,2,3,4,5];
/// let slice_result = [1,2,5,4,3];
///
/// assert_slices_eq!(slice_ref, slice_result, "Slices are not equals");
/// ```
#[macro_export]
macro_rules! assert_slices_eq {
    ($awaiting:expr, $result:expr) => {
        assert_slices_eq!($awaiting, $result, "Assertion failed");
    };

    ($awaiting:expr, $result:expr, $msg:literal) => {{
        assert_eq!($awaiting.len(), $result.len(), $msg);
        let mut cpt = 0;
        while cpt < $awaiting.len() {
            assert_eq!($awaiting[cpt], $result[cpt], $msg);
            cpt += 1;
        }
    }};
}

/// Assertion about slices inequality.
///
/// # Arguments
/// * `awaiting` - The slice reference.
/// * `result` - The slice to test.
/// * `msg` - (Optional) The message for this assertion if failed.
///
/// # Examples
/// ```
/// // Compare 2 different slices
/// use utmt::assert_slices_ne;
///
/// let slice_ref = [1,2,3,4,5];
/// let slice_result = [1,2,3,4,0];
///
/// assert_slices_ne!(slice_ref, slice_result);
/// ```
///
/// ```
/// // Compare 2 different slices size
/// use utmt::assert_slices_ne;
///
/// assert_slices_ne!([1,2,3], [1,2,3,4]);
/// ```
///
/// ```should_panic
/// // Compare 2 same slices
/// use utmt::assert_slices_ne;
///
/// let slice_ref = [1,2,3,4,5];
/// let slice_result = [1,2,3,4,5];
///
/// assert_slices_ne!(slice_ref, slice_result);
/// ```
#[macro_export]
macro_rules! assert_slices_ne {
    ($awaiting:expr, $result:expr) => {
        assert_slices_ne!($awaiting, $result, "Assertion failed");
    };

    ($awaiting:expr, $result:expr, $msg:literal) => {{
        let mut cpt = 0;

        let min = match $awaiting.len() < $result.len() {
            true => $awaiting.len(),
            false => $result.len(),
        };

        while cpt < min && ($awaiting[cpt] == $result[cpt]) {
            cpt += 1;
        }

        assert!(!((cpt == min) & ($awaiting.len() == $result.len())), $msg);
    }};
}

/// Assertion for same slices. Same slices means, the order is not guaranteed, but the size and the content are equals.
///
/// # Arguments
/// * `awaiting` - The slice reference.
/// * `result` - The slice to test.
/// * `msg` - (Optional) The message for this assertion if failed.
///
/// # Example
/// ```
/// use utmt::assert_same_slices;
///
/// assert_same_slices!([1,2,3,4,5], [5,4,3,2,1]);
/// ```
/// ```should_panic
/// use utmt::assert_same_slices;
///
/// assert_same_slices!([1,2,3,4], [1,2,3]);
/// ```
#[macro_export]
macro_rules! assert_same_slices {
    ($awaiting:expr, $result:expr) => {
        assert_same_slices!($awaiting, $result, "Assertion failed");
    };

    ($awaiting:expr, $result:expr, $msg:literal) => {{
        assert_eq!($awaiting.len(), $result.len(), $msg);

        let mut cpt = 0;
        let mut is_same = true;

        while cpt < $awaiting.len() && is_same {
            is_same = $result.iter().filter(|&x| *x == $awaiting[cpt]).count() != 0;
            cpt += 1;
        }

        assert!(is_same, $msg);
    }};
}

/// Assertion for not same slices. Not same slices means, is not same content or not same the size.
///
/// # Arguments
/// * `awaiting` - The slice reference.
/// * `result` - The slice to test.
/// * `msg` - (Optional) The message for this assertion if failed.
///
/// # Example
/// ```
/// use utmt::assert_not_same_slices;
///
/// assert_not_same_slices!([1,2,3,4,5], [6,7,8,9,10]);
/// ```
/// ```should_panic
/// use utmt::assert_not_same_slices;
///
/// assert_not_same_slices!([1,2,3,4], [1,2,3,4]);
/// ```
#[macro_export]
macro_rules! assert_not_same_slices {
    ($awaiting:expr, $result:expr) => {
        assert_not_same_slices!($awaiting, $result, "Assertion failed")
    };

    ($awaiting:expr, $result:expr, $msg:literal) => {{
        let min = match $awaiting.len() < $result.len() {
            true => $awaiting.len(),
            false => $result.len(),
        };

        let mut common = 1;
        let mut cpt = 0;
        while cpt < min && common != 0 {
            common = $result.iter().filter(|&x| *x == $awaiting[cpt]).count();
            cpt += 1;
        }

        assert!((common == 0) | ($awaiting.len() != $result.len()), $msg);
    }};
}

/// Match the specific values.
///
/// # Arguments
/// * `$current` - Current value for matching these values
/// * `$ok_value` - Awaiting value for considering this match valid.
/// * `$nok_value` - Awaiting value for considering this match not valid.
/// * `$msg` - (Optional) Specific match message error.
///
/// # Return
/// The `Result<(), &'static str>` value.
///
/// # Examples
/// ```
/// use utmt::facility_match_values;
///
/// assert!(facility_match_values!(None::<i32>, None, Some(_)).is_ok())
/// ```
///
/// # Notes
/// This macro is using as support for other macros and do not `panic!()` if the internal matching test failed.
#[macro_export]
macro_rules! facility_match_values {
    ($current:expr, $ok_value:pat, $nok_value:pat) => {
        facility_match_values!($current, $ok_value, $nok_value, "Assertion failed")
    };

    ($current:expr, $ok_value:pat, $nok_value:pat, $msg:literal) => {
        match $current {
            $ok_value => Ok(()),
            $nok_value => Err($msg),
        }
    };
}

/// Force the test failure.
///
/// # Argument
/// * `msg` - Optional message.
///
/// # Example
/// ```should_panic
/// use utmt::fail;
///
/// fail!();
/// ```
///
/// ```should_panic
/// use utmt::fail;
///
/// fail!("A failed message");
/// ```
#[macro_export]
macro_rules! fail {
    () => {
        fail!("Test failed")
    };

    ($msg:literal) => {
        panic!("{}", $msg)
    };
}

/// Repeat the code block for a number of iterations.
///
/// # Arguments
/// * `$nb` - number of iterations. Must be an `usize` value.
/// * `$b`- block of code.
///
/// # Examples
/// ```rust
/// use utmt::repeat;
///
/// let mut counter = 0;
///
/// repeat!(10, {
///     counter += 1;
/// });
///
/// assert_eq!(10, counter);
/// ```
/// ```rust
/// use utmt::repeat;
///
/// let mut counter = 0;
///
/// repeat!(0, {
///     counter += 1;
/// });
///
/// assert_eq!(0, counter);
/// ```
#[macro_export]
macro_rules! repeat {
    ($nb:expr, $b:block) => {
        let mut max: usize = $nb as usize;
        while max != 0 {
            {
                $b
            }
            max -= 1;
        }
    };
}

/// Setup for unit test initialization.
///
/// # Argument
/// * `$b` - code block for unit test initialization.
///
/// # Example
/// ```no_run
///  use std::fs;
///  use std::fs::File;
///  use std::path::Path;
///  use utmt::setup;
///
/// setup!({File::create(Path::new("aFile.txt")).unwrap();});
/// ```
///
/// # Note
/// While `setup!({...})` is using is advised to use `teardown!({...})` after, like this example:
///
/// ```no_run
///  use std::fs;
///  use std::fs::File;
///  use std::path::Path;
///  use utmt::{setup, teardown};
///
/// setup!({File::create(Path::new("aFile.txt")).unwrap();});
/// teardown!({fs::remove_file(Path::new("aFile.txt")).unwrap();});
/// // ... test code
/// ```
#[macro_export]
macro_rules! setup {
    ($b:block) => {
        $b
    };
}

/// Teardown for unit tests. The code of the teardown macro will be running automatically while the test will end, with test failure or not.
///
/// # Argument
/// * `$b` - Code block for unit test teardown
///
/// # Example
/// ```no_run
///  use std::fs;
///  use std::fs::File;
///  use std::path::Path;
///  use utmt::teardown;
///
/// teardown!({fs::remove_file(Path::new("aFile.txt")).unwrap();});
/// ```
///
/// # Note
/// While `teardown!({...})` is using is advised to use `setup!({...})` before, like this example:
/// ```no_run
///  use std::fs;
///  use std::fs::File;
///  use std::path::Path;
///  use utmt::{setup, teardown};
///
/// setup!({File::create(Path::new("aFile.txt")).unwrap();});
/// teardown!({fs::remove_file(Path::new("aFile.txt")).unwrap();});
///
/// // ... test code
/// ```
#[macro_export]
macro_rules! teardown {
    ($b:block) => {
        struct AutoDown;
        impl Drop for AutoDown {
            fn drop(&mut self) {
                $b
            }
        }

        let _a = AutoDown;
    };
}

#[cfg(test)]
mod test {
    use std::fs;
    use std::fs::File;
    use std::path::Path;

    #[test]
    fn test_assert_all_true() {
        assert_all!(true);
    }

    #[should_panic]
    #[test]
    fn test_assert_all_false_panic() {
        assert_all!(false);
    }

    #[should_panic]
    #[test]
    fn test_assert_all_false_true_panic() {
        assert_all!(false, true);
    }

    #[should_panic]
    #[test]
    fn test_assert_all_true_false_panic() {
        assert_all!(true, false);
    }

    #[test]
    fn test_assert_all_multi() {
        assert_all!(true, 1 + 1 == 2);
    }

    #[should_panic]
    #[test]
    fn test_assert_all_multi_panic() {
        assert_all!(true, 1 + 1 == 2, 1 * 2 == 6);
    }

    #[should_panic]
    #[test]
    fn test_assert_multi_long_panic() {
        assert_all!(true, 1 + 1 == 2, 1 * 2 == 6, 0 * 0 == 0, 'a' == 'b');
    }

    #[should_panic]
    #[test]
    fn test_assert_all_compte_panic() {
        assert_all!(compute(), 1 + 1 == 2, 1 * 2 == 6);
    }

    fn compute() -> bool {
        false
    }
    
    #[test]
    fn test_assert_all_match_result() {
        assert_all_match_result!(result_ok1(), result_ok2())
    }
    
    fn result_ok1() -> Result<(), &'static str> {
        Ok(())
    }
    
    fn result_ok2() -> Result<(), &'static str> {
        Ok(())
    }
    
    #[should_panic]
    #[test]
    fn test_assert_all_match_result_fail() {
        assert_all_match_result!(result_ok1(), result_fail1(), result_ok2(), result_fail2())
    }
    
    fn result_fail1() -> Result<(), &'static str> {
        Err("result fail1")
    }
    
    fn result_fail2() -> Result<(), &'static str> {
        Err("result fail2")
    }
    
    #[test]
    fn test_assert_all_match_result_with_arguments() {
        ["value", "Value", "VALUE"].iter().for_each(|v| assert_all_match_result!(arg_with_value1(v), arg_with_value2(v)));
    }
    
    fn arg_with_value1(val: &str) -> Result<(), &'static str>{
        match val.to_ascii_lowercase().as_str() {
            "value" => Ok(()),
            _ => Err("Invalid value")
        }
    }
    
    fn arg_with_value2(val: &str) -> Result<(), &'static str>{
        match val.to_ascii_lowercase().as_str() {
            "value" => Ok(()),
            _ => Err("Invalid value")
        }
    }
    
    #[should_panic]
    #[test]
    fn test_assert_all_match_result_with_invalid_arguments() {
        ["value", "VALUE", "pas value"].iter().for_each(|v| assert_all_match_result!(arg_with_value1("value"), arg_with_value2(v)));
    }

    #[should_panic]
    #[test]
    fn test_fail() {
        fail!();
    }

    #[test]
    fn test_setup_teardown() {
        setup!({
            File::create(Path::new("test.txt")).unwrap();
        });
        teardown!({
            fs::remove_file(Path::new("test.txt")).unwrap();
        });

        assert!(Path::new("test.txt").exists());
    }

    #[test]
    fn test_setup_teardown_file_is_not_exist() {
        assert!(!Path::new("test.txt").exists());
    }

    #[test]
    fn test_assert_match_option() -> Result<(), &'static str> {
        assert_match_option!(Some(5))
    }

    #[test]
    fn test_assert_match_none() {
        let result = assert_match_option!(None::<i32>);

        assert_eq!(result, Err("Assertion failed"));
    }

    #[test]
    fn test_assert_match_with_specific_error_message() {
        let result = assert_match_option!(None::<i32>, "It's failed");

        assert_eq!(result, Err("It's failed"));
    }

    #[test]
    fn test_assert_not_match_option() {
        let result = assert_not_match_option!(None::<i32>);

        assert_eq!(result, Ok(()));
    }

    #[test]
    fn test_assert_not_match_not_none() {
        let result = assert_not_match_option!(Some(5));

        assert_eq!(result, Err("Assertion failed"));
    }

    #[test]
    fn test_assert_not_match_none_with_message() {
        let result = assert_not_match_option!(Some("Foo"), "Foo failed");

        assert_eq!(result, Err("Foo failed"));
    }

    #[test]
    fn test_assert_match_result() -> Result<(), &'static str> {
        assert_match_result!(Ok::<i32, &str>(5))
    }

    #[test]
    fn test_assert_match_result_with_message() {
        let result = assert_match_result!(Err::<(), &str>("Foo"), "It's failed");

        assert_eq!(result, Err("It's failed"));
    }
    
    #[test]
    fn test_assert_match_natural_result() -> Result<(), &'static str> {
        assert_match_natural_result!(match_natural_result(true))
    }
    
    fn match_natural_result(must_ok: bool) -> Result<&'static str, &'static str> {
        match must_ok {
            true => Ok("Ok"),
            false => Err("Error value")
        }
    }
    
    #[test]
    fn test_assert_match_natural_result_with_failed() {
     assert!(assert_match_natural_result!(match_natural_result(false)).is_err());   
    }
    
    #[test]
    fn test_assert_match_natural_result_other_type() -> Result<(),i32> {
        assert_match_natural_result!(match_result_with_i32(true))
    }
    
    fn match_result_with_i32(must_ok: bool) -> Result<(), i32> {
        match must_ok {
            true => Ok(()),
            false => Err(1)
        }
    }
    
    #[test]
    fn test_assert_match_natural_result_other_type_failed() {
        assert!(assert_match_natural_result!(match_result_with_i32(false)).is_err());
    }

    #[test]
    fn test_assert_not_match_result() -> Result<(), &'static str> {
        assert_not_match_result!(Err::<(), i32>(5), "It's failed")
    }

    #[test]
    fn test_assert_none_with_method() {
        assert_none!(none_method());
    }

    fn none_method() -> Option<i32> {
        None
    }

    #[should_panic]
    #[test]
    fn test_assert_none_with_none() {
        assert_none!(Some(3));
    }

    #[test]
    fn test_assert_not_none_valid() {
        assert_not_none!(Some(1));
    }

    #[should_panic]
    #[test]
    fn test_assert_not_none_from_method() {
        assert_not_none!(none_method());
    }

    #[test]
    fn test_assert_slices_eq() {
        let slice1 = [1, 2, 3, 4, 5];
        let slice2 = [1, 2, 3, 4, 5];

        assert_slices_eq!(slice1, slice2);
    }

    #[should_panic]
    #[test]
    fn test_assert_slices_eq_not_same_size() {
        let slice1 = ['a', 'b', 'c', 'd'];
        let slice2 = ['a', 'b', 'c'];

        assert_slices_eq!(slice1, slice2);
    }

    #[should_panic]
    #[test]
    fn test_assert_slices_eq_not_equal() {
        let slice1 = [1, 2, 3, 4, 5];
        let slice2 = [1, 2, 3, 5, 4];

        assert_slices_eq!(slice1, slice2);
    }

    #[test]
    fn test_assert_slices_eq_direct() {
        assert_slices_eq!([1, 2, 3, 4, 5], [1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_assert_slices_eq_with_vector() {
        let vec1 = vec![1, 2, 3, 4, 5];
        let vec2 = vec![1, 2, 3, 4, 5];

        assert_slices_eq!(vec1, vec2);
    }

    #[test]
    fn test_assert_slices_eq_with_string() {
        assert_slices_eq!("abcdef".as_bytes(), "abcdef".as_bytes());
    }

    #[should_panic]
    #[test]
    fn test_assert_slices_eq_with_message() {
        assert_slices_eq!([1, 2, 3, 4], [1, 2, 3, 3], "Error with this test");
    }

    #[test]
    fn test_assert_slices_ne_not_same_content() {
        assert_slices_ne!([1, 2, 3, 4, 5], [1, 2, 3, 4, 0]);
    }

    #[test]
    fn test_assert_slices_ne_not_same_size() {
        assert_slices_ne!([1, 2, 3, 4], [1, 2, 3]);
    }

    #[test]
    fn test_assert_slices_ne_not_same_size_reversed() {
        assert_slices_ne!([1, 2, 3], [1, 2, 3, 4]);
    }

    #[should_panic]
    #[test]
    fn test_assert_slices_ne_same_slices() {
        assert_slices_ne!([1, 2, 3, 4], [1, 2, 3, 4]);
    }

    #[should_panic]
    #[test]
    fn test_assert_slices_ne_with_message() {
        assert_slices_ne!([1, 2, 3, 4], [1, 2, 3, 4], "Slices are not valids");
    }

    #[test]
    fn test_assert_match_values() {
        assert_match_values!(true, true, false);
    }

    #[should_panic]
    #[test]
    fn test_assert_match_values_not_match() {
        assert_match_values!(false, true, false);
    }

    #[test]
    fn test_assert_not_match_values() {
        assert_not_match_values!(true, false, true);
    }

    #[should_panic]
    #[test]
    fn test_assert_not_match_values_not_match() {
        assert_not_match_values!(true, true, false);
    }

    #[test]
    fn test_assert_match_values_with_chars() {
        assert_match_values!('a', 'a'..'z', _);
    }

    #[test]
    fn test_assert_not_match_values_with_chars() {
        assert_not_match_values!(' ', 'a'..'z', _);
    }

    #[test]
    fn test_assert_same_slices_same_order_and_size() {
        assert_same_slices!([1, 2, 4, 5], [1, 2, 4, 5]);
    }

    #[test]
    fn test_assert_same_slices_same_reverse_order() {
        assert_same_slices!([1, 2, 3, 4, 5], [5, 4, 3, 2, 1]);
    }

    #[should_panic]
    #[test]
    fn test_assert_same_slices_same_order_not_size() {
        assert_same_slices!([1, 2, 3, 4], [1, 2, 3, 4, 5]);
    }

    #[should_panic]
    #[test]
    fn test_assert_same_slices_same_reverse_order_and_size() {
        assert_same_slices!([5, 4, 3, 2, 1], [5, 4, 3]);
    }

    #[test]
    fn test_assert_same_slices_same_vector() {
        let v1 = vec!['a', 'b', 'c', 'd'];
        let v2 = vec!['d', 'c', 'b', 'a'];

        assert_same_slices!(v1, v2);
    }

    #[should_panic]
    #[test]
    fn test_assert_same_slices_same_message() {
        let v1 = vec!['a', 'b', 'c', 'd'];
        let v2 = vec!['e', 'f', 'b', 'a'];

        assert_same_slices!(v1, v2, "Slices are not the same");
    }

    #[test]
    fn test_assert_not_same_slices_same_size() {
        assert_not_same_slices!([1, 2, 3, 4, 5], [6, 7, 8, 9, 10]);
    }

    #[test]
    fn test_assert_not_same_slices_not_same_size() {
        assert_not_same_slices!([1, 2, 3], [1, 2, 3, 4]);
    }

    #[should_panic]
    #[test]
    fn test_assert_not_same_slices_with_same_slices() {
        assert_not_same_slices!([1, 2, 3, 4, 5], [1, 2, 3, 4, 5]);
    }

    #[test]
    fn test_assert_not_same_slices_same_size_not_same_content() {
        assert_not_same_slices!([1, 2, 3, 4, 5], [1, 2, 3, 4, 4]);
    }

    #[test]
    fn test_repeat_10_repeats() {
        let mut counter = 0;
        repeat!(10, {
            counter += 1;
        });

        assert_eq!(10, counter);
    }

    #[test]
    fn test_repeat_zero_repeat() {
        let mut counter = 1;
        repeat!(0, {
            counter += 1;
        });

        assert_eq!(1, counter);
    }
}