Question

I want to write unit tests for a subroutine in perl. The subroutine is using multiple threads to do its tasks. So, it first creates some threads and then it waits for them to join.

The problem is that our unit tests run on a server which is not able to run multi-threaded tests, so I need to somehow mock out the thread behavior. Basically I want to override the threads create and join functions such that its not threaded anymore. Any pointers how can I do that and test the code ?

Edit : The server fails to run the threaded code for the following reason:

Devel::Cover does not yet work with threads

Answer 1

Update: this answer doesn’t solve the OP’s problem as described in the edited question, but it might be useful to someone.

Perl threads are an interpreter emulation, not an operating system feature. So, they should work on any platform. If your testing server doesn’t support threads, it’s probably for one of these reasons:

1. Your version of Perl is very old.
2. Perl was compiled without thread support.
3. Your testing framework wasn’t created with threaded code in mind.

The first two could be easily rectified by updating your environment. However, I suspect yours is the third issue.

I don’t think you should solve this by mocking the thread behavior. This changes the original code too much to be a valid test. And it would be a significant amount of work anyway, so why not direct that effort toward getting a threaded test working?

The exact issues depend on your code, but probably the issue is that your subroutine starts a thread and then returns, with the thread still running. Then your test framework runs the sub over and over, accumulating a whole bunch of concurrent threads.

In that case, all you need is a wrapper sub that calls the sub you are testing, and then blocks until the threads are complete. This should be fairly simple. Take a look at threads->list() to see how you can detect running threads. Just have a loop that waits until the threads in question are no longer running before exiting the wrapper sub.

Here is a simple complete example demonstrating a wrapper sub:

#!usr/bin/perl
use strict;
use warnings;
use threads;

sub sub_to_test {

    threads->create(sub { sleep 5; print("Thread done\n"); threads->detach() });
    return "Sub done\n";
}

sub wrapper {
    #Get a count of the running threads.
    my $original_running_threads = threads->list(threads::running);

    my @results = sub_to_test(@_);

    #block until the number of running threads is the same as when we started.
    sleep 1 while (threads->list(threads::running) > $original_running_threads);

    return @results;
}

print wrapper;