Struct Reporter 

pub struct Reporter;

Implementations

impl Reporter

pub fn init()

Initialize the reporter with event handlers

pub fn reset_message_cache()

Clear the message cache to allow duplicated messages in different test scopes

pub fn enable_deduplication()

Enable deduplication of messages

pub fn disable_deduplication()

Disable deduplication of messages (for tests)

pub fn enable_silent_mode()

Enable silent mode to suppress intermediate output in chains

pub fn disable_silent_mode()

Disable silent mode to show all output

pub fn summarize()

Examples found in repository

examples/basic.rs (line 30)

fn main() {
    // Enable enhanced output for this example
    config().enhanced_output(true).apply();

    // Just to demonstrate the API
    let x = 42;
    let name = "Arthur";

    // Integer tests - direct and by reference
    expect!(x).to_be_greater_than(30);
    expect!(x).to_be_less_than(50);
    expect!(x).to_be_even();

    // Create a reference to demonstrate the & removal in output
    let x_ref = &x;
    expect!(x_ref).to_equal(&42);

    // String tests - direct and by reference
    expect!(name).to_contain("th");
    expect!(name).to_have_length(6);

    // Create a reference to demonstrate the & removal in output
    let name_ref = &name;
    let arthur = "Arthur";
    expect!(name_ref).to_equal(&arthur);

    // Report test results
    fluent_test::Reporter::summarize();
}

examples/modifiers.rs (line 43)

fn main() {
    // Enable enhanced output for this example
    config().enhanced_output(true).apply();

    println!("\n=== Testing AND modifier (all true) ===");
    let number = 42;
    // Using AND modifier with both conditions true
    expect!(number).to_be_greater_than(30).and().to_be_less_than(50);

    println!("\n=== Testing complex AND chain (passing) ===");
    // Complex chain with multiple AND conditions
    expect!(number).to_be_even().and().to_be_positive();

    println!("\n=== Testing failing OR chain with passing part ===");
    // Using OR modifier (will pass if any condition is true)
    expect!(number).to_be_greater_than(50).or().to_be_less_than(30).or().to_equal(42);

    println!("\n=== Testing OR chain (all false) ===");
    // All conditions fail - should report failure and handle the panic
    let success = guard_test(|| {
        expect!(number).to_be_greater_than(50).or().to_be_less_than(30).or().to_be_greater_than(100);
    });

    if !success {
        println!("Test failed as expected (all conditions were false)");
    }

    println!("\n=== Testing combined NOT with AND ===");
    // Combining AND and OR with NOT
    expect!(number).not().to_be_less_than(30).and().not().to_be_greater_than(50);

    println!("\n=== Testing string matchers with AND ===");
    // String example
    let name = "Arthur";
    expect!(name).to_contain("th").and().to_have_length(6).and().not().to_be_empty();

    // Report test results
    println!("\n=== Test Summary ===");
    fluent_test::Reporter::summarize();
}

examples/new_matchers.rs (line 54)

fn main() {
    // Enable enhanced output for this example
    config().enhanced_output(true).apply();

    // Boolean matchers
    let is_enabled = true;
    expect!(is_enabled).to_be_true();
    expect!(!is_enabled).to_be_false();

    // Option matchers
    let maybe_value: Option<i32> = Some(42);
    expect!(&maybe_value).to_be_some();
    expect!(&maybe_value).to_contain(&42);

    let empty_option: Option<i32> = None;
    expect!(&empty_option).to_be_none();
    expect!(&empty_option).not().to_be_some();

    // Result matchers
    let success_result: Result<i32, &str> = Ok(42);
    expect!(&success_result).to_be_ok();
    expect!(&success_result).to_contain_ok(&42);

    let error_result: Result<i32, &str> = Err("failed");
    expect!(&error_result).to_be_err();
    expect!(&error_result).to_contain_err(&"failed");

    // Collection matchers
    let numbers = vec![1, 2, 3, 4, 5];
    let numbers_slice = numbers.as_slice();
    expect!(numbers_slice).to_have_length(5);
    expect!(numbers_slice).to_contain(3);
    expect!(numbers_slice).to_contain_all_of(&[1, 5]);
    expect!(numbers_slice).to_equal_collection(&[1, 2, 3, 4, 5]);

    let empty_vec: Vec<i32> = vec![];
    let empty_slice = empty_vec.as_slice();
    expect!(empty_slice).to_be_empty();

    // HashMap matchers
    let mut user_scores = HashMap::new();
    user_scores.insert("Alice", 100);
    user_scores.insert("Bob", 85);

    expect!(&user_scores).to_have_length(2);
    expect!(&user_scores).to_contain_key("Alice");
    expect!(&user_scores).to_contain_entry("Bob", &85);
    expect!(&user_scores).not().to_contain_key("Charlie");

    // Report test results
    fluent_test::Reporter::summarize();
}

examples/conjugation.rs (line 48)

fn main() {
    // Enable enhanced output for this example
    config().enhanced_output(true).apply();

    println!("Testing verb conjugation in assertions\n");

    println!("=== Testing singular vs plural variable names ===");

    // Singular variable names
    let number = 42;
    let value = 42;
    let item = "hello";
    let element = [1, 2, 3];

    expect!(number).to_be_even(); // Should be "number is even"
    expect!(value).to_be_positive(); // Should be "value is positive"
    expect!(item).to_have_length(5); // Should be "item has length 5"
    expect!(&element).to_have_length(3); // Should be "element has length 3"

    // Plural variable names
    let numbers = vec![1, 2, 3, 4, 5];
    let values = vec![10, 20, 30];
    let items = ["a", "b", "c"];
    let elements = [5, 6, 7];

    expect!(numbers.as_slice()).to_have_length(5); // Should be "numbers have length 5"
    expect!(values.as_slice()).to_have_length(3); // Should be "values have length 3"
    expect!(&items).to_contain("b"); // Should be "items contain 'b'"
    expect!(&elements).to_have_length(3); // Should be "elements have length 3"

    println!("\n=== Testing logical chains ===");

    // Singular with chains
    expect!(number).to_be_greater_than(30).and().to_be_less_than(50); // Should be "number is greater than 30 AND be less than 50"

    // Plural with chains
    expect!(numbers.as_slice()).to_have_length(5).and().to_contain(3); // Should be "numbers have length 5 AND contain 3"

    // Mixed cases
    let user = "John";
    let users = ["John", "Alice", "Bob"];

    expect!(user).to_equal("John"); // Should be "user is equal to 'John'"
    expect!(&users).to_contain("Alice"); // Should be "users contain 'Alice'"

    fluent_test::Reporter::summarize();
}