Fixture.hpp

Go to the documentation of this file.

#ifndef IODRIVERS_BASE_BOOST_FIXTURE_HPP
#define IODRIVERS_BASE_BOOST_FIXTURE_HPP

#include <iodrivers_base/TestStream.hpp>
#include <vector>
#include <iodrivers_base/Exceptions.hpp>

namespace iodrivers_base
{
    template<typename Driver>
    struct Fixture
    {
        typedef Driver fixture_driver_t;

        std::vector<uint8_t> packetBuffer;
        Driver driver;

        Fixture()
        {
            packetBuffer.resize(driver.MAX_PACKET_SIZE);
        }

        TestStream* getStream()
        {
            if (!driver.getMainStream())
                driver.openTestMode();
            return dynamic_cast<TestStream*>(driver.getMainStream());
        }

        std::vector<uint8_t> readPacket()
        {
            size_t size = driver.readPacket(packetBuffer.data(), packetBuffer.size());
            std::vector<uint8_t> packet;
            packet.insert(packet.end(), packetBuffer.begin(), packetBuffer.begin() + size);
            return packet;
        }

        void writePacket(std::vector<uint8_t> const& data)
        {
            writePacket(data.data(), data.size());
        }

        void writePacket(uint8_t const* buffer, size_t size)
        {
            driver.writePacket(buffer, size);
        }

        void pushDataToDriver(std::vector<uint8_t> const& data)
        {
            return getStream()->pushDataToDriver(data);
        }

        template<typename Iterator>
        void pushDataToDriver(Iterator begin, Iterator end)
        {
            std::vector<uint8_t> buffer(begin, end);
            pushDataToDriver(buffer);
        }

        std::vector<uint8_t> readDataFromDriver()
        {
            return getStream()->readDataFromDriver();
        }

        unsigned int getQueuedBytes() const
        {
            return driver.getStatus().queued_bytes;
        }
        void EXPECT_REPLY(std::vector<uint8_t> const& expectation, std::vector<uint8_t> const& reply)
        {
            getStream()->EXPECT_REPLY(expectation,reply);
        }

        void validateExpectationsAreEmpty()
        {
            if(!getStream()->expectationsAreEmpty())
                throw TestEndsWithExpectationsLeftException();
        }

        void setMockMode(bool mode)
        {
            getStream()->setMockMode(mode);
        }

        void clearExpectations()
        {
            getStream()->clearExpectations();
        }

        class GTestMockContext;
        class BoostMockContext;
    };
}

#endif