Assert Timings

[StefanSchoof]

I have a scenario where the time between calls is something I like to test.

I want to send a code over gpio pins and the time how long a high and how long a low signal is the key thing. Can I use mockall for this purpose? If yes, can someone point me to the docs and/or an example.

[asomers]

The timing won't be precise, but you should be able to do it by inserting sleeps into the returner. Like this:

let mut mock = MockMyThing::default();
mock.expect_go_high()
    .returning(|| {
        std::thread::sleep(std::time::Duration::from_millis(10));
        Ok(())
    })

Or are you saying you want to assert that the code under test slept for a certain amount of time? If so, you could try something like this:

let mut high_time = None;
let mut low_time = None;
let mut mock = MockMyThing();
mock.expect_go_high()
    .returning(|| {
        high_time = Some(std::time::Instant::now());
        Ok(())
    });
mock.expect_go_low()
    .returning(|| {
        low_time = Some(std::time::Instant::now());
        Ok(())
    });
code_under_test(mock);
assert_ge(high_time.unwrap() - low_time.unwrap(), std::time::Duration::from_millis(10));

[StefanSchoof]

Thanks, the seconds things is want I want to do.

[StefanSchoof]

Today I found time to use this code:

        let mut high_time = None;
        let mut mock = MockGpioPin::default();
        mock.expect_set().returning(|_v| {
            high_time = Some(std::time::Instant::now());
            Ok(())
        });
        send_to_pin(&State::On, mock);
        assert_eq!(
            high_time.unwrap() - std::time::Instant::now(),
            std::time::Duration::from_millis(10),
        );

this will get me

error[E0373]: closure may outlive the current function, but it borrows `high_time`, which is owned by the current function
  --> src/main.rs:63:37
   |
63 |         mock.expect_set().returning(|_v| {
   |                                     ^^^^ may outlive borrowed value `high_time`
64 |             high_time = Some(std::time::Instant::now());
   |             --------- `high_time` is borrowed here
   |
note: function requires argument type to outlive `'static`
  --> src/main.rs:63:9
   |
63 | /         mock.expect_set().returning(|_v| {
64 | |             high_time = Some(std::time::Instant::now());
65 | |             Ok(())
66 | |         });
   | |__________^
help: to force the closure to take ownership of `high_time` (and any other referenced variables), use the `move` keyword
   |
63 |         mock.expect_set().returning(move |_v| {
   |                                     ++++

error[E0503]: cannot use `high_time` because it was mutably borrowed
  --> src/main.rs:69:13
   |
63 |           mock.expect_set().returning(|_v| {
   |           -                           ---- borrow of `high_time` occurs here
   |  _________|
   | |
64 | |             high_time = Some(std::time::Instant::now());
   | |             --------- borrow occurs due to use of `high_time` in closure
65 | |             Ok(())
66 | |         });
   | |__________- argument requires that `high_time` is borrowed for `'static`
...
69 |               high_time.unwrap() - std::time::Instant::now(),
   |               ^^^^^^^^^ use of borrowed `high_time`

Some errors have detailed explanations: E0373, E0503.
For more information about an error, try `rustc --explain E0373`.

Is there something I miss, to get this code working?

(sorry if this is a dump rust question, but I have not much rust experience)

[asomers]

This is a common Rust problem, and there are multiple ways to solve it. Basically, your closure has 'static lifetime, so it can't borrow anything that doesn't. Also, the closure is Send (unless you use returning_st), so it can't borrow anything that isn't. Here is one solution:

        let high_time = Arc::new(Mutex::new(None));
        let ht2 = high_time.clone();
        let mut mock = MockGpioPin::default();
        mock.expect_set().returning(move |_v| {
            ht2.lock().unwrap() = Some(std::time::Instant::now());
            Ok(())
        });
        send_to_pin(&State::On, mock);
        assert_eq!(
            high_time.lock().unwrap().unwrap() - std::time::Instant::now(),
            std::time::Duration::from_millis(10),
        );