Struct racetrack::tracker::Tracker

pub struct Tracker { /* fields omitted */ }

The main tracker class. Construct this in each test if possible, otherwise use a static copy. Any assertions will start with this tracker.

Constraints

• All arguments and return types must implement ToOwned to allow the function to be tracked.

Example

use racetrack::{Tracker, track_with};

let tracker = Tracker::new();

struct Tracked(Arc<Tracker>);

#[track_with(0)]
impl Tracked {
    fn tracked_method(&self, arg: String) {}
}

let tracked = Tracked(tracker.clone());
tracked.tracked_method("Test".to_string());

tracker
    .assert_that("Tracked::tracked_method")
    .was_called_once()
    .with("Test".to_string());

Methods

impl Tracker

pub fn new() -> Arc<Self>

Construct a new tracker. This returns an Arc since the library expects one everywhere. This allows for use of the tracker in multi-threaded/tasked scenarios.

pub fn assert_that(&self, item: impl Into<String>) -> Assertion

Start an assertion chain.

Arguments

• item - The key of the method for which assertions should be made. e.g. "Tracked::tracked_method"

pub fn log_call(&self, key: impl Into<String>, call_info: CallInfo)

Log a call to the tracker. This is usually used by the proc macro but can be called manually if the macro doesn't work for your use case.

Arguments

• key - The key for the method. e.g. Tracked::tracked_method
• call_info - The call info for the call. May or may not contain arguments and return values.

pub fn clear(&self)

Clear the tracker completely

pub fn print_debug(&self, item: impl Into<String>)

Print the call info for a specific method. To print the whole tracker, use debug format.

Trait Implementations

impl Debug for Tracker

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

Formats the value using the given formatter.