A race condition in a custom implementation of recursive mutex

UPD: It seems that the problem which I explain below is non-existent. I cannot reproduce it in a week already, I started suspecting that it was caused by some bugs in a compiler or corrupted memory because it is not reproducing anymore.

I tried to implement my own recursive mutex in C++, but for some reason, it fails. I tried to debug it, but I stuck. (I know that there are recursive mutex in std, but I need a custom implementation in a project where STL is not available; this implementation was just a check of an idea). I haven't thought about efficiency yet, but I don't understand why my straightforward implementation doesn't work.

First of all, here's the implementation of the RecursiveMutex:

class RecursiveMutex
{
    std::mutex critical_section;
    std::condition_variable cv;
    std::thread::id id;
    int recursive_calls = 0;

public:
    void lock() {
        auto thread = std::this_thread::get_id();
        std::unique_lock<std::mutex> lock(critical_section);

        cv.wait( lock, [this, thread]() {
            return id == thread || recursive_calls == 0;
        });

        ++recursive_calls;
        id = thread;
    }

    void unlock() {
        std::unique_lock<std::mutex> lock( critical_section );
        --recursive_calls;
        if( recursive_calls == 0 ) {
            lock.unlock();
            cv.notify_all();
        }
    }
};

The failing test is straightforward, it just runs two threads, both of them are locking and unlocking the same mutex (the recursive nature of the mutex is not tested here). Here it is:

std::vector<std::thread> threads;

void initThreads( int num_of_threads, std::function<void()> func )
{
    threads.resize( num_of_threads );
    for( auto& thread : threads )
    {
        thread = std::thread( func );
    }
}

void waitThreads()
{
    for( auto& thread : threads )
    {
        thread.join();
    }
}

void test () {
    RecursiveMutex mutex;

    while (true) {
        int count = 0;
        initThreads(2, [&mutex] () {
            for( int i = 0; i < 100000; ++i ) {
                try {
                    mutex.lock();
                    ++count;
                    mutex.unlock();
                }
                catch (...) {
                    // Extremely rarely.
                    // Exception is "Operation not permited"
                    assert(false);
                }
            }
        });

        waitThreads();
        // Happens often
        assert(count == 200000);
    }  
}

In this code I have two kinds of errors:

1. Extremely rarely I get an exception in RecursiveMutex::lock() which contains message "Operation not permitted" and is thrown from cv.wait. As far as I understand, this exception is thrown when wait is called on a mutex which is not owned by the thread. At the same time, I lock it just above calling the wait so this cannot be the case.

2. In most situations I just get a message into console "terminate called without an active exception".

My main question is what the bug is, but I'll also be happy to know how to debug and provoke race condition in such a code in general.

P.S. I use Desktop Qt 5.4.2 MinGW 32 bit.