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/fakeRepositorySubscriber.hpp>
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
namespace rtctk::componentFramework::test {
 
class MockRuntimeRepoIf : virtual public RuntimeRepoIf, virtual public FakeRepositorySubscriber {
public:
    MockRuntimeRepoIf() {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
        // Setup the default behaviour to forward the calls to the fake repository.
        using testing::A;
        ON_CALL(*this, CreateDataPoint(A<const DataPointPath&>(), A<const std::type_info&>()))
            .WillByDefault([this](const DataPointPath& path, const std::type_info& type) {
                RuntimeRepoIf::CreateDataPoint(path, type);
            });
        ON_CALL(*this,
                CreateDataPoint(
                    A<const DataPointPath&>(), A<const std::type_info&>(), A<const std::string&>()))
            .WillByDefault([this](const DataPointPath& path,
                                  const std::type_info& type,
                                  const std::string& server_alias) {
                RuntimeRepoIf::CreateDataPoint(path, type, server_alias);
            });
        ON_CALL(*this, DeleteDataPointLegacy).WillByDefault([this](const DataPointPath& path) {
            FakeRepositorySubscriber::DeleteDataPointLegacy(path);
        });
        ON_CALL(*this, GetDataPointTypeLegacy)
            .WillByDefault([this](const DataPointPath& path) -> const std::type_info& {
                return FakeRepositorySubscriber::GetDataPointTypeLegacy(path);
            });
        ON_CALL(*this, GetDataPointSizeLegacy).WillByDefault([this](const DataPointPath& path) {
            return FakeRepositorySubscriber::GetDataPointSizeLegacy(path);
        });
        ON_CALL(*this, DataPointExistsLegacy).WillByDefault([this](const DataPointPath& path) {
            return FakeRepositorySubscriber::DataPointExistsLegacy(path);
        });
        ON_CALL(*this, GetChildrenLegacy).WillByDefault([this](const DataPointPath& path) {
            return FakeRepositorySubscriber::GetChildrenLegacy(path);
        });
        ON_CALL(*this, SendReadRequest).WillByDefault([this](const ReadRequest& request) {
            return FakeRepositorySubscriber::SendReadRequest(request);
        });
        ON_CALL(*this, SendWriteRequest).WillByDefault([this](const WriteRequest& request) {
            return FakeRepositorySubscriber::SendWriteRequest(request);
        });
        ON_CALL(*this, SendSubscribeRequest).WillByDefault([this](const SubscribeRequest& request) {
            return FakeRepositorySubscriber::SendSubscribeRequest(request);
        });
        ON_CALL(*this, SendUnsubscribeRequest)
            .WillByDefault([this](const UnsubscribeRequest& request) {
                return FakeRepositorySubscriber::SendUnsubscribeRequest(request);
            });
        ON_CALL(*this, GetServerAlias).WillByDefault([this](const DataPointPath& path) {
            return RuntimeRepoIf::GetServerAlias(path);
        });
#pragma GCC diagnostic pop
    }
 
    using RuntimeRepoIf::CreateDataPoint;
 
    MOCK_METHOD(void, CreateDataPoint, (const DataPointPath&, const std::type_info&), (override));
    MOCK_METHOD(void,
                CreateDataPoint,
                (const DataPointPath&, const std::type_info&, const std::string&),
                (override));
    MOCK_METHOD(void, DeleteDataPointLegacy, (const DataPointPath&), (override));
    MOCK_METHOD(const std::type_info&,
                GetDataPointTypeLegacy,
                (const DataPointPath&),
                (const override));
    MOCK_METHOD(std::size_t, GetDataPointSizeLegacy, (const DataPointPath&), (const override));
    MOCK_METHOD(bool, DataPointExistsLegacy, (const DataPointPath&), (const override));
    MOCK_METHOD((std::pair<PathList, PathList>),
                GetChildrenLegacy,
                (const DataPointPath&),
                (const override));
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    MOCK_METHOD(Response, SendReadRequest, (const ReadRequest&), (const override));
    MOCK_METHOD(Response, SendWriteRequest, (const WriteRequest&), (override));
    MOCK_METHOD(Response, SendSubscribeRequest, (const SubscribeRequest&), (const override));
    MOCK_METHOD(Response, SendUnsubscribeRequest, (const UnsubscribeRequest&), (const override));
    MOCK_METHOD(std::string, GetServerAlias, (const DataPointPath&), (const override));
#pragma GCC diagnostic pop
 
