Struct Unit 

pub struct Unit { /* private fields */ }

Implementations

impl Unit

To run unit test

pub fn see(url: &str, expected: &str) -> bool

pub fn equals_bytes(&mut self, actual: &str, expected: &[u8]) -> &mut Unit

pub fn unequals_bytes(&mut self, actual: &str, expected: &[u8]) -> &mut Unit

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

pub fn finnish_with(&mut self, actual: &str, expected: &str) -> &mut Unit

pub fn exe(&mut self, filename: &str) -> &mut Unit

Test if a file is an executable

• filename The filename to test

pub fn not_exe(&mut self, filename: &str) -> &mut Unit

pub fn describe( &mut self, description: &str, it: fn(&mut Unit) -> &mut Unit, ) -> &mut Unit

Group test in a function

• description The group test description
• it The callback to execute

pub fn title(&mut self, description: &str)

pub fn theory(&mut self, description: &str, it: fn() -> bool) -> &mut Unit

pub fn chaos(&mut self, description: &str, it: fn() -> bool) -> &mut Unit

Check if a theory match false

• description THe theory description
• it The callback to execute

pub fn new(description: &str, time: u64, s: Style) -> Unit

Unit constructor

• description The unit test description
• time The sleep time

pub fn end(&mut self) -> Result<String, String>

End of the tests

pub fn ok(&mut self, b: bool) -> &mut Unit

Check if all values are equals to true

• b A value to check

pub fn ko(&mut self, b: bool) -> &mut Unit

Check if all values are equals to false

• b The value to check

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

Check if two value are equals

• a The first value
• b The second value

pub fn between<T: PartialOrd>(&mut self, actual: T, min: T, max: T) -> &mut Unit

Check if actual is in min and []ax value

• actual The actual value
• min The minimun value for actual
• max The maximum value for actual

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

Check if values are unequals

• a The first value
• b The second value

pub fn inferior<T: PartialOrd>(&mut self, actual: T, max: T) -> &mut Unit

Check if the value is inferior to the maximum value

• actual The actual value
• max The maximum value

pub fn superior<T: PartialOrd>(&mut self, actual: T, min: T) -> &mut Unit

Check if the value is superior to the minimun value

• actual The actual value
• min The minimum value

pub fn not_empty(&mut self, x: &str) -> &mut Unit

Check if a string is not empty

• x The string to check

pub fn contains(&mut self, x: &str, expected: &str) -> &mut Unit

Check if a string contains another string

• x The string to check
• expected The string to verify

pub fn not_contains(&mut self, x: &str, expected: &str) -> &mut Unit

Check if a string not contains another string

• x The string to check
• expected The string to verify

pub fn empty(&mut self, x: &str) -> &mut Unit

Check if a string is empty

• x The string to check

pub fn is_directory(&mut self, d: &str) -> &mut Unit

Check if the given value is a directory

• d The path to check

pub fn is_not_directory(&mut self, d: &str) -> &mut Unit

Check if the given value is not a directory

• d The path to check

pub fn is_file(&mut self, f: &str) -> &mut Unit

Check if the given value is a file

• f The path to check

pub fn path_start_with(&mut self, path: &str, base: &str) -> &mut Unit

Chek if a path start with a expected base

• path The path to check
• base The path’s base

pub fn path_absolute(&mut self, path: &str) -> &mut Unit

Chek if a path is absolute

• path The path to check

pub fn path_not_absolute(&mut self, path: &str) -> &mut Unit

Chek if a path is not absolute

• path The path to check

pub fn path_exists(&mut self, path: &str) -> &mut Unit

Chek if a path exist

• path The path to check

pub fn path_not_relative(&mut self, path: &str) -> &mut Unit

Chek if a path is not relative

• path The path to check

pub fn is_executable(&mut self, path: &str) -> &mut Unit

Chek if a path is not relative

• path The path to check

pub fn is_not_executable(&mut self, path: &str) -> &mut Unit

Chek if a path is relative

• path The path to check

pub fn path_symlink(&mut self, path: &str) -> &mut Unit

Chek if a path is relative

• path The path to check

pub fn path_relative(&mut self, path: &str) -> &mut Unit

Chek if a path exist

• path The path to check

pub fn path_no_exists(&mut self, path: &str) -> &mut Unit

Chek if a path is not absolute

• path The path to check

pub fn file_contains(&mut self, file: &str, expected: &str) -> &mut Unit

Check if a file contains an another string

• file The path to check
• expected The expected value

pub fn file_no_contains(&mut self, file: &str, expected: &str) -> &mut Unit

Check if a file no contains an another string

• file The path to check
• expected The unexpected value

pub fn vec_length_equals<T: PartialEq>( &mut self, a: Vec<T>, b: Vec<T>, ) -> &mut Unit

Check if two vec length are equals

• a The first vector
• b The second vector

pub fn vec_length_unequals<T: PartialEq>( &mut self, a: Vec<T>, b: Vec<T>, ) -> &mut Unit

Check if two vec length are unequals

• a The first vector
• b The second vector

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

Check if a vec contains a value

• a The vector
• b The value

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

Check if a vec not contains a value

• a The vector
• b The value

pub fn vec_start_with<T: PartialEq>(&mut self, a: Vec<T>, b: T) -> &mut Unit

Check if a vec start with a value

• a The vector
• b The value

pub fn vec_no_start_with<T: PartialEq>(&mut self, a: Vec<T>, b: T) -> &mut Unit

Check if a vec no start with a value

• a The vector
• b The value

pub fn vec_end_with<T: PartialEq>(&mut self, a: Vec<T>, b: T) -> &mut Unit

Check if a vec finnish with a value

• a The vector
• b The value

pub fn vec_no_end_with<T: PartialEq>(&mut self, a: Vec<T>, b: T) -> &mut Unit

Check if a vec finnish with a value

• a The vector
• b The value

pub fn vec_empty<T: PartialEq>(&mut self, a: Vec<T>) -> &mut Unit

Check if a vec is empty

• a The vector

pub fn vec_not_empty<T: PartialEq>(&mut self, a: Vec<T>) -> &mut Unit

Check if a vec is not empty

• a The vector

pub fn full(&mut self, callback: fn() -> usize, max: usize) -> &mut Unit

Check if the return of the callback is not at this maximum value

• callback The callback to check
• max The callback maximum value

pub fn not_full(&mut self, callback: fn() -> usize, max: usize) -> &mut Unit

Check if the return of the callback is not at this maximum value

• callback The callback to check
• max The callback maximum value

pub fn prime(&mut self, x: usize) -> &mut Unit

Check if the value is a prime number

• x The value to check

pub fn pair(&mut self, x: usize) -> &mut Unit

Check if the value is a pair number

• x The value to check

pub fn impair(&mut self, x: usize) -> &mut Unit

Check if the value is an impair number

• x The value to check