Occasional boost::asio tcp server failure run on localhost when using valgrind - c++

Question

I'm testing my application which contains a TCP client. To test that I've created a simple TCP server based on boost examples. The problem is that once each ~5 test invocations with valgrind the test fails to connect to local server. When not using valgrind all the tests pass on each invocation.
I can't find the cause of it. The server implementation:
class arcturus_mock
{
private:
boost::asio::io_service ios;
boost::asio::ip::tcp::socket socket;
boost::asio::ip::tcp::acceptor acceptor;
std::thread t;
public:
arcturus_mock(short port)
: acceptor(ios,
boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port))
, socket(ios)
{
do_accept();
}
// A new thread is created to not to block on calling
// io_service::run function
void run()
{
t = std::thread([&ios = this->ios]() { ios.run(); });
}
void stop()
{
ios.stop();
t.join();
}
private:
void do_accept()
{
acceptor.async_accept(socket, [this](boost::system::error_code ec) {
if (!ec)
std::make_shared<arcturus_mock_session>(std::move(socket))
->start();
do_accept();
});
}
};
And the corresponding session:
class arcturus_mock_session : public std::enable_shared_from_this<arcturus_mock_session>
{
private:
boost::asio::ip::tcp::socket socket;
char data[1024];
public:
arcturus_mock_session(boost::asio::ip::tcp::socket &&used_socket)
: socket(std::move(used_socket))
{
}
void start()
{
using boost::asio::async_write;
async_write( ...
}
};
I run the tests using Catch2 framework. This is how the test case looks like:
TEST_CASE(" ... ")
{
arcturus_mock mock(1050);
mock.run();
SECTION(" ... ")
{
client c;
// That throws sometimes
REQUIRE_NOTHROW(c.connect_and_handle("localhost", 1050));
}
mock.stop();
}
Could the problem be caused by the thread which won't manage to create and start the server by the time the client connects to it?

Answer 1

It's a race condition.
When the server thread starts, there is not necessarily any work to be done (async_accept may not happen quickly enough). This means run() simply exits immediately, and the server doesn't run.
Either make async_accept precede the thread launch or use a io_service::work to keep the service occupied.