    MOCK_METHOD(void, CreateDataPointRequest, (const DataPointPath&));
    MOCK_METHOD(void, DeleteDataPointRequest, (const DataPointPath&));
    MOCK_METHOD(void, GetDataPointTypeRequest, (const DataPointPath&), (const));
    MOCK_METHOD(void, GetDataPointSizeRequest, (const DataPointPath&), (const));
    MOCK_METHOD(void, DataPointExistsRequest, (const DataPointPath&), (const));
    MOCK_METHOD(void, ReceivedReadRequest, (const DataPointPath&), (const));
    MOCK_METHOD(void, ReceivedWriteRequest, (const DataPointPath&));
 
protected:
    BatchResponse ProcessRequests(const RequestList& requests) override {
        for (const auto& request : requests) {
            if (request.type() == typeid(detail::CreateRequest<std::byte>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<std::byte>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::CreateRequest<char>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<char>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::CreateRequest<RtcBool>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<RtcBool>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::CreateRequest<RtcInt8>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<RtcInt8>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::CreateRequest<RtcInt16>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<RtcInt16>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::CreateRequest<RtcInt32>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<RtcInt32>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::CreateRequest<RtcInt64>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<RtcInt64>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::CreateRequest<RtcUInt8>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<RtcUInt8>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::CreateRequest<RtcUInt16>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<RtcUInt16>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::CreateRequest<RtcUInt32>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<RtcUInt32>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::CreateRequest<RtcUInt64>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<RtcUInt64>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::CreateRequest<RtcFloat>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<RtcFloat>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::CreateRequest<RtcDouble>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<RtcDouble>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::CreateRequest<RtcString>)) {
                const auto& req = std::any_cast<const detail::CreateRequest<RtcString>&>(request);
                CreateDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::DeleteRequest)) {
                const auto& req = std::any_cast<const detail::DeleteRequest&>(request);
                DeleteDataPointRequest(req.path);
            } else if (request.type() == typeid(detail::ReadMetaDataRequest)) {
                const auto& req = std::any_cast<const detail::ReadMetaDataRequest&>(request);
                GetDataPointTypeRequest(req.path);
                GetDataPointSizeRequest(req.path);
            } else if (request.type() == typeid(detail::ExistsRequest)) {
                const auto& req = std::any_cast<const detail::ExistsRequest&>(request);
                DataPointExistsRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<std::byte>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<std::byte>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<char>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<char>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<RtcBool>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<RtcBool>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<RtcInt8>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<RtcInt8>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<RtcInt16>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<RtcInt16>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<RtcInt32>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<RtcInt32>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<RtcInt64>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<RtcInt64>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<RtcUInt8>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<RtcUInt8>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<RtcUInt16>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<RtcUInt16>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<RtcUInt32>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<RtcUInt32>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<RtcUInt64>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<RtcUInt64>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<RtcFloat>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<RtcFloat>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<RtcDouble>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<RtcDouble>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::ReadRequest<RtcString>)) {
                const auto& req = std::any_cast<const detail::ReadRequest<RtcString>&>(request);
                ReceivedReadRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<std::byte>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<std::byte>&>(request);
                ReceivedWriteRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<char>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<char>&>(request);
                ReceivedWriteRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<RtcBool>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<RtcBool>&>(request);
                ReceivedWriteRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<RtcInt8>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<RtcInt8>&>(request);
                ReceivedWriteRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<RtcInt16>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<RtcInt16>&>(request);
                ReceivedWriteRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<RtcInt32>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<RtcInt32>&>(request);
                ReceivedWriteRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<RtcInt64>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<RtcInt64>&>(request);
                ReceivedWriteRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<RtcUInt8>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<RtcUInt8>&>(request);
                ReceivedWriteRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<RtcUInt16>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<RtcUInt16>&>(request);
                ReceivedWriteRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<RtcUInt32>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<RtcUInt32>&>(request);
                ReceivedWriteRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<RtcUInt64>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<RtcUInt64>&>(request);
                ReceivedWriteRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<RtcFloat>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<RtcFloat>&>(request);
                ReceivedWriteRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<RtcDouble>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<RtcDouble>&>(request);
                ReceivedWriteRequest(req.path);
            } else if (request.type() == typeid(detail::WriteRequest<RtcString>)) {
                const auto& req = std::any_cast<const detail::WriteRequest<RtcString>&>(request);
                ReceivedWriteRequest(req.path);
            }
        }
        return FakeRepositorySubscriber::ProcessRequests(requests);
    }
};
 
}  // namespace rtctk::componentFramework::test
 
#endif  // RTCTK_COMPONENTFRAMEWORK_TEST_MOCKRUNTIMEREPOIF_HPP