在 Rust 单元测试工具中，如何等待回调被调用？

Question

Please consider the following function:

pub fn shiny_function(&mut self, cb: Arc<Mutex<dyn FnMut(usize) + Send>>) {
    // Do stuff here...
}

Now, the question is, how do I write a Unit Test that checks that the callback (closure) parameter is equal to some value?

The obvious solution looks something like this:

#[test]
fn progress_cb() {
    let cut = ... // cut stands for Class Under Test
    cut.shiny_function(Arc::new(Mutex::new(move |percent| {
        // Assert here maybe? I don't know.
    })));

    cut.shiny_function();

    // Or maybe assert it somehow here? I don't know.
}

But the thing is the test finishes before the callback is even called. How can I tell the test harness to wait until the callback is called?

Answer 1

You can use the regular concurrency structs provided in the standard library to fix this issue. In this example, I use a barrier to ensure that the end of the closure is reached before the test function exits. I create the barrier with a value of 2 since wait must be called twice before the barrier is released on both threads. This behavior might not be desirable when calling shiny_function multiple times so you could also substitute another concurrency structure that only blocks in a single location.

use std::sync::{Arc, Barrier};

#[test]
fn progress_cb() {
    let cut = ... // cut stands for Class Under Test

    // Create a barrier for this thread and clone it to move into the closure
    let barrier = Arc::new(Barrier::new(2));
    let barrier_clone = barrier.clone();

    cut.shiny_function(Arc::new(Mutex::new(move |percent| {
        // Perform tests
        assert_eq!(percent, foo);

        // Once we finish we can trigger the barrier so the outer thread can continue
        barrier_clone.wait();
    })));

    // Don't exit the function until the barrier has been resolved in the callback
    barrier.wait();
}

Edit: Here is a struct you could use to if the barrier starts becoming an issue due to the closure blocking on every call and holding up later calls to shiny_function in a single test function.

use std::sync::{Arc, Mutex, Condvar};

pub struct SingleBlockingBarrier {
    target: u32,
    counter: Mutex<u32>,
    lock: Condvar,
}

impl SingleBlockingBarrier {
    pub fn new(target: u32) -> Arc<Self> {
        Arc::new(SingleBlockingBarrier {
            target,
            counter: Mutex::new(0),
            lock: Condvar::new(),
        })
    }

    pub fn signal(&self) {
        let mut guard = self.counter.lock().unwrap();
        *guard += 1;
        if *guard >= self.target {
            self.lock.notify_all();
        }
    }

    // Block until signal has been called the target number of times
    pub fn block_until_finished(&self) {
        let mut guard = self.counter.lock().unwrap();
        
        loop {
            if *guard >= self.target {
                return;
            }

            guard = self.lock.wait(guard).unwrap();
        }
    }
}

#[test]
fn progress_cb() {
    let cut = ... // cut stands for Class Under Test

    // Create a barrier for this thread and clone it to move into the closure
    let barrier = SingleBlockingBarrier::new(10);

    for _ in 0..10 {
        let barrier_clone = barrier.clone();

        cut.shiny_function(Arc::new(Mutex::new(move |percent| {
            // Perform tests
            assert_eq!(percent, foo);
    
            // Notify barrier that a worker has finished without blocking
            barrier_clone.signal();
        })));
    }

    // Block until all non-blocking barriers have been reached
    barrier.block_until_finished();
}