Using a struct with Predicate

[StephanVogt]

Hi,
I am trying to write a predicate for a function, that takes a struct as a parameter. I have tried to use both .with(predicate::eq(...)) and .withf( ... ), but I am running into either a borrow checker issue, or a lifetime issue. Below is some example code, I hope someone can give me some advice on how to solve this.
In the end I want to make sure, that the struct I pass into "call_with_four" gets passed into "MyTrait.foo".

use mockall::predicate::*;
use mockall::*;

#[derive(Debug, PartialEq, PartialOrd, Clone)]
struct MyData
{
    data: u32,
}

#[automock]
trait MyTrait
{
    fn foo(&self, d: &MyData) -> u32;
}

fn call_with_four(x: &dyn MyTrait, d: &MyData) -> u32
{
    x.foo(d)
}

#[cfg(test)]
mod tests
{
    use super::*;

    #[test]
    fn test_foo()
    {
        let data = MyData { data: 42 };

        let mut mock = MockMyTrait::new();
        mock.expect_foo()
            .withf(|d| *d == &data)
            .times(1)
            .returning(|x| 42);

        assert_eq!(5, call_with_four(&mock, &data));
    }
}

[asomers]

You said you had a "either a borrow checker issue, or a lifetime issue", but you didn't provide the actual error. Would you?

[StephanVogt]

In the version with "withf" (from the example code above), I am seeing this issue:

error[E0373]: closure may outlive the current function, but it borrows `data`, which is owned by the current function
  --> src/mymod.rs:34:24
   |
34 |                 .withf(|d| d == &data)
   |                        ^^^       ---- `data` is borrowed here
   |                        |
   |                        may outlive borrowed value `data`
   |
note: function requires argument type to outlive `'static`
  --> src/mymod.rs:33:13
   |
33 | /             mock.expect_foo()
34 | |                 .withf(|d| d == &data)
   | |______________________________________^
help: to force the closure to take ownership of `data` (and any other referenced variables), use the `move` keyword
   |
34 |                 .withf(move |d| d == &data)
   |                        ++++

For more information about this error, try `rustc --explain E0373`.

A similar message is shown when I try ".with(predicate::eq(&data))":

error[E0597]: `data` does not live long enough
  --> src/mymod.rs:34:37
   |
29 |         let data = MyData { data: 42 };
   |             ---- binding `data` declared here
...
34 |                 .with(predicate::eq(&data))
   |                       --------------^^^^^-
   |                       |             |
   |                       |             borrowed value does not live long enough
   |                       argument requires that `data` is borrowed for `'static`
...
40 |     }
   |     - `data` dropped here while still borrowed

For more information about this error, try `rustc --explain E0597`.

When I try to drop the reference from data, I get this message instead:

error[E0382]: borrow of moved value: `data`
  --> src/mymod.rs:38:49
   |
29 |         let data = MyData { data: 42 };
   |             ---- move occurs because `data` has type `mymod::MyData`, which does not implement the `Copy` trait
...
34 |                 .with(predicate::eq(data))
   |                                     ---- value moved here
...
38 |             assert_eq!(5, call_with_four(&mock, &data));
   |                                                 ^^^^^ value borrowed here after move
   |
help: consider cloning the value if the performance cost is acceptable
   |
34 |                 .with(predicate::eq(data.clone()))
   |                                         ++++++++

For more information about this error, try `rustc --explain E0382`.

[asomers]

Did you try any of the suggestions that the compiler gave you?

[StephanVogt]

I did try to clone the MyData struct, and move the cloned struct into the "withf" call. That did work, but I was hoping for a "better" solution, that would work without such a clone. Cloning a simple struct like MyData works, but what if I try to pass a parameter, that does not implement Clone?

Just for reference, this is the (working) code with a cloned MyData:

use mockall::predicate::*;
use mockall::*;

#[derive(Debug, PartialEq, PartialOrd, Clone)]
struct MyData
{
    data: u32,
}

#[automock]
trait MyTrait
{
    fn foo(&self, d: &MyData) -> u32;
}

fn call_with_four(x: &dyn MyTrait, d: &MyData) -> u32
{
    x.foo(d)
}

#[cfg(test)]
mod tests
{
    use super::*;

    #[test]
    fn test_foo()
    {
        let data = MyData { data: 42 };
        let cloned_data = data.clone();

        let mut mock = MockMyTrait::new();
        mock.expect_foo()
            .withf(move |d| d == &cloned_data)
            .times(1)
            .returning(|x| 42);

        assert_eq!(5, call_with_four(&mock, &data));
    }
}

[asomers]

This isn't a Mockall problem. It's just a usual Rust lifetime issue. You need withf to own its argument. You can do that by using clone. Or you can construct a new object within the closure itself. Or you can make MyData a global constant. Or you can examine the data field by field within withf. Or you can make use of Arc<Mutex<_>>. There are lots of solutions.

[StephanVogt]

Ok, thanks for the clarification. Guess I am just a bit spoiled from working with unittesting/mocking frameworks in other languages :).