helpers.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <condition_variable>
#include <functional>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include <rtctk/componentFramework/componentMetricsIf.hpp>
#include <rtctk/componentFramework/dataPointRecordingUnit.hpp>
#include <rtctk/componentFramework/eventServiceIf.hpp>
#include <rtctk/componentFramework/recordingUnit.hpp>
#include <rtctk/componentFramework/test/fakeComponentMetrics.hpp>
#include <rtctk/componentFramework/test/fakeOldbIf.hpp>
#include <rtctk/componentFramework/test/fakeRuntimeRepoIf.hpp>
#include <rtctk/componentFramework/test/mockRepository.hpp>
 
#include <iostream>
#include <memory>
#include <mutex>
#include <stdexcept>
 
using ::testing::_;           // NOLINT(google-global-names-in-headers)
using ::testing::InSequence;  // NOLINT(google-global-names-in-headers)
using ::testing::NiceMock;    // NOLINT(google-global-names-in-headers)
using ::testing::Return;      // NOLINT(google-global-names-in-headers)
using ::testing::Sequence;    // NOLINT(google-global-names-in-headers)
 
using namespace rtctk::componentFramework;        // NOLINT(google-global-names-in-headers)
using namespace rtctk::componentFramework::test;  // NOLINT(google-global-names-in-headers)
 
extern void* rec_ptr;
 
template <class... T>
class FakeRecorder : public DataRecorder<T...> {
public:
    using ColumnDescription = typename DataRecorder<T...>::ColumnDescription;
 
    explicit FakeRecorder(const ColumnDescription& columns,
                          const std::array<bool, sizeof...(T)>& disable = {})
        : DataRecorder<T...>(columns, disable) {
        rec_ptr = this;
    }
 
    ~FakeRecorder() = default;
 
    MOCK_METHOD(void, Open, (const std::filesystem::path&), (override));
 
    MOCK_METHOD(void, SetColumnLength, (size_t, size_t));
 
    MOCK_METHOD(void, Close, (), (override));
 
    MOCK_METHOD(void, Write, (const std::tuple<T...>&), (override));
 
    std::string DefaultFileExtension() override {
        return std::string{".data"};
    }
};
 
class MockEventPublisher;
class MockEventSubscriber;
class MockEventService;
 
class MockEventPublisher : public EventPublisherIf {
public:
    friend MockEventService;
 
    void Publish(const JsonPayload& sample) override {
    }
 
private:
    explicit MockEventPublisher(const std::string& topic) {
    }
};
 
class MockEventSubscriber : public EventSubscriberIf {
public:
    friend MockEventService;
 
    void Subscribe(std::function<void(const JsonPayload&)> cb) override {
        auto lock = std::scoped_lock(callback_lock);
        callback = cb;
        SubscribeMock(cb);
    }
    MOCK_METHOD(void, SubscribeMock, (std::function<void(const JsonPayload&)>), ());
    MOCK_METHOD(void, Unsubscribe, (), (override));
 
    std::function<void(const JsonPayload&)> GetCallback() {
        auto lock = std::scoped_lock(callback_lock);
        auto copy = callback;
        return copy;
    };
 
private:
    std::function<void(const JsonPayload&)> callback;
    std::mutex callback_lock;
 
    explicit MockEventSubscriber(const std::string& topic) {
    }
};
 
class MockEventService : public EventServiceIf {
public:
    MockEventService() = default;
 
    std::unique_ptr<EventPublisherIf> MakePublisher(const std::string& topic) override {
        pub[topic] = new MockEventPublisher(topic);
        return std::unique_ptr<MockEventPublisher>(pub.at(topic));
    }
 
    std::unique_ptr<EventSubscriberIf> MakeSubscriber(const std::string& topic) override {
        sub[topic] = new MockEventSubscriber(topic);
        return std::unique_ptr<MockEventSubscriber>(sub.at(topic));
    }
 
    std::map<std::string, MockEventPublisher*> pub;
    std::map<std::string, MockEventSubscriber*> sub;
};
 
struct FakeServices {
    FakeServices() {
        services.Add<RuntimeRepoIf>(std::make_shared<NiceMock<test::FakeRuntimeRepoIf>>());
        services.Add<OldbIf>(std::make_shared<NiceMock<test::FakeOldbIf>>());
        services.Add<ComponentMetricsIf>(std::make_shared<FakeComponentMetrics>());
        // cppcheck-suppress useInitializationList
        es = std::make_shared<MockEventService>();
        services.Add<EventServiceIf>(es);
    }
 
    ServiceContainer& operator*() {
        return services;
    }
 
    MockEventService& Es() {
        return *es;
    }
 
    ServiceContainer services;
    std::shared_ptr<MockEventService> es;
};
 
inline void AwaitState(RecordingUnit& unit,
                       RecordingUnit::State state,
                       std::chrono::milliseconds timeout = std::chrono::milliseconds{5000}) {
    ASSERT_NO_THROW({
        std::mutex state_reached_mutex;
        auto state_reached = std::make_shared<std::condition_variable>();
        std::chrono::steady_clock::time_point until = std::chrono::steady_clock::now() + timeout;
        RecordingUnit::State current_state = unit.GetState();
 
        std::function<void(const std::string& unit_id, const RecordingUnit::State&)> unblock_wait =
            [=](const std::string& name, const RecordingUnit::State& new_state) {
                if (new_state == state) {
                    state_reached->notify_one();
                }
            };
        auto registration = unit.Connect(unblock_wait);
        while (current_state != state) {
            if (std::chrono::steady_clock::now() > until) {
                throw std::runtime_error("Timeout!");
            }
            auto lock = std::unique_lock(state_reached_mutex);
            state_reached->wait_until(lock, until, [&]() { return unit.GetState() == state; });
            current_state = unit.GetState();
        }
        ASSERT_EQ(current_state, state);
        registration.disconnect();
    });
}
 
ACTION(Throw) {
    CII_THROW(RtctkException, "Some Exception");
}