Transmission pipeline and cosmetic adjustments to the API

tests/.clang-tidy

@@ -38,6 +38,7 @@ Checks: >-
   -cert-msc30-c,
   -cert-msc50-cpp,
   -modernize-macro-to-enum,
+  -modernize-use-trailing-return-type,
   -cppcoreguidelines-owning-memory,
 WarningsAsErrors: '*'
 HeaderFilterRegex: '.*\.hpp'

tests/CMakeLists.txt

@@ -73,13 +73,13 @@ endfunction()
 
 # Disable missing declaration warning to allow exposure of private definitions.
 gen_test_matrix(test_private
-        "test_private_cavl.cpp;"
+        "test_private_cavl.cpp;test_private_crc.cpp;test_private_tx.cpp;"
         "-DUDPARD_CONFIG_HEADER=\"${CMAKE_CURRENT_SOURCE_DIR}/udpard_config_private.h\""
         "-Wno-missing-declarations"
         "")
 
 gen_test_matrix(test_public
-        "test_self.cpp"
+        "test_self.cpp;test_public_tx.cpp;"
         ""
         "-Wmissing-declarations"
         "")

tests/exposed.hpp

@@ -0,0 +1,70 @@
+/// This software is distributed under the terms of the MIT License.
+/// Copyright (C) OpenCyphal Development Team  <opencyphal.org>
+/// Copyright Amazon.com Inc. or its affiliates.
+/// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <udpard.h>  // Must be always included first.
+#include <cstdarg>
+#include <cstdint>
+#include <limits>
+#include <stdexcept>
+
+/// Definitions that are not exposed by the library but that are needed for testing.
+/// Please keep them in sync with the library by manually updating as necessary.
+namespace exposed
+{
+using byte_t = std::uint_least8_t;
+
+constexpr std::size_t HeaderSize = 24U;
+
+struct TransferMetadata final
+{
+    UdpardPriority   priority;
+    UdpardNodeID     src_node_id;
+    UdpardNodeID     dst_node_id;
+    std::uint16_t    data_specifier;
+    UdpardTransferID transfer_id;
+};
+
+struct TxItem final : public UdpardTxItem
+{
+    UdpardPriority priority;
+    // flex array not included
+};
+
+struct TxChain final
+{
+    TxItem*     head;
+    TxItem*     tail;
+    std::size_t count;
+};
+
+extern "C" {
+std::uint16_t headerCRCCompute(const std::size_t size, const void* const data);
+
+std::uint32_t transferCRCAdd(const std::uint32_t crc, const std::size_t size, const void* const data);
+
+byte_t* txSerializeHeader(byte_t* const          destination_buffer,
+                          const TransferMetadata meta,
+                          const std::uint32_t    frame_index,
+                          const bool             end_of_transfer);
+
+TxChain txMakeChain(UdpardMemoryResource* const memory,
+                    const std::uint_least8_t    dscp_value_per_priority[UDPARD_PRIORITY_MAX + 1U],
+                    const std::size_t           mtu,
+                    const UdpardMicrosecond     deadline_usec,
+                    const TransferMetadata      meta,
+                    const UdpardUDPIPEndpoint   endpoint,
+                    const UdpardConstPayload    payload,
+                    void* const                 user_transfer_reference);
+
+std::int32_t txPush(UdpardTx* const           tx,
+                    const UdpardMicrosecond   deadline_usec,
+                    const TransferMetadata    meta,
+                    const UdpardUDPIPEndpoint endpoint,
+                    const UdpardConstPayload  payload,
+                    void* const               user_transfer_reference);
+}
+}  // namespace exposed

tests/helpers.hpp

