test: add integration_test.flash_tested

.github/workflows/ci.yml

@@ -18,6 +18,8 @@ jobs:
       - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           persist-credentials: false
+          submodules: true
+          token: ${{ secrets.AMP_ACCESS_TOKEN }}
       - uses: hendrikmuhs/ccache-action@c92f40bee50034e84c763e33b317c77adaa81c92 # v1.2.13
         with:
           key: ${{ github.job }}-ubuntu-latest
@@ -27,29 +29,31 @@ jobs:
         with:
           configurePreset: "host"
           buildPreset: "host-Debug-WithPackage"
-          #testPreset: "host"
+          testPreset: "host"
           configurePresetAdditionalArgs: "['-DCMAKE_C_COMPILER_LAUNCHER=sccache', '-DCMAKE_CXX_COMPILER_LAUNCHER=sccache']"
       - uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
         with:
           name: hal_st
           path: build/host/hal_st-*-Linux.tar.gz
           if-no-files-found: error
-      #- name: Upload test logs
-      #  if: ${{ failure() }}
-      #  uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
-      #  with:
-      #    name: test-logs
-      #    path: build/host/Testing/Temporary/
+      - name: Upload test logs
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
+        with:
+          name: test-logs
+          path: build/host/Testing/Temporary/
   host_build_test:
     name: Host Build & Test
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [windows-latest, windows-2019, macos-latest]
+        os: [windows-latest, macos-latest]
     steps:
       - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
         with:
           persist-credentials: false
+          submodules: true
+          token: ${{ secrets.AMP_ACCESS_TOKEN }}
       - uses: hendrikmuhs/ccache-action@c92f40bee50034e84c763e33b317c77adaa81c92 # v1.2.13
         with:
           key: ${{ github.job }}-${{ matrix.os }}
@@ -58,27 +62,24 @@ jobs:
         with:
           configurePreset: "host-single-Debug"
           buildPreset: "host-single-Debug"
-          #testPreset: "host-single-Debug"
+          testPreset: "host-single-Debug"
           configurePresetAdditionalArgs: "['-DCMAKE_C_COMPILER_LAUNCHER=sccache', '-DCMAKE_CXX_COMPILER_LAUNCHER=sccache']"
-      #- name: Upload test logs
-      #  if: ${{ failure() }}
-      #  uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
-      #  with:
-      #    name: test-logs
-      #    path: build/host/Testing/Temporary/
+      - name: Upload test logs
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@65462800fd760344b1a7b4382951275a0abb4808 # v4.3.3
+        with:
+          name: test-logs
+          path: build/host/Testing/Temporary/
   embedded_build:
     name: Embedded Build
     runs-on: ubuntu-latest
     needs: [host_build_test_ubuntu]
     strategy:
       matrix:
         configuration: ["RelWithDebInfo"]
-        gcc: [ "10.3-2021.10" ]
+        gcc: ["10.3-2021.10"]
         target: ["stm32wb55", "stm32g070", "stm32g431", "stm32f407", "stm32f429", "stm32f746", "stm32f767", "stm32wba52"]
         include:
-          - gcc: "7-2018-q2"
-            configuration: "RelWithDebInfo"
-            target: "stm32f767"
           - gcc: "8-2019-q3"
             configuration: "RelWithDebInfo"
             target: "stm32f767"
@@ -87,6 +88,10 @@ jobs:
             target: "stm32f767"
     steps:
       - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
+        with:
+          persist-credentials: false
+          submodules: true
+          token: ${{ secrets.AMP_ACCESS_TOKEN }}
       - name: Install GNU Arm Embedded Toolchain ${{ matrix.gcc }}
         uses: carlosperate/arm-none-eabi-gcc-action@b864ac853a2d2f74ec2b8b3ec4deb9cb684b4627 # v1.8.2
         with:

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "amp-cucumber-cpp-runner"]
+	path = amp-cucumber-cpp-runner
+	url = https://github.com/philips-software/amp-cucumber-cpp-runner.git

CMakeLists.txt

@@ -5,12 +5,21 @@ 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_TESTS "Enable building the tests" Off)
+
 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 amp-embedded-infa-lib
