test: add integration_test.flash_tested

CMakeLists.txt

@@ -5,12 +5,19 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
 endif()
 
 option(CMAKE_COMPILE_WARNING_AS_ERROR "Enable warnings-as-error" ON)
+option(HALST_BUILD_TESTS "Enable building the tests" Off)
 option(HALST_INCLUDE_DEFAULT_INIT "Include default initialization code; turn off when providing custom initialization" ON)
 option(HALST_BUILD_EXAMPLES "Enable build of the examples" OFF)
 option(HALST_BUILD_EXAMPLES_FREERTOS "Enable build of the FreeRTOS example" OFF)
 set(HALST_XML_GPIO "" CACHE STRING "XML GPIO table")
 set(HALST_XML_STM32 "" CACHE STRING "XML STM32 table")
 
+if (HALST_BUILD_TESTS)
+    # CTest cannot be included before the first project() statement, but Embedded Infastructure
+    # Library needs to see that test utilities need to be built.
+    set(BUILD_TESTING On)
+endif()
+
 if (HALST_STANDALONE)
     set(EMIL_INCLUDE_FREERTOS ${HALST_BUILD_EXAMPLES_FREERTOS})
 
@@ -40,6 +47,11 @@ else()
     set(HALST_EXCLUDE_FROM_ALL "EXCLUDE_FROM_ALL")
 endif()
 
+if (HALST_BUILD_TESTS)
+    include(CTest)
+    emil_enable_testing()
+endif()
+
 add_subdirectory(st)
 add_subdirectory(hal_st)
 add_subdirectory(hal_st_lwip)

CMakePresets.json

@@ -17,7 +17,8 @@
       "inherits": "defaults",
       "cacheVariables": {
         "CMAKE_CONFIGURATION_TYPES": "Debug;Release;RelWithDebInfo;MinSizeRel",
-        "EMIL_BUILD_ECHO_COMPILERS": true
+        "EMIL_BUILD_ECHO_COMPILERS": true,
+        "HALST_BUILD_TESTS": true
       },
       "generator": "Ninja Multi-Config"
     },
@@ -26,15 +27,17 @@
       "displayName": "Configuration for Host Tooling and Tests, Single Config Generator, Debug",
       "inherits": "defaults",
       "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug"
