Struct Unit

pub struct Unit { /* private fields */ }

To run units tests

Trait Implementations

impl Failure for Unit

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 Unit

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 Unit

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 an assert and measure the time

impl Testable for Unit

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 the x index equals a value listing in values

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

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

Assert if callback return true

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

Assert if callback return false

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

Check if test pass

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

Check if a and b are equals

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

Check if a and b are unequals

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

Check if a is superior to min

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

Check if a is superior or equal to min

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

Check if a is inferior to max

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

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

Check if a is 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 exe(&mut self, p: &str) -> &mut Self

Check if p is 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 an 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 str_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 path exists

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

Check if a path not exists

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

Check if a string begins 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 Unit

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

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

Check if a theorem is true