+    # 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})
 
@@ -19,15 +28,15 @@ if (HALST_STANDALONE)
     FetchContent_Declare(
         emil
         GIT_REPOSITORY https://github.com/philips-software/amp-embedded-infra-lib.git
-        GIT_TAG        eeefdbabb671c1bed0142b06ffe25546d702c7d0 # unreleased
+        GIT_TAG        1ac66fc6aca64fb750b7133766c53d4d67b01be1 # sesame
     )
 
     FetchContent_MakeAvailable(emil)
 endif()
 
 project(hal_st LANGUAGES C CXX ASM VERSION 3.0.0) # x-release-please-version
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED On)
 
 set_directory_properties(PROPERTY USE_FOLDERS ON)
@@ -40,10 +49,21 @@ else()
     set(HALST_EXCLUDE_FROM_ALL "EXCLUDE_FROM_ALL")
 endif()
 
+if (HALST_BUILD_TESTS)
+    include(CTest)
+    emil_enable_testing()
+endif()
+
+if (EMIL_HOST_BUILD)
+    add_subdirectory(amp-cucumber-cpp-runner)
+endif()
+
 add_subdirectory(st)
 add_subdirectory(hal_st)
 add_subdirectory(hal_st_lwip)
-add_subdirectory(integration_test)
+if (HALST_STANDALONE)
+    add_subdirectory(integration_test)
+endif()
 add_subdirectory(services)
 add_subdirectory(examples)
 

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
       }
     },
     {

hal_st/stm32fxxx/DefaultClockNucleoF767ZI.cpp

@@ -1,7 +1,6 @@
 #include DEVICE_HEADER
 #include "hal_st/stm32fxxx/DefaultClockNucleoF767ZI.hpp"
 
-
 /* The system Clock is configured as follows:
  *    System Clock source            = PLL (HSE)
  *    SYSCLK(Hz)                     = 216000000
@@ -32,11 +31,11 @@ void ConfigureDefaultClockNucleo767ZI()
     RCC_OscInitStruct.HSEState = RCC_HSE_ON;
     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
     RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
-    RCC_OscInitStruct.PLL.PLLM = 4;               // Divides the 8MHz HSI to 2MHz
-    RCC_OscInitStruct.PLL.PLLN = 216;             // Multiplies the 2MHz to 432MHz
-    RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;   // Divides the 432MHz to 216MHz for SYSCLK
-    RCC_OscInitStruct.PLL.PLLQ = 9;               // Divides the 432MHz to 48MHz for USB and SDMMC and RNG
-    RCC_OscInitStruct.PLL.PLLR = 7;               // Divides the 432MHz to 62MHz for DSI (No clue what a good frequency would be here...)
+    RCC_OscInitStruct.PLL.PLLM = 4;             // Divides the 8MHz HSI to 2MHz
+    RCC_OscInitStruct.PLL.PLLN = 216;           // Multiplies the 2MHz to 432MHz
+    RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2; // Divides the 432MHz to 216MHz for SYSCLK
+    RCC_OscInitStruct.PLL.PLLQ = 9;             // Divides the 432MHz to 48MHz for USB and SDMMC and RNG
+    RCC_OscInitStruct.PLL.PLLR = 7;             // Divides the 432MHz to 62MHz for DSI (No clue what a good frequency would be here...)
     HAL_RCC_OscConfig(&RCC_OscInitStruct);
 
     HAL_PWREx_EnableOverDrive();

integration_test/CMakeLists.txt

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

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;
+        this->endIndex = endIndex;
+
+        proxy.RequestSend([this, beginIndex]()
+            {
+                proxy.EraseSectors(beginIndex, this->endIndex - 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)
+        {
+            this->start = start;
+            proxy.RequestSend([this, address]()
+                {
+                    ++transferBuffers;
+                    auto size = std::min<uint32_t>(readingBuffer.size() - this->start, std::tuple_size<std::remove_reference_t<decltype(std::declval<flash::WriteRequest>().contents.Storage())>>::value);
+                    proxy.Read(address + this->start, size);
+                    ReadPartialBuffer(address, this->start + 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;
+    }
+}