+        "CMAKE_BUILD_TYPE": "Debug",
+        "HALST_BUILD_TESTS": true
       }
     },
     {
       "name": "host-single-MinSizeRel",
       "displayName": "Configuration for Host Tooling and Tests, Single Config Generator, MinSizeRel",
       "inherits": "defaults",
       "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "MinSizeRel"
+        "CMAKE_BUILD_TYPE": "MinSizeRel",
+        "HALST_BUILD_TESTS": true
       }
     },
     {

integration_test/CMakeLists.txt

@@ -1,3 +1,4 @@
 add_subdirectory(logic)
+add_subdirectory(flash_tested)
 add_subdirectory(tested)
 add_subdirectory(tester)

integration_test/flash_tested/CMakeLists.txt

@@ -0,0 +1,19 @@
+add_library(integration_test.flash_tested ${HALST_EXCLUDE_FROM_ALL})
+
+target_include_directories(integration_test.flash_tested PUBLIC
+    "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/../..>"
+)
+
+protocol_buffer_echo_cpp(integration_test.flash_tested Flash.proto)
+
+target_sources(integration_test.flash_tested PRIVATE
+    Flash.cpp
+    Flash.hpp
+)
+
+target_link_libraries(integration_test.flash_tested PUBLIC
+    services.util
+    protobuf.echo
+)
+
+add_subdirectory(test)

integration_test/flash_tested/Flash.cpp

@@ -0,0 +1,149 @@
+#include "integration_test/flash_tested/Flash.hpp"
+#include <utility>
+
+namespace application
+{
+    Flash::Flash(services::Echo& echo, hal::Flash& flash)
+        : flash::Flash(echo)
+        , flashResult(echo)
+        , flash(flash)
+    {}
+
+    void Flash::Read(uint32_t address, uint32_t size)
+    {
+        flash.ReadBuffer(infra::Head(infra::MakeRange(buffer), size), address, [this, size]()
+            {
+                flashResult.RequestSend([this, size]()
+                    {
+                        flashResult.ReadDone(infra::Head(infra::MakeRange(buffer), size));
+                        MethodDone();
+                    });
+            });
+    }
+
+    void Flash::Write(uint32_t address, infra::ConstByteRange contents)
+    {
+        flash.WriteBuffer(contents, address, [this]()
+            {
+                flashResult.RequestSend([this]()
+                    {
+                        flashResult.WriteDone();
+                        MethodDone();
+                    });
+            });
+    }
+
+    void Flash::EraseSectors(uint32_t sector, uint32_t numberOfSectors)
+    {
+        flash.EraseSectors(sector, sector + numberOfSectors, [this]()
+            {
+                flashResult.RequestSend([this]()
+                    {
+                        flashResult.EraseSectorsDone();
+                        MethodDone();
+                    });
+            });
+    }
+
+    FlashProxy::FlashProxy(services::Echo& echo)
+        : flash::FlashResult(echo)
+        , proxy(echo)
+    {}
+
+    void FlashProxy::WriteBuffer(infra::ConstByteRange buffer, uint32_t address, infra::Function<void()> onDone)
+    {
+        writingBuffer = buffer;
+        this->onDone = onDone;
+
+        if (!writingBuffer.empty())
+            proxy.RequestSend([this, address]()
+                {
+                    ++transferBuffers;
+                    auto size = std::min(writingBuffer.size(), std::tuple_size<std::remove_reference_t<decltype(std::declval<flash::WriteRequest>().contents.Storage())>>::value);
+                    proxy.Write(address, infra::Head(writingBuffer, size));
+                    WriteBuffer(infra::DiscardHead(writingBuffer, size), address + size, this->onDone.Clone());
+                });
+    }
+
+    void FlashProxy::ReadBuffer(infra::ByteRange buffer, uint32_t address, infra::Function<void()> onDone)
+    {
+        readingBuffer = buffer;
+        this->onDone = onDone;
+
+        ReadPartialBuffer(address, 0);
+    }
+
+    void FlashProxy::EraseSectors(uint32_t beginIndex, uint32_t endIndex, infra::Function<void()> onDone)
+    {
+        this->onDone = onDone;
+        x = endIndex;
+
+        proxy.RequestSend([this, beginIndex]()
+            {
+                proxy.EraseSectors(beginIndex, x - beginIndex);
+            });
+    }
+
+    void FlashProxy::ReadDone(infra::ConstByteRange contents)
+    {
+        infra::Copy(contents, infra::Head(readingBuffer, contents.size()));
+        readingBuffer = infra::DiscardHead(readingBuffer, contents.size());
+
+        --transferBuffers;
+        if (transferBuffers == 0 && readingBuffer.empty())
+            onDone();
+    }
+
+    void FlashProxy::WriteDone()
+    {
+        --transferBuffers;
+        if (transferBuffers == 0 && writingBuffer.empty())
+            onDone();
+    }
+
+    void FlashProxy::EraseSectorsDone()
+    {
+        onDone();
+    }
+
+    void FlashProxy::ReadPartialBuffer(uint32_t address, uint32_t start)
+    {
+        if (readingBuffer.size() - start > 0)
+        {
+            x = start;
+            proxy.RequestSend([this, address]()
+                {
+                    ++transferBuffers;
+                    auto size = std::min<uint32_t>(readingBuffer.size() - x, std::tuple_size<std::remove_reference_t<decltype(std::declval<flash::WriteRequest>().contents.Storage())>>::value);
+                    proxy.Read(address + x, size);
+                    ReadPartialBuffer(address, x + size);
+                });
+        }
+    }
+
+    FlashHomogeneousProxy::FlashHomogeneousProxy(services::Echo& echo, uint32_t numberOfSectors, uint32_t sizeOfEachSector)
+        : FlashProxy(echo)
+        , numberOfSectors(numberOfSectors)
+        , sizeOfEachSector(sizeOfEachSector)
+    {}
+
+    uint32_t FlashHomogeneousProxy::NumberOfSectors() const
+    {
+        return numberOfSectors;
+    }
+
+    uint32_t FlashHomogeneousProxy::SizeOfSector(uint32_t sectorIndex) const
+    {
+        return sizeOfEachSector;
+    }
+
+    uint32_t FlashHomogeneousProxy::SectorOfAddress(uint32_t address) const
+    {
+        return address / sizeOfEachSector;
+    }
+
+    uint32_t FlashHomogeneousProxy::AddressOfSector(uint32_t sectorIndex) const
+    {
+        return sectorIndex * sizeOfEachSector;
+    }
+}

integration_test/flash_tested/Flash.hpp

@@ -0,0 +1,74 @@
+#ifndef HAL_ST_INTEGRATION_TEST_FLASH_HPP
+#define HAL_ST_INTEGRATION_TEST_FLASH_HPP
+
+#include "generated/echo/Flash.pb.hpp"
+#include "hal/interfaces/FlashHomogeneous.hpp"
+#include "infra/util/AutoResetFunction.hpp"
+
+namespace application
+{
+    class Flash
+        : public flash::Flash
+    {
+    public:
+        Flash(services::Echo& echo, hal::Flash& flash);
+
+        // Implementation of flash::Flash
+        void Read(uint32_t address, uint32_t size) override;
+        void Write(uint32_t address, infra::ConstByteRange contents) override;
+        void EraseSectors(uint32_t sector, uint32_t numberOfSectors) override;
+
+    private:
+        flash::FlashResultProxy flashResult;
+        hal::Flash& flash;
+
+        std::array<uint8_t, std::tuple_size<std::remove_reference_t<decltype(std::declval<flash::WriteRequest>().contents.Storage())>>::value> buffer;
+    };
+
+    class FlashProxy
+        : public hal::Flash
+        , private flash::FlashResult
+    {
+    public:
+        FlashProxy(services::Echo& echo);
+
+        // Implementation of hal::Flash
+        void WriteBuffer(infra::ConstByteRange buffer, uint32_t address, infra::Function<void()> onDone) override;
+        void ReadBuffer(infra::ByteRange buffer, uint32_t address, infra::Function<void()> onDone) override;
+        void EraseSectors(uint32_t beginIndex, uint32_t endIndex, infra::Function<void()> onDone) override;
+
+    private:
+        // Implementation of flash::FlashResult
+        void ReadDone(infra::ConstByteRange contents) override;
+        void WriteDone() override;
+        void EraseSectorsDone() override;
+
+        void ReadPartialBuffer(uint32_t address, uint32_t start);
+
+    private:
+        flash::FlashProxy proxy;
+        infra::AutoResetFunction<void()> onDone;
+        infra::ConstByteRange writingBuffer;
+        infra::ByteRange readingBuffer;
+        uint32_t transferBuffers = 0;
+        uint32_t x;
+    };
+
+    class FlashHomogeneousProxy
+        : public FlashProxy
+    {
+    public:
+        FlashHomogeneousProxy(services::Echo& echo, uint32_t numberOfSectors, uint32_t sizeOfEachSector);
+
+        uint32_t NumberOfSectors() const override;
+        uint32_t SizeOfSector(uint32_t sectorIndex) const override;
+        uint32_t SectorOfAddress(uint32_t address) const override;
+        uint32_t AddressOfSector(uint32_t sectorIndex) const override;
+
+    private:
+        uint32_t numberOfSectors;
+        uint32_t sizeOfEachSector;
+    };
+}
+
+#endif

integration_test/flash_tested/Flash.proto

@@ -0,0 +1,46 @@
+syntax = "proto3";
+
+import "EchoAttributes.proto";
+
+package flash;
+
+message ReadRequest
+{
+    uint32 address = 1;
+    uint32 size = 2;
+}
+
+message ReadResponse
+{
+    bytes contents = 1 [(bytes_size) = 512];
+}
+
+message WriteRequest
+{
+    uint32 address = 1;
+    bytes contents = 2 [(bytes_size) = 512];
+}
+
+message EraseSectorsRequest
+{
+    uint32 sector = 1;
+    uint32 number_of_sectors = 2;
+}
+
+service Flash
+{
+    option (service_id) = 6;
+
+    rpc Read(ReadRequest) returns (Nothing) { option (method_id) = 1; }
+    rpc Write(WriteRequest) returns (Nothing) { option (method_id) = 2; }
+    rpc EraseSectors(EraseSectorsRequest) returns (Nothing) { option (method_id) = 3; }
+}
+
+service FlashResult
+{
+    option (service_id) = 7;
+
+    rpc ReadDone(ReadResponse) returns (Nothing) { option (method_id) = 1; }
+    rpc WriteDone(Nothing) returns (Nothing) { option (method_id) = 2; }
+    rpc EraseSectorsDone(Nothing) returns (Nothing) { option (method_id) = 3; }
+}

integration_test/flash_tested/test/CMakeLists.txt

@@ -0,0 +1,13 @@
+add_executable(integration_test.flash_tested.test)
+emil_build_for(integration_test.flash_tested.test BOOL HALST_BUILD_TESTS)
+emil_add_test(integration_test.flash_tested.test)
+
+target_link_libraries(integration_test.flash_tested.test PUBLIC
+    gmock_main
+    integration_test.flash_tested
+    protobuf.test_doubles
+)
+
+target_sources(integration_test.flash_tested.test PRIVATE
+    TestFlash.cpp
+)