Struct Assertion

pub struct Assertion<T> {
    pub value: T,
    pub expr_str: &'static str,
    pub negated: bool,
    pub steps: Vec<AssertionStep>,
    pub in_chain: bool,
    pub is_final: bool,
}

Represents the complete assertion with all steps

Fields

value: T

The value being tested

expr_str: &'static str

The expression string (variable name)

negated: bool

Whether the current assertion is negated

steps: Vec<AssertionStep>

All steps in the assertion chain

in_chain: bool

Flag to track if this is part of a chain

is_final: bool

Flag to mark the final step in a chain

Implementations

impl<T> Assertion<T>

pub fn new(value: T, expr_str: &'static str) -> Self

Creates a new assertion

pub fn add_step(&self, sentence: AssertionSentence, result: bool) -> Self

where T: Clone,

Add an assertion step and get back a cloned Assertion for chaining

pub fn set_last_logic(&mut self, op: LogicalOp)

Set the logical operation for the last step

pub fn mark_as_intermediate(&mut self)

Mark this assertion as non-final (intermediate step in a chain)

pub fn mark_as_final(&mut self)

Mark this assertion as final (last step in a chain)

pub fn calculate_chain_result(&self) -> bool

Calculate if the entire chain passes

pub fn evaluate(self) -> bool

where T: Clone,

Explicitly evaluate the assertion chain Returns true if the assertion passed, false otherwise

Trait Implementations

impl<T: Clone> AndModifier<T> for Assertion<T>

fn and(self) -> Self

Returns a new Assertion with the same value, allowing for chaining assertions

impl<V> BooleanMatchers for Assertion<V>

where V: AsBoolean + Debug + Clone,

fn to_be_true(self) -> Self

fn to_be_false(self) -> Self

impl<T: Clone> Clone for Assertion<T>

fn clone(&self) -> Assertion<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, V> CollectionMatchers<T> for Assertion<V>

where T: Debug + Clone + PartialEq, V: AsCollection<Item = T> + Debug + Clone,

fn to_be_empty(self) -> Self

fn to_have_length(self, expected: usize) -> Self

fn to_contain<U: PartialEq<T> + Debug>(self, expected: U) -> Self

fn to_contain_all_of<U: PartialEq<T> + Debug>(self, expected: &[U]) -> Self

fn to_equal_collection<U: PartialEq<T> + Debug>(self, expected: &[U]) -> Self

impl<T: Debug> Debug for Assertion<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Drop for Assertion<T>

For automatic evaluation of assertions when the Assertion drops

fn drop(&mut self)

Executes the destructor for this type.

impl<V, T> EqualityMatchers<T> for Assertion<V>

where T: Debug + PartialEq + Clone, V: AsEqualityComparable<T> + Debug + Clone,

fn to_equal(self, expected: T) -> Self

Check if the value is equal to the expected value

fn to_equal_value(self, expected: T) -> Self

Type-specific version of to_equal to avoid trait conflicts

impl<M, K, V> HashMapMatchers<K, V> for Assertion<M>

where K: Hash + Eq + Debug + Clone, V: Debug + Clone, M: AsHashMap<K, V> + Debug + Clone,

fn to_be_empty(self) -> Self

fn to_have_length(self, expected: usize) -> Self

fn to_contain_key<Q>(self, key: &Q) -> Self

where K: Borrow<Q>, Q: Hash + Eq + Debug + ?Sized,

fn to_contain_entry<Q, R>(self, key: &Q, value: &R) -> Self

where K: Borrow<Q>, V: Borrow<R>, Q: Hash + Eq + Debug + ?Sized, R: PartialEq + Debug + ?Sized,

impl<T: Clone> NotModifier<T> for Assertion<T>

fn not(self) -> Self

Creates a negated assertion This provides a fluent API for negated assertions: expect(value).not().to_equal(x)

impl<V> NumericMatchers<i32> for Assertion<V>

where V: AsNumeric + Debug + Clone,

fn to_be_positive(self) -> Self

fn to_be_negative(self) -> Self

fn to_be_zero(self) -> Self

fn to_be_greater_than(self, expected: i32) -> Self

fn to_be_greater_than_or_equal(self, expected: i32) -> Self

fn to_be_less_than(self, expected: i32) -> Self

fn to_be_less_than_or_equal(self, expected: i32) -> Self

fn to_be_in_range(self, range: Range<i32>) -> Self

fn to_be_even(self) -> Self

fn to_be_odd(self) -> Self

impl<T, V> OptionMatchers<T> for Assertion<V>

where T: Debug + Clone + PartialEq, V: AsOption<Item = T> + Debug + Clone,

fn to_be_some(self) -> Self

fn to_be_none(self) -> Self

fn to_contain(self, expected: &T) -> Self

where T: PartialEq,

impl<T: Clone> OrModifier<T> for Assertion<T>

fn or(self) -> Self

Returns a new Assertion with the same value, allowing for OR chaining assertions

impl<V, T, E> ResultMatchers<T, E> for Assertion<V>

where T: Debug + Clone, E: Debug + Clone, V: AsResult<T, E> + Debug + Clone,

fn to_be_ok(self) -> Self

fn to_be_err(self) -> Self

fn to_contain_ok<U: PartialEq<T> + Debug>(self, expected: &U) -> Self

fn to_contain_err<U: PartialEq<E> + Debug>(self, expected: &U) -> Self

impl<V> StringMatchers for Assertion<V>

where V: AsString + Debug + Clone,

fn to_be_empty(self) -> Self

fn to_have_length(self, expected: usize) -> Self

fn to_contain(self, substring: &str) -> Self

Check if the string contains a substring

fn to_contain_substring(self, substring: &str) -> Self

Type-specific version of to_contain to avoid trait conflicts

fn to_start_with(self, prefix: &str) -> Self

fn to_end_with(self, suffix: &str) -> Self

fn to_match(self, pattern: &str) -> Self