helpers.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include "rtctk/componentFramework/serviceContainer.hpp"
#include <rtctk/componentFramework/componentMetricsIf.hpp>
#include <rtctk/componentFramework/test/fakeComponentMetrics.hpp>
 
#include <iostream>
#include <memory>
#include <mutex>
 
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)
 
struct TestTopic {
    std::uint32_t sample_id;
};
 
template <typename TopicType, size_t max_reads = std::numeric_limits<size_t>::max()>
class FakeReaderBase {
public:
    template <class Rep, class Period>
    static FakeReaderBase
    MakeReader(const char* shm_name, std::chrono::duration<Rep, Period> timeout) {
        return FakeReaderBase(shm_name);
    }
 
    explicit FakeReaderBase(const char* shm_name) {
        m_sample.sample_id = 0;
        m_size = 1000;
        m_available = 500;
    }
 
    template <class Operation, class Rep, class Period>
    std::pair<std::error_code, size_t>
    Read(Operation&& op, size_t count, std::chrono::duration<Rep, Period> timeout) {
        size_t i = 0;
        for (; i < count and i < max_reads; i++) {
            m_sample.sample_id += 1;
            op(m_sample);
        }
        return {{}, i};
    }
 
    template <class Rep, class Period>
    std::pair<std::error_code, size_t>
    Skip(size_t count, std::chrono::duration<Rep, Period> timeout) {
        const auto op = [](const TopicType& sample) {};
        return Read(op, count, timeout);
    }
 
    std::error_code Reset() {
        m_size = 1000;
        m_available = 500;
        return {};
    }
 
    size_t Size() {
        return m_size;
    }
 
    size_t NumAvailable() {
        return m_available;
    }
 
    TopicType m_sample;
    size_t m_size;
    size_t m_available;
};
 
// Partially specialise the base template to have FakeReader only take one template parameter.
template <typename T>
using FakeReader = FakeReaderBase<T>;
 
// This is a partially specialised class that limits the FakeReader::Read and FakeReader::Skip
template <typename T>
using FakeReaderReadLimited = FakeReaderBase<T, 2>;
 
struct FakeServices {
    FakeServices() {
        services.Add<ComponentMetricsIf>(std::make_shared<FakeComponentMetrics>());
    }
 
    ServiceContainer& operator*() {
        return services;
    }
 
    ServiceContainer services;
};