@@ -29,16 +29,16 @@ namespace helpers
 {
 namespace dummy_allocator
 {
-inline auto allocate(UdpardMemoryResource* const ins, const std::size_t amount) -> void*
+inline auto allocate(UdpardMemoryResource* const self, const std::size_t amount) -> void*
 {
-    (void) ins;
+    (void) self;
     (void) amount;
     return nullptr;
 }
 
-inline void free(UdpardMemoryResource* const ins, const size_t size, void* const pointer)
+inline void free(UdpardMemoryResource* const self, const size_t size, void* const pointer)
 {
-    (void) ins;
+    (void) self;
     (void) size;
     (void) pointer;
 }
@@ -65,10 +65,14 @@ inline void traverse(const UdpardTreeNode* const root, const F& fun)
 /// An allocator that sits on top of the standard malloc() providing additional testing capabilities.
 /// It allows the user to specify the maximum amount of memory that can be allocated; further requests will emulate OOM.
 /// It also performs correctness checks on the memory use.
-class TestAllocator
+class TestAllocator final : public UdpardMemoryResource
 {
 public:
-    TestAllocator()                                         = default;
+    TestAllocator() :
+        UdpardMemoryResource{.allocate       = &TestAllocator::trampolineAllocate,
+                             .free           = &TestAllocator::trampolineFree,
+                             .user_reference = this}
+    {}
     TestAllocator(const TestAllocator&)                     = delete;
     TestAllocator(const TestAllocator&&)                    = delete;
     auto operator=(const TestAllocator&) -> TestAllocator&  = delete;
@@ -79,36 +83,33 @@ class TestAllocator
         const std::unique_lock locker(lock_);
         for (const auto& pair : allocated_)
         {
-            // Clang-tidy complains about manual memory management. Suppressed because we need it for testing purposes.
-            std::free(pair.first - canary_.size());  // NOLINT
+            std::free(pair.first - canary_.size());
         }
     }
 
-    [[nodiscard]] auto allocate(const std::size_t amount) -> void*
+    [[nodiscard]] auto allocate(const std::size_t size) -> void*
     {
         const std::unique_lock locker(lock_);
         std::uint8_t*          p = nullptr;
-        if ((amount > 0U) && ((getTotalAllocatedAmount() + amount) <= ceiling_))
+        if ((size > 0U) && ((getTotalAllocatedAmount() + size) <= ceiling_))
         {
-            const auto amount_with_canaries = amount + canary_.size() * 2U;
-            // Clang-tidy complains about manual memory management. Suppressed because we need it for testing purposes.
-            p = static_cast<std::uint8_t*>(std::malloc(amount_with_canaries));  // NOLINT
+            const auto size_with_canaries = size + canary_.size() * 2U;
+            p                             = static_cast<std::uint8_t*>(std::malloc(size_with_canaries));
             if (p == nullptr)
             {
                 throw std::bad_alloc();  // This is a test suite failure, not a failed test. Mind the difference.
             }
             p += canary_.size();
-            std::generate_n(p, amount, []() { return static_cast<std::uint8_t>(getRandomNatural(256U)); });
+            std::generate_n(p, size, [] { return static_cast<std::uint8_t>(getRandomNatural(256U)); });
             std::memcpy(p - canary_.size(), canary_.begin(), canary_.size());
-            std::memcpy(p + amount, canary_.begin(), canary_.size());
-            allocated_.emplace(p, amount);
+            std::memcpy(p + size, canary_.begin(), canary_.size());
+            allocated_.emplace(p, size);
         }
         return p;
     }
 
     void free(const std::size_t size, void* const pointer)
     {
-        (void) size;  // TODO FIXME ensure the size passed to this function is correct.
         if (pointer != nullptr)
         {
             const std::unique_lock locker(lock_);
@@ -118,15 +119,20 @@ class TestAllocator
                 throw std::logic_error("Attempted to deallocate memory that was never allocated; ptr=" +
                                        std::to_string(reinterpret_cast<std::uint64_t>(pointer)));
             }
-            const auto [p, amount] = *it;
+            const auto [p, true_size] = *it;
+            if (size != true_size)
+            {
+                throw std::logic_error("Attempted to deallocate memory with a wrong size; ptr=" +
+                                       std::to_string(reinterpret_cast<std::uint64_t>(pointer)));
+            }
             if ((0 != std::memcmp(p - canary_.size(), canary_.begin(), canary_.size())) ||
-                (0 != std::memcmp(p + amount, canary_.begin(), canary_.size())))
+                (0 != std::memcmp(p + true_size, canary_.begin(), canary_.size())))
             {
                 throw std::logic_error("Dead canary detected at ptr=" +
                                        std::to_string(reinterpret_cast<std::uint64_t>(pointer)));
             }
             std::generate_n(p - canary_.size(),  // Damage the memory to make sure it's not used after deallocation.
-                            amount + canary_.size() * 2U,
+                            true_size + canary_.size() * 2U,
                             []() { return static_cast<std::uint8_t>(getRandomNatural(256U)); });
             std::free(p - canary_.size());
             allocated_.erase(it);
@@ -161,6 +167,16 @@ class TestAllocator
         return out;
     }
 
+    static auto trampolineAllocate(UdpardMemoryResource* const self, const size_t size) -> void*
+    {
+        return static_cast<TestAllocator*>(self->user_reference)->allocate(size);
+    }
+
+    static void trampolineFree(UdpardMemoryResource* const self, const size_t size, void* const pointer)
+    {
+        return static_cast<TestAllocator*>(self->user_reference)->free(size, pointer);
+    }
+
     const std::array<std::uint8_t, 256> canary_ = makeCanary();
 
     mutable std::recursive_mutex                   lock_;

tests/hexdump.hpp

@@ -0,0 +1,80 @@
+/// This software is distributed under the terms of the MIT License.
+/// Copyright (C) OpenCyphal Development Team  <opencyphal.org>
+/// Copyright Amazon.com Inc. or its affiliates.
+/// SPDX-License-Identifier: MIT
+/// Author: Pavel Kirienko <[email protected]>
+
+#include <string>
+#include <sstream>
+#include <iomanip>
+
+namespace hexdump
+{
+template <std::uint8_t BytesPerRow = 16, typename InputIterator>
+[[nodiscard]] std::string hexdump(InputIterator begin, const InputIterator end)
+{
+    static_assert(BytesPerRow > 0);
+    static constexpr std::pair<std::uint8_t, std::uint8_t> PrintableASCIIRange{32, 126};
+    std::uint32_t                                          offset = 0;
+    std::ostringstream                                     output;
+    bool                                                   first = true;
+    output << std::hex << std::setfill('0');
+    do
+    {
+        if (first)
+        {
+            first = false;
+        }
+        else
+        {
+            output << "\n";
+        }
+        output << std::setw(8) << offset << "  ";
+        offset += BytesPerRow;
+        auto it = begin;
+        for (std::uint8_t i = 0; i < BytesPerRow; ++i)
+        {
+            if (i == 8)
+            {
+                output << ' ';
+            }
+            if (it != end)
+            {
+                output << std::setw(2) << static_cast<std::uint32_t>(*it) << ' ';
+                ++it;
+            }
+            else
+            {
+                output << "   ";
+            }
+        }
+        output << " ";
+        for (std::uint8_t i = 0; i < BytesPerRow; ++i)
+        {
+            if (begin != end)
+            {
+                output << (((static_cast<std::uint32_t>(*begin) >= PrintableASCIIRange.first) &&
+                            (static_cast<std::uint32_t>(*begin) <= PrintableASCIIRange.second))
+                               ? static_cast<char>(*begin)  // NOSONAR intentional conversion to plain char
+                               : '.');
+                ++begin;
+            }
+            else
+            {
+                output << ' ';
+            }
+        }
+    } while (begin != end);
+    return output.str();
+}
+
+[[nodiscard]] auto hexdump(const auto& cont)
+{
+    return hexdump(std::begin(cont), std::end(cont));
+}
+
+[[nodiscard]] inline auto hexdump(const void* const data, const std::size_t size)
+{
+    return hexdump(static_cast<const std::uint8_t*>(data), static_cast<const std::uint8_t*>(data) + size);
+}
+}  // namespace hexdump

tests/test_private_cavl.cpp

@@ -1347,7 +1347,7 @@ TEST(Cavl, MutationRandomized)
     };
 
     std::puts("Running the randomized test...");
