Struct unit::Unit

pub struct Unit {}

Implementations

impl Unit

pub fn new() -> Unit

pub fn end(self) -> Result<(), ()>

pub fn ok( self, description: &str, callback: &dyn Fn() -> bool, success: &str, failure: &str, message: &str ) -> Unit

Check if a callback return true

• description The test description
• callback The callback to check
• success The success message
• failure The failure message
• message The panic message

use std::env::consts::OS;
use unit::Unit;

fn is_linux()-> bool
{
    OS == "linux"
}

Unit::new()
.ok("Check if user use linux",&is_linux,"User use linux","User don't use linux","User must be use linux")
.end().expect("panic message");

pub fn ko( self, description: &str, callback: &dyn Fn() -> bool, success: &str, failure: &str, message: &str ) -> Unit

Check if a callback return false

• description The test description
• callback The callback to check
• success The success message
• failure The failure message
• message The panic message

use std::env::consts::OS;
use unit::Unit;

fn is_windows()-> bool
{
    OS == "windows"
}

Unit::new()
.ko("Check if user use linux",&is_windows,"User use linux","User don't use linux","User must be use linux")
.end().expect("panic message");

pub fn equals<T: PartialEq>( self, description: &str, callback: &dyn Fn() -> T, expected: T, success: &str, failure: &str, message: &str ) -> Unit

Check if a callback is equals to expected value

• description The test description
• callback The callback to check
• expected The callback expected result
• success The success message
• failure The failure message
• message The panic message

use std::env::consts::OS;
use unit::Unit;

fn is_windows()-> bool
{
    OS == "windows"
}

Unit::new()
.equals("Check if user use linux",&is_windows,false,"User use linux","User don't use linux","User must be use linux")
.end().expect("panic message");

pub fn between<T: PartialOrd>( self, description: &str, callback: &dyn Fn() -> T, min: T, max: T, success: &str, failure: &str, message: &str ) -> Unit

Check if a callback return a expected value

• description The test description
• callback The callback to check
• min The min value for the callback result
• max The callback for the callback result
• success The success message
• failure The failure message
• message The panic message

use std::env::consts::OS;
use unit::Unit;

fn is_windows()-> i32
{
    500
}

Unit::new()
.between("Check if user use linux",&is_windows,400,600,"User use linux","User don't use linux","User must be use linux")
.end().expect("panic message");

pub fn unequals<T: PartialEq>( self, description: &str, callback: &dyn Fn() -> T, unexpected: T, success: &str, failure: &str, message: &str ) -> Unit

Check if a callback are unequals to the expected value

• description The test description
• callback The callback to check
• unexpected The callback unexpected result
• success The success message
• failure The failure message
• message The panic message

use std::env::consts::OS;
use unit::Unit;

fn is_windows()-> bool
{
    OS == "windows"
}

Unit::new()
.unequals("Check if user use linux",&is_windows,true,"User use linux","User don't use linux","User must be use linux")
.end().expect("panic message");

pub fn inferior<T: PartialOrd>( self, description: &str, callback: &dyn Fn() -> T, expected: T, success: &str, failure: &str, message: &str ) -> Unit

Check if a callback return an inferior value to the expected value

• description The test description
• callback The callback to check
• success The success message
• failure The failure message
• message The panic message

use std::env::consts::OS;
use unit::Unit;

fn is_windows()-> i32
{
    500
}

Unit::new()
.inferior("Check if user use linux",&is_windows,1000,"User use linux","User don't use linux","User must be use linux")
.end().expect("panic message");

pub fn superior<T: PartialOrd>( self, description: &str, callback: &dyn Fn() -> T, expected: T, success: &str, failure: &str, message: &str ) -> Unit

Check if a callback return a superior value to expected

• description The test description
• callback The callback to check
• success The success message
• failure The failure message
• message The panic message

use std::env::consts::OS;
use unit::Unit;

fn is_windows()-> i32
{
    500
}

Unit::new()
.superior("Check if user use linux",&is_windows,400,"User use linux","User don't use linux","User must be use linux")
.end().expect("panic message");

pub fn not_empty( self, description: &str, expected: &fn() -> String, success: &str, failure: &str, message: &str ) -> Unit

Check if a callback return a not empty value

• description The test description
• callback The callback to check
• success The success message
• failure The failure message
• message The panic message

use std::env::consts::OS;
use unit::Unit;

fn os()-> String
{
    OS.to_string()
}

Unit::new()
.not_empty("Check if we can detected os",&os,"We can detect os","We can't detect os","We must detect os")
.end().expect("panic message");

pub fn empty( self, description: &str, expected: fn() -> String, success: &str, failure: &str, message: &str ) -> Unit

Check if a callback return an empty value

• description The test description
• callback The callback to check
• success The success message
• failure The failure message
• message The panic message

use std::env::consts::OS;
use unit::Unit;

fn os()-> String
{
   String::new()
}

Unit::new()
.empty("Check if we can detected os",os,"We can detect os","We can't detect os","We must detect os")
.end().expect("panic message");

pub fn exists( self, description: &str, paths: Vec<&str>, success: &str, failure: &str, message: &str ) -> Unit

Check if all paths given exists

• description The test description
• callback The callback to check
• success The success message
• failure The failure message
• message The panic message

use std::env::consts::OS;
use unit::Unit;

fn is_windows()-> bool
{
    OS == "windows"
}

Unit::new()
.exists("Check if user use linux",vec!["/","/home"],"User use linux","User don't use linux","User must be use linux")
.end().expect("panic message");

pub fn theory<T: PartialEq>( self, description: &str, callback: &dyn Fn() -> T, expected: T, success: &str, failure: &str, message: &str ) -> Unit

Check if a callback return a expected value

• description The test description
• callback The callback to check
• success The success message
• failure The failure message
• message The panic message

use std::env::consts::OS;
use unit::Unit;

fn is_windows()-> bool
{
    OS == "windows"
}

Unit::new()
.unequals("Check if user use linux",&is_windows,true,"User use linux","User don't use linux","User must be use linux")
.end().expect("panic message");

pub fn expect<T: PartialEq>( self, description: &str, callback: &dyn Fn() -> T, expected: T, success: &str, failure: &str, message: &str ) -> Unit

Check if a callback return a expected value

• description The test description
• callback The callback to check
• success The success message
• failure The failure message
• message The panic message

use std::env::consts::OS;
use unit::Unit;

fn is_windows()-> bool
{
    OS == "windows"
}

Unit::new()
.expect("Check if user use linux",&is_windows,false,"User use linux","User don't use linux","User must be use linux")
.end().expect("panic message");

pub fn chaos<T: PartialEq>( self, description: &str, callback: &dyn Fn() -> T, unexpected: T, success: &str, failure: &str, message: &str ) -> Unit

Check if a callback return false

• description The test description
• callback The callback to check
• success The success message
• failure The failure message
• message The panic message

use std::env::consts::OS;
use unit::Unit;

fn is_windows()-> bool
{
    OS == "windows"
}

Unit::new()
.unequals("Check if user use linux",&is_windows,true,"User use linux","User don't use linux","User must be use linux")
.end().expect("panic message");