Struct unit_testing::unit::Assert

pub struct Assert { /* private fields */ }

To run assertions tests

Trait Implementations

impl Failure for Assert

fn command_fail( &mut self, callbacks: Vec<&dyn Fn() -> Result<ExitStatus, Error>> ) -> &mut Self

Check if a command exit status is a failure code

fn fail(&mut self, callbacks: Vec<&dyn Fn() -> bool>) -> &mut Self

Check if a callbacks return false

impl Success for Assert

fn run( &mut self, callbacks: Vec<&dyn Fn() -> Result<ExitStatus, Error>> ) -> &mut Self

Check if a command success

fn success(&mut self, callbacks: Vec<&dyn Fn() -> bool>) -> &mut Self

Check if a callbacks return true

impl Take for Assert

fn assert_that(&mut self, t: bool) -> bool

run assertion

fn take(&mut self, t: bool, s: &str, e: &str) -> &mut Self

Run assert and measure execution time

fn check(&mut self, t: bool, s: &str, e: &str)

Run a assert and mesure the time

impl Testable for Assert

fn matches(&mut self, pattern: &str, values: Vec<String>) -> &mut Self

Check if a pattern matches values

fn capture( &mut self, pattern: &str, x: &str, key: usize, values: Vec<String> ) -> &mut Self

check if a pattern a the x index equal a value listing in values

fn it( describe: &str, sleep_time: u64, callbacks: Vec<&dyn Fn(&mut Self) -> &mut Self> )

Constructor

fn ok(&mut self, f: &dyn Fn() -> bool) -> &mut Self

Assert if callback return true

fn ko(&mut self, f: &dyn Fn() -> bool) -> &mut Self

Assert if callback return false

fn assert(&mut self, test: bool) -> bool

Check if test pass

fn equals<T: PartialEq>(&mut self, a: T, b: T) -> &mut Self

Check if a and b are equals

fn unequals<T: PartialEq>(&mut self, a: T, b: T) -> &mut Self

Check if a and b are unequals

fn superior<T: PartialOrd>(&mut self, a: T, min: T) -> &mut Self

Check if a are superior to min

fn inferior<T: PartialOrd>(&mut self, a: T, max: T) -> &mut Self

Check if a are inferior to max

fn between<T: PartialOrd>(&mut self, a: T, min: T, max: T) -> &mut Self

Check if a are between min and max

fn vec_contains<T: PartialEq>(&mut self, a: Vec<T>, b: T) -> &mut Self

Check if a vector contains a value

fn program(&mut self, p: &str) -> &mut Self

Check if p is a program

fn not_program(&mut self, p: &str) -> &mut Self

Check if p is not a program

fn vec_no_contains<T: PartialEq>(&mut self, a: Vec<T>, b: T) -> &mut Self

Check if a vector not contains a value

fn option_contains<T: PartialEq>(&mut self, a: Option<T>, b: T) -> &mut Self

Check if a option contains a value

fn hash_contains(&mut self, a: &mut HashSet<String>, b: String) -> &mut Self

Check if a hash contains a string

fn string_contains(&mut self, a: &str, b: &str) -> &mut Self

Check if a sting contains a substring

fn file_contains(&mut self, f: &str, v: &str) -> &mut Self

Check if a file contains a value

fn exists(&mut self, p: &str) -> &mut Self

Check if a paths exists

fn not_exists(&mut self, p: &str) -> &mut Self

Check if a path not exist

fn begin_with(&mut self, actual: &str, expected: &str) -> &mut Self

Check if a string begin with the expected value

fn end_with(&mut self, actual: &str, expected: &str) -> &mut Self

Check if a string finnish with the expected value

fn end(&mut self) -> bool

Show assertions

fn new(sleep_time: u64) -> Self

sleep_time The sleep time

impl Theory for Assert

fn chaos(&mut self, callback: &dyn Fn() -> bool) -> &mut Self

A theory must be equal to false

fn theory<T: PartialEq>( &mut self, expected: T, callback: &dyn Fn() -> T ) -> &mut Self

Test a theory