-    for (std::uint32_t iteration = 0U; iteration < 100'000U; iteration++)
+    for (std::uint32_t iteration = 0U; iteration < 10'000U; iteration++)
     {
         if ((getRandomByte() % 2U) != 0)
         {

tests/test_private_crc.cpp

@@ -0,0 +1,31 @@
+/// This software is distributed under the terms of the MIT License.
+/// Copyright (C) OpenCyphal Development Team  <opencyphal.org>
+/// Copyright Amazon.com Inc. or its affiliates.
+/// SPDX-License-Identifier: MIT
+
+#include "exposed.hpp"
+#include <gtest/gtest.h>
+
+TEST(CRC, Header)
+{
+    using exposed::headerCRCCompute;
+    ASSERT_EQ(0x29B1U, headerCRCCompute(9, "123456789"));
+}
+
+TEST(CRC, Transfer)
+{
+    using exposed::transferCRCAdd;
+    constexpr std::uint32_t OutputXOR = 0xFFFFFFFFU;
+    auto                    crc       = transferCRCAdd(0xFFFFFFFFU, 3, "123");
+    crc                               = transferCRCAdd(crc, 6, "456789");
+    ASSERT_EQ(0x1CF96D7CUL, crc);
+    ASSERT_EQ(0xE3069283UL, crc ^ OutputXOR);
+    crc = transferCRCAdd(crc,
+                         4,
+                         "\x83"  // Least significant byte first.
+                         "\x92"
+                         "\x06"
+                         "\xE3");
+    ASSERT_EQ(0xB798B438UL, crc);
+    ASSERT_EQ(0x48674BC7UL, crc ^ OutputXOR);
+}