Calling a function which is inside a Thread - c++

Question

I was doing Unit Testing and finding code coverage using gtest and lcov.
My function is
void MyClass::MyFunction(const std::string& argument1, const std::string& argument2) {
std::thread([this, argument1, argument2]() {
std::unique_lock<std::mutex> live_lock_(live_mutex_);
int64_t time_stamp = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
int64_t time_to_live = myList[argument1] - (time_stamp % myList[argument1]);
cond_var_.wait_for(time_to_live_lock_, std::chrono::milliseconds(time_to_live), [this, argument1] { return cond_var_status_[argument1]; });
if (message_master_.find(argument1) != message_master_.end()) {
//something
}
}).detach();
std::cout<< "end line is executed"<<std::endl; }
and my test function is
TEST(test, test1) {
Myclass testObj;
testObj.MyFunction("arg1", "arg2");
ASSERT_EQ("","");
};
When I run the test, all codes except those inside thread are executed.
So is there any solution to call those codes inside thread too?

Answer 1

How do you know none of those lines are being executed?
I would suggest making a test program, compiling with -g and -Wall, then using gdb to make sure a thread is actually being created. If it is, step through the code.
It could be that the compiler gets rid of code it thinks is doing nothing.

Answer 2

This is how I would test it (I modified the code a little, but in principle it is the same thing. All the globals shall be moved to MyClass most probably):
#include <atomic>
#include <condition_variable>
#include <map>
#include <mutex>
#include <thread>
std::mutex time_to_live_mutex_;
std::map<std::string, int64_t> myList;
std::map<std::string, bool> cond_var_status_;
std::map<std::string, std::string> incoming_message_master_;
std::condition_variable cond_var_;
std::atomic_bool something_happened{false};
void foo(const std::string& argument1, const std::string& argument2) {
std::thread([argument1, argument2]() {
std::unique_lock<std::mutex> time_to_live_lock_(time_to_live_mutex_);
int64_t time_stamp = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
int64_t time_to_live = myList[argument1] - (time_stamp % myList[argument1]);
cond_var_.wait_for(time_to_live_lock_, std::chrono::milliseconds(time_to_live), [argument1] { return cond_var_status_[argument1]; });
if (incoming_message_master_.find(argument1) != incoming_message_master_.end()) {
//something
something_happened = true;
}
}).detach();
}
TEST(TestFoo, testing_foo_thread) {
int64_t timeout = 10000;
myList["bar"] = timeout; // so that cond variable waits long time
cond_var_status_["bar"] = false; // so that cond variable returns false at first try
incoming_message_master_["bar"] = std::string("42"); // so that something can happen
foo("bar", "fiz");
ASSERT_FALSE(something_happened); // cond variable is still waiting at this point
{
std::unique_lock<std::mutex> time_to_live_lock_(time_to_live_mutex_);
cond_var_status_["bar"] = true; // so that cond variable returns eventually
}
while(!something_happened && timeout > 0) {
std::this_thread::sleep_for(std::chrono::milliseconds(10));
timeout -= 10;
}
ASSERT_TRUE(something_happened); // cond variable is not waiting, should have returned
}