Question

In Javascript, I have two versions of a recursive function, one that runs synchronously and one that uses simple scheduling to run asynchronously. Given certain inputs, in both cases the function is expected to have an infinite execution path. I need to develop tests for these functions, specifically a test to check that the asynchronous version does not block the main thread.

I already have tests that check the output callback behavior of these functions in non-returning cases, I am only concerned about testing the blocking behavior. I can limit how long the function runs to some long but finite amount of time for testing purposes as well. I am currently using QUnit but can switch to another testing framework.

How can I test that a non-returning, asynchronous function does not block?

Edit, For Clarification

This would be a bare bones example of the function I am working with:

function a()
{
    console.log("invoked");
    setTimeout(a, 1000);
}

a();

I am intentionally misusing some threading terms in my description because I felt they most clearly expressed the problem. By not blocking the main thread, I mean that invoking the function does not prevent the scheduling and execution of other logic. I expect the function itself will be executed on the main thread but I consider the function running as long as it is scheduled for execution in the future.

Answer 1

Based on all the answers, I came up with this solution that works for my case:

testAsync("Doesn't hang", function(){
    expect(1);

    var ranToLong = false;
    var last = new Date();
    var sched = setInterval(function(){
        var now = new Date();
        ranToLong = ranToLong || (now - last) >= 50;
        last = now;
    }, 0);

    // In this case, asyncRecursiveFunction runs for a long time and 
    // returns a single value in callback
    asyncRecursiveFunction(function callback(v){
        clearInterval(sched);
        var now = new Date();
        ranToLong = ranToLong || (now - last) >= 50;
        assert.equal(ranToLong, false);
        start();
    });
});

It tests that ‘asyncRecursiveFunction’ does not hang while processing by looking at the time between another scheduled function calls.

This is really ugly and not be applicable to every case but it seems to work for me because I can restrict my function to some large set of async recursive calls so it runs for a long but not infinite time. As I mentioned in the question, I am happy proving that such cases do not block.

BTW, the actual code in question is found in gen.js. The main problem was an async reduce generator. It correctly returned a value asynchronously, but in previous versions would stall because of synchronous internal implementation.