utils.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_libdaq_test
 * @copyright 2022 ESO - European Southern Observatory
 *
 * @brief Defines shared test utilities.
 */
#ifndef OCM_DAQ_TEST_UTILS_HPP_
#define OCM_DAQ_TEST_UTILS_HPP_
// GCOVR_EXCL_START
#include <chrono>
#include <thread>
 
#include <boost/asio/io_context.hpp>
#include <boost/asio/post.hpp>
#include <gtest/gtest.h>
 
/**
 * Executes io_ctx::poll until @a pred returns true or it times out.
 */
template <class Predicate>
void MakeTestProgressUntil(boost::asio::io_context& io_ctx,
                           Predicate&& pred,
                           std::chrono::milliseconds timeout = std::chrono::seconds(3)) {
    auto until = std::chrono::steady_clock::now() + timeout;
 
    while (std::chrono::steady_clock::now() < until) {
        io_ctx.restart();
        io_ctx.poll();
        if (pred()) {
            return;
        }
    }
    FAIL() << "MakeTestProgressUntil timed out";
}
 
/**
 * Test helper that progress the test by executing pending jobs and optionally wait for
 * a future to be ready.
 *
 * @ingroup daq_ocm_libdaq_test
 */
template <class Future = void>
void MakeTestProgress(boost::asio::io_context& io_ctx, Future* fut = nullptr) {
    using namespace std::chrono;
    using namespace ::testing;
 
    auto work = std::make_unique<boost::asio::io_context::work>(io_ctx);
 
    // Run asio in its own thread so we can independenty wait for future
    std::thread t([&]() {
        try {
            io_ctx.restart();
            io_ctx.run();
            // The run() function blocks until all work has finished and there are no more handlers
            // to be dispatched or until the io_context has been stopped.
        } catch (std::exception const& e) {
            FAIL() << "MakeTestProgress caught std::exception: " << e.what();
        } catch (...) {
            FAIL() << "MakeTestProgress caught unknown exception";
        }
    });
    std::this_thread::yield();
    if constexpr (!std::is_same_v<Future, void>) {
        if (fut) {
            EXPECT_NO_THROW(fut->wait_for(boost::chrono::seconds(3)));
        }
        boost::asio::post(io_ctx, [&] {
            // remove work so that asio::io_context::run returns
            work.reset();
            // Explicitly stop io_ctx if future is ready. I.e. even if there are handlers pending
            // we want to stop here since the caller might set up next step in the test.
            io_ctx.stop();
        });
        t.join();
        if (fut) {
            ASSERT_TRUE(fut->is_ready()) << "Future is not ready after 1s, aborting";
        }
    } else {
        // remove work so that asio::io_context::run returns
        boost::asio::post(io_ctx, [&] { work.reset(); });
        t.join();
    }
}
 
// GCOVR_EXCL_STOP
#endif  // #ifndef OCM_DAQ_TEST_UTILS_HPP_