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?

CodePudding user response：

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();
}