Trait shoulda::Shoulda

pub trait Shoulda: Debug {
    fn test_eq<FloatDiff>(&self, other: &Self) -> bool
    where
        FloatDiff: FloatDiffProvider;

    fn should(
        &self
    ) -> Should<'_, Self, NoOpAssertionHook, EnvFloatDiffProvider> { ... }
}

Required methods

fn test_eq<FloatDiff>(&self, other: &Self) -> bool where
    FloatDiff: FloatDiffProvider, 

Provided methods

fn should(&self) -> Should<'_, Self, NoOpAssertionHook, EnvFloatDiffProvider>

Implementations on Foreign Types

impl Shoulda for bool

pub fn test_eq<FloatDiff>(&self, other: &bool) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for isize

pub fn test_eq<FloatDiff>(&self, other: &isize) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<'_, T> Shoulda for &'_ [T] where
    T: Debug + Shoulda, 

pub fn test_eq<FloatDiff>(&self, other: &&'_ [T]) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for CStr

pub fn test_eq<FloatDiff>(&self, other: &CStr) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for ()

pub fn test_eq<FloatDiff>(&self, &()) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for i8

pub fn test_eq<FloatDiff>(&self, other: &i8) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for Ipv4Addr

pub fn test_eq<FloatDiff>(&self, other: &Ipv4Addr) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for u128

pub fn test_eq<FloatDiff>(&self, other: &u128) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for usize

pub fn test_eq<FloatDiff>(&self, other: &usize) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for NonZeroI128

pub fn test_eq<FloatDiff>(&self, other: &NonZeroI128) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for String

pub fn test_eq<FloatDiff>(&self, other: &String) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for f32

pub fn test_eq<FloatDiff>(&self, other: &f32) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for u32

pub fn test_eq<FloatDiff>(&self, other: &u32) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for NonZeroU64

pub fn test_eq<FloatDiff>(&self, other: &NonZeroU64) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T> Shoulda for VecDeque<T> where
    T: Debug + Shoulda, 

pub fn test_eq<FloatDiff>(&self, other: &VecDeque<T>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for Permissions

pub fn test_eq<FloatDiff>(&self, other: &Permissions) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for NonZeroI16

pub fn test_eq<FloatDiff>(&self, other: &NonZeroI16) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for OsStr

pub fn test_eq<FloatDiff>(&self, other: &OsStr) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for f64

pub fn test_eq<FloatDiff>(&self, other: &f64) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for ThreadId

pub fn test_eq<FloatDiff>(&self, other: &ThreadId) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for i64

pub fn test_eq<FloatDiff>(&self, other: &i64) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for NonZeroI64

pub fn test_eq<FloatDiff>(&self, other: &NonZeroI64) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for Instant

pub fn test_eq<FloatDiff>(&self, other: &Instant) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for NonZeroU128

pub fn test_eq<FloatDiff>(&self, other: &NonZeroU128) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for CString

pub fn test_eq<FloatDiff>(&self, other: &CString) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for NonZeroU32

pub fn test_eq<FloatDiff>(&self, other: &NonZeroU32) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for NonZeroIsize

pub fn test_eq<FloatDiff>(&self, other: &NonZeroIsize) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for Path

pub fn test_eq<FloatDiff>(&self, other: &Path) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for OsString

pub fn test_eq<FloatDiff>(&self, other: &OsString) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<L, K> Shoulda for Result<L, K> where
    K: Shoulda + Debug,
    L: Shoulda + Debug, 

pub fn test_eq<FloatDiff>(&self, other: &Result<L, K>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for NonZeroI32

pub fn test_eq<FloatDiff>(&self, other: &NonZeroI32) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for SocketAddrV6

pub fn test_eq<FloatDiff>(&self, other: &SocketAddrV6) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for i128

pub fn test_eq<FloatDiff>(&self, other: &i128) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T> Shoulda for HashSet<T, RandomState> where
    T: Debug + Shoulda + Eq + Hash, 

pub fn test_eq<FloatDiff>(&self, other: &HashSet<T, RandomState>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for u16

pub fn test_eq<FloatDiff>(&self, other: &u16) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for str

pub fn test_eq<FloatDiff>(&self, other: &str) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for Duration

pub fn test_eq<FloatDiff>(&self, other: &Duration) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<'_, T> Shoulda for &'_ T where
    T: Shoulda, 

pub fn test_eq<FloatDiff>(&self, other: &&'_ T) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<K> Shoulda for Option<K> where
    K: Shoulda + Debug, 

pub fn test_eq<FloatDiff>(&self, other: &Option<K>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for SocketAddrV4

pub fn test_eq<FloatDiff>(&self, other: &SocketAddrV4) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for i16

pub fn test_eq<FloatDiff>(&self, other: &i16) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for NonZeroUsize

pub fn test_eq<FloatDiff>(&self, other: &NonZeroUsize) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for i32

pub fn test_eq<FloatDiff>(&self, other: &i32) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for FileType

pub fn test_eq<FloatDiff>(&self, other: &FileType) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T> Shoulda for PhantomData<T>

pub fn test_eq<FloatDiff>(&self, &PhantomData<T>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T> Shoulda for Box<T, Global> where
    T: Shoulda + ?Sized, 

pub fn test_eq<FloatDiff>(&self, other: &Box<T, Global>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T> Shoulda for Range<T> where
    T: Debug + Shoulda, 

pub fn test_eq<FloatDiff>(&self, other: &Range<T>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for Ipv6Addr

pub fn test_eq<FloatDiff>(&self, other: &Ipv6Addr) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<'_, K> Shoulda for Cow<'_, K> where
    K: Shoulda + Debug + ToOwned + ?Sized,
    <K as ToOwned>::Owned: Debug, 

pub fn test_eq<FloatDiff>(&self, other: &Cow<'_, K>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for SystemTime

pub fn test_eq<FloatDiff>(&self, other: &SystemTime) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T> Shoulda for Vec<T, Global> where
    T: Debug + Shoulda, 

pub fn test_eq<FloatDiff>(&self, other: &Vec<T, Global>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T> Shoulda for RefCell<T> where
    T: Shoulda + Debug + ?Sized, 

pub fn test_eq<FloatDiff>(&self, other: &RefCell<T>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T, K> Shoulda for HashMap<T, K, RandomState> where
    T: Debug + Shoulda + Eq + Hash,
    K: Debug + Shoulda, 

pub fn test_eq<FloatDiff>(&self, other: &HashMap<T, K, RandomState>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for NonZeroU16

pub fn test_eq<FloatDiff>(&self, other: &NonZeroU16) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for NonZeroI8

pub fn test_eq<FloatDiff>(&self, other: &NonZeroI8) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for u64

pub fn test_eq<FloatDiff>(&self, other: &u64) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T> Shoulda for [T] where
    T: Debug + Shoulda, 

pub fn test_eq<FloatDiff>(&self, other: &[T]) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T> Shoulda for Wrapping<T> where
    T: Shoulda + Debug, 

pub fn test_eq<FloatDiff>(&self, other: &Wrapping<T>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T> Shoulda for Arc<T> where
    T: Shoulda + Debug + ?Sized, 

pub fn test_eq<FloatDiff>(&self, other: &Arc<T>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for PathBuf

pub fn test_eq<FloatDiff>(&self, other: &PathBuf) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T> Shoulda for RangeInclusive<T> where
    T: Debug + Shoulda, 

pub fn test_eq<FloatDiff>(&self, other: &RangeInclusive<T>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T> Shoulda for Rc<T> where
    T: Shoulda + Debug + ?Sized, 

pub fn test_eq<FloatDiff>(&self, other: &Rc<T>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl<T> Shoulda for Cell<T> where
    T: Shoulda + Debug + Copy + ?Sized, 

pub fn test_eq<FloatDiff>(&self, other: &Cell<T>) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for NonZeroU8

pub fn test_eq<FloatDiff>(&self, other: &NonZeroU8) -> bool where
    FloatDiff: FloatDiffProvider, 

impl Shoulda for u8

pub fn test_eq<FloatDiff>(&self, other: &u8) -> bool where
    FloatDiff: FloatDiffProvider, 

Implementors