Trying to mock std::thread::spawn

[zephod77]

I have some code that started off looking like this:

use std::thread;
pub fn foo() -> bool {
// do stuff
thread::spawn(move || bar(x,y) );
// do other stuff
true
}
fn (x, y)
{
...
}

I want to be able to unit test foo() and mock out thread::spawn() so I modified foo() like this
#[cfg(not(test))]
use std::thread as MyThread;
#[cfg(test)]
use MyThread as MyThread;

pub fn foo() -> bool
{
...
MyThread::spawn::<_,u32>(move || bar(x,y) );
...
}

and in my test code I have:
mock! {
pub JoinHandle {}
}
mock! {
pub Thread {
pub fn spawn<F: 'static, T: 'static>(f: F) -> MockJoinHandle;
}
}

test_fn() {
...
let mock_thread_ctx = MockThread::spawn_context();
mockthread_ctx.expect::<_,u32>()
.returning(|()| { MockJoinHandle::::new() } );
...
// create test object and call foo()
}

but when I run cargo test I get
test_fn panicked at MockThread::spawn(?) No matching expectation found.

I think this is because I don't have the parameter types correct. The u32 I added in response to the compiler complaints but I really don't care what type T is.

[asomers]

That's because the F parameter is a closure, which is impossible to name. And that makes it impossible to create an expectation for it. You could try this instead:

mock! {
    pub Thread {
        pub fn spawn<T: 'static>(f: Box<FnOnce() -> T> + 'static) -> JoinHandle<T>;
    }
}

then box your closure when you call spawn. But if you really don't want to box closures in production, then you can work around it by defining your mocks like this:

mock! {
    pub Thread {
        pub fn _spawn<T: 'static>(f: Box<FnOnce() -> T> + 'static) -> JoinHandle<T>;
    }
}
impl MockThread {
       pub fn spawn<F, T>(f: F) -> JoinHandle
            where F: FnOnce -> T + Send + 'static,
                  T: Send + 'static
        {
            self._spawn(Box::new(f))
        }
}

that way you can write expectations that will take a boxed closure, but your production code won't need to do the boxing.

[zephod77]

I had already tried that and it did not give me any more information; still the same error when running the test. It does compile OK. To be clear, I changed the spawn call to:

MyThread::spawn::<()>(Box::new(move || NetAgent::sub_thread(sub_skt, pub_skt));

and the expect call to:

mock_thread_ctx.expect::<()>()
    .returning(|_| { unsafe {std::mem::MaybeUninit::<JoinHandle<()>>::zeroed().assume_init()} });

Hmmm... I do get a couple of warnings from the compiler:
warning: the type std::thread::JoinHandle<()> does not permit zero-initialization()
and
"this code causes undefined behavior when executed, help: use MaybeUninit<T> instead, and only call assume_init after initialization is done"

Could that be causing the problem?

[asomers]

What do you know, it is. Usually the "undefined behavior" warnings are merely theoretical, and I assumed that you could get away with creating an invalid JoinHandle as long as you never accessed it, but in this case it does seem to be causing the problem. Try changing your returning method to .returning(|_| std::thread::spawn(|| ())). That will create a real JoinHandle, which fixes the problem for me. However, it might create a thread leak in your test code. If you can't close that leak, you may need to do some refactoring to make the product code more testable.

[zephod77]

Yes! That worked for me too.

As for the leaked thread thread, does it actually leak? The spawn docs say that:
"If the join handle is dropped, the spawned thread will implicitly be detached. ... (It is the responsibility of the program to either eventually join threads it creates or detach them; otherwise, a resource leak will result.)"
I read that as saying that a detached thread will be dropped when it is done and since our thread does nothing, its done immediately.
In any case each test runs in parallel so I assume that when each test ends, it cleans up any resources it has used which would include the leaked thread?

If you have any patience left with me, I'd like to get rid of the Box in the spawn call and use your other method that I couldn't get to work before.
First I don't understand how you can even use a Box instead of a closure. Is it that you can use a Boxed 'Thing' instead of a 'Thing' anywhere?
The _spawn function in the MockThread implementation is called on self but self is never passed in. I tried just adding Self to the paramaters but that made it worse.

[asomers]

If dropping a JoinHandle is sufficient to join the thread, then it looks like yes any leaking will be avoided. Regarding the Box, the idea behind my second method is that the manually implemented spawn method will Box its generic argument, allowing the automatically generated _spawn method to have no generic closure arguments. Regarding self, try like this:

mock! {
    pub Thread {
        pub fn _spawn<T: 'static>(f: Box<FnOnce() -> T> + 'static) -> JoinHandle<T>;
    }
}
impl MockThread {
       pub fn spawn<F, T>(f: F) -> JoinHandle
            where F: FnOnce -> T + Send + 'static,
                  T: Send + 'static
        {
            Self::_spawn(Box::new(f))
        }
}

But in fact, unless you intend to execute the closure in your matcher or returner, you can even eliminate it from the mock function, like this:

mock! {
    pub Thread {
        pub fn _spawn<T: 'static>() -> JoinHandle<T>;
    }
}
impl MockThread {
       pub fn spawn<F, T>(_f: F) -> JoinHandle
            where F: FnOnce -> T + Send + 'static,
                  T: Send + 'static
        {
            self._spawn()
        }
}

[zephod77]

I got both of those to work after fixing a couple of typos but I think I like the 1st one better as its clearer to me what is happening. I'm going to mark this thread as answered.

typos:
JoinHandle should be JoinHandle
FnOnce has to be FnOnce()
and in the second example, self._spawn() should be Self._spawn()