Struct Assertion

Source

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,
}

Expand description

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§

Source §

impl<T> Assertion<T>

Source

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

Creates a new assertion

Source

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

Source

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

Set the logical operation for the last step

Source

pub fn mark_as_intermediate(&mut self)

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

Source

pub fn mark_as_final(&mut self)

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

Source

pub fn calculate_chain_result(&self) -> bool

Calculate if the entire chain passes

Source

pub fn evaluate(self) -> bool
where T: Clone,

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

Examples found in repository ?

examples/enhanced_output.rs (line 16)

3fn main() {
4    println!("FluentTest Enhanced Output Example\n");
5
6    // Enable enhanced output for this example
7    config().enhanced_output(true).apply();
8
9    // Use various expectations to show the enhanced formatting
10    println!("Running assertions with enhanced output enabled:");
11
12    // Number assertions
13    let number = 42;
14    print_result("expect!(number).to_be_even()", || {
15        // Call evaluate explicitly to get the boolean result
16        expect!(number).to_be_even().evaluate()
17    });
18
19    print_result("expect!(number).to_be_greater_than(30).and().to_be_less_than(50)", || {
20        expect!(number).to_be_greater_than(30).and().to_be_less_than(50).evaluate()
21    });
22
23    // Failing assertion - use catch_unwind for this since it will panic
24    let result = std::panic::catch_unwind(|| {
25        expect!(number).to_be_greater_than(100);
26    });
27    match result {
28        Ok(_) => println!("\n🔍 expect!(number).to_be_greater_than(100)\n  ❌ Failed but did not panic"),
29        Err(e) => {
30            if let Some(s) = e.downcast_ref::<String>() {
31                println!("\n🔍 expect!(number).to_be_greater_than(100)\n  ❌ Failed with: {}", s);
32            } else {
33                println!("\n🔍 expect!(number).to_be_greater_than(100)\n  ❌ Failed with panic");
34            }
35        }
36    }
37
38    // String assertions
39    let text = "Hello, world!";
40    print_result("expect!(text).to_contain(\"world\")", || expect!(text).to_contain("world").evaluate());
41
42    // Collection assertions
43    let items = vec![1, 2, 3, 4, 5];
44    print_result("expect!(items.as_slice()).to_have_length(5)", || expect!(items.as_slice()).to_have_length(5).evaluate());
45
46    println!("\nNOTE: Without enhanced output enabled (the default), these assertions would");
47    println!("      produce standard Rust assertion messages instead of the detailed ones shown above.");
48    println!("\nUse config().enhanced_output(true).apply() to enable enhanced output in your code,");
49    println!("or set the FLUENT_TEST_ENHANCED_OUTPUT=true environment variable.");
50}