mockRuntimeRepoIf.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_TEST_MOCKRUNTIMEREPOIF_HPP
#define RTCTK_COMPONENTFRAMEWORK_TEST_MOCKRUNTIMEREPOIF_HPP
 
#include <rtctk/componentFramework/runtimeRepoIf.hpp>
#include <rtctk/componentFramework/test/fakeRepositoryIf.hpp>
 
namespace rtctk::componentFramework::test {
 
class MockRuntimeRepoIf : virtual public RuntimeRepoIf {
public:
    MockRuntimeRepoIf() {
        // Setup the default behaviour to forward the calls to the fake repository.
        ON_CALL(*this, DeleteDataPoint).WillByDefault([this](const DataPointPath& path) {
            m_fakerepo.DeleteDataPoint(path);
        });
        ON_CALL(*this, GetDataPointType)
            .WillByDefault([this](const DataPointPath& path) -> const std::type_info& {
                return m_fakerepo.GetDataPointType(path);
            });
        ON_CALL(*this, GetDataPointSize).WillByDefault([this](const DataPointPath& path) {
            return m_fakerepo.GetDataPointSize(path);
        });
        ON_CALL(*this, DataPointExists).WillByDefault([this](const DataPointPath& path) {
            return m_fakerepo.DataPointExists(path);
        });
        ON_CALL(*this, GetChildren).WillByDefault([this](const DataPointPath& path) {
            return m_fakerepo.GetChildren(path);
        });
        ON_CALL(*this, SendReadRequest).WillByDefault([this](const ReadRequest& request) {
            return m_fakerepo.SendReadRequest(request);
        });
        ON_CALL(*this, SendWriteRequest).WillByDefault([this](const WriteRequest& request) {
            return m_fakerepo.SendWriteRequest(request);
        });
        ON_CALL(*this, GetServerAlias)
            .WillByDefault([this](const DataPointPath& path) -> std::string const {
                return m_server_alias_map.at(path.ToString());
            });
    }
 
    using RepositoryIf::CreateDataPoint;
    MOCK_METHOD(void,
                CreateDataPoint1,
                (const DataPointPath&, const std::type_info&, const std::string& alias),
                ());
    MOCK_METHOD(void, DeleteDataPoint, (const DataPointPath&), (override));
    MOCK_METHOD(const std::type_info&, GetDataPointType, (const DataPointPath&), (const override));
    MOCK_METHOD(std::size_t, GetDataPointSize, (const DataPointPath&), (const override));
    MOCK_METHOD(bool, DataPointExists, (const DataPointPath&), (const override));
    MOCK_METHOD((std::pair<PathList, PathList>),
                GetChildren,
                (const DataPointPath&),
                (const override));
    MOCK_METHOD(Response, SendReadRequest, (const ReadRequest&), (const override));
    MOCK_METHOD(Response, SendWriteRequest, (const WriteRequest&), (override));
 
    MOCK_METHOD(std::string, GetServerAlias, (const DataPointPath&), (const override));
    MOCK_METHOD(Response, SendSubscribeRequest, (const SubscribeRequest&), (const override));
    MOCK_METHOD(Response, SendUnsubscribeRequest, (const UnsubscribeRequest&), (const override));
 
    void CreateDataPoint(const DataPointPath& path, const std::type_info& type) override {
        CreateDataPoint(path, type, "");
    }
 
    void CreateDataPoint(const DataPointPath& path,
                         const std::type_info& type,
                         const std::string& alias) override {
        m_server_alias_map[path.ToString()] = alias;
        m_fakerepo.CreateDataPoint(path, type);
        this->CreateDataPoint1(path, type, alias);
    }
 
private:
    FakeRepositoryIf m_fakerepo;
    std::map<std::string, std::string> m_server_alias_map;
};
 
}  // namespace rtctk::componentFramework::test
 
#endif  // RTCTK_COMPONENTFRAMEWORK_TEST_MOCKRUNTIMEREPOIF_HPP