add test public and migrate udpard fragment seek test there

Author: pavel-kirienko

libudpard/udpard.c

@@ -6,8 +6,8 @@
 // ReSharper disable CppDFATimeOver
 
 #include "udpard.h"
-#include <string.h>
 #include <assert.h>
+#include <string.h>
 
 /// Define this macro to include build configuration header.
 /// Usage example with CMake: "-DUDPARD_CONFIG_HEADER=\"${CMAKE_CURRENT_SOURCE_DIR}/my_udpard_config.h\""
@@ -18,7 +18,6 @@
 /// By default, this macro resolves to the standard assert(). The user can redefine this if necessary.
 /// To disable assertion checks completely, make it expand into `(void)(0)`.
 #ifndef UDPARD_ASSERT
-// Intentional violation of MISRA: inclusion not at the top of the file to eliminate unnecessary dependency on assert.h.
 // Intentional violation of MISRA: assertion macro cannot be replaced with a function definition.
 #define UDPARD_ASSERT(x) assert(x) // NOSONAR
 #endif
@@ -122,6 +121,7 @@ static int32_t cavl_compare_fragment_end(const void* const user, const udpard_tr
     return 0; // clang-format on
 }
 
+// NOLINTNEXTLINE(misc-no-recursion)
 void udpard_fragment_free_all(udpard_fragment_t* const frag, const udpard_mem_resource_t fragment_memory_resource)
 {
     if (frag != NULL) {

tests/.clang-tidy

@@ -50,6 +50,7 @@ Checks: >-
   -performance-avoid-endl,
   -cppcoreguidelines-avoid-do-while,
   -*DeprecatedOrUnsafeBufferHandling,
+  -*-prefer-static-over-anonymous-namespace,
 WarningsAsErrors: '*'
 HeaderFilterRegex: '.*\.hpp'
 FormatStyle: file

tests/CMakeLists.txt

@@ -20,7 +20,7 @@ set(ENABLE_COVERAGE OFF CACHE BOOL "enable code coverage measurement")
 set(library_dir "${CMAKE_SOURCE_DIR}/libudpard")
 set(unity_root "${CMAKE_SOURCE_DIR}/submodules/unity")
 
-include_directories(${CMAKE_SOURCE_DIR}/lib/cavl)
+include_directories(SYSTEM ${CMAKE_SOURCE_DIR}/lib/cavl)
 
 # TODO FIXME: remove this later
 add_compile_options(-Wno-unused-function)
@@ -91,6 +91,7 @@ gen_test_matrix(test_intrusive_header "src/test_intrusive_header.c")
 gen_test_matrix(test_intrusive_misc "src/test_intrusive_misc.c")
 gen_test_matrix(test_intrusive_tx "src/test_intrusive_tx.c")
 gen_test_matrix(test_intrusive_rx "src/test_intrusive_rx.c")
+gen_test_matrix(test_public "src/test_public.cpp;${library_dir}/udpard.c")
 
 # Coverage targets. Usage:
 #   cmake -DENABLE_COVERAGE=ON ..

tests/src/helpers.h

@@ -158,14 +158,14 @@ static inline void instrumented_allocator_reset(instrumented_allocator_t* const
 
 static inline udpard_mem_resource_t instrumented_allocator_make_resource(const instrumented_allocator_t* const self)
 {
-    return (udpard_mem_resource_t){ .user  = (void*)self,
-                                    .free  = &instrumented_allocator_free,
-                                    .alloc = &instrumented_allocator_alloc };
+    const udpard_mem_resource_t result = { (void*)self, &instrumented_allocator_free, &instrumented_allocator_alloc };
+    return result;
 }
 
 static inline udpard_mem_deleter_t instrumented_allocator_make_deleter(const instrumented_allocator_t* const self)
 {
-    return (udpard_mem_deleter_t){ .user = (void*)self, .free = &instrumented_allocator_free };
+    const udpard_mem_deleter_t result = { (void*)self, &instrumented_allocator_free };
+    return result;
 }
 
 static inline void seed_prng(void)

tests/src/test_intrusive_rx.c

@@ -2644,123 +2644,6 @@ static void test_session_ordered(void)
     instrumented_allocator_reset(&alloc_payload);
 }
 
-// ---------------------------------------------  FRAGMENT  ---------------------------------------------
-
-static void test_udpard_fragment_seek(void)
-{
-    instrumented_allocator_t alloc_frag = { 0 };
-    instrumented_allocator_new(&alloc_frag);
-    const udpard_mem_resource_t mem_frag = instrumented_allocator_make_resource(&alloc_frag);
-
-    instrumented_allocator_t alloc_payload = { 0 };
-    instrumented_allocator_new(&alloc_payload);
-    const udpard_mem_resource_t mem_payload = instrumented_allocator_make_resource(&alloc_payload);
-    const udpard_mem_deleter_t  del_payload = instrumented_allocator_make_deleter(&alloc_payload);
-
-    // Build a fragment tree with multiple fragments with gaps between them.
-    // Using make_frame_base to control exact sizes (no null terminators).
-    // Fragments at offsets: 0-3 (3 bytes), 5-8 (3 bytes), 10-14 (4 bytes)
-    udpard_tree_t* root = NULL;
-    size_t         cov  = 0;
-
-    // Fragment 1: offset 0, size 3
-    rx_fragment_tree_update(&root, mem_frag, del_payload, make_frame_base(mem_payload, 0, 3, "abc"), 14, 14, &cov);
-    TEST_ASSERT_NOT_NULL(root);
-    TEST_ASSERT_EQUAL_size_t(3, cov); // Coverage is only the contiguous prefix from offset 0.
-
-    // Fragment 2: offset 5, size 3
-    rx_fragment_tree_update(&root, mem_frag, del_payload, make_frame_base(mem_payload, 5, 3, "def"), 14, 14, &cov);
-    TEST_ASSERT_EQUAL_size_t(3, cov); // Still 3, gap at [3-5).
-
-    // Fragment 3: offset 10, size 4
-    rx_fragment_tree_update(&root, mem_frag, del_payload, make_frame_base(mem_payload, 10, 4, "ghij"), 14, 14, &cov);
-
-    TEST_ASSERT_EQUAL(3, tree_count(root));
-    TEST_ASSERT_EQUAL_size_t(3, cov); // Still 3, gaps prevent full coverage.
-
-    // Get references to the fragments for testing.
-    udpard_fragment_t* frag0 = fragment_at(root, 0);
-    udpard_fragment_t* frag1 = fragment_at(root, 1);
-    udpard_fragment_t* frag2 = fragment_at(root, 2);
-    TEST_ASSERT_NOT_NULL(frag0);
-    TEST_ASSERT_NOT_NULL(frag1);
-    TEST_ASSERT_NOT_NULL(frag2);
-
-    // Test seeking to offset 0 (should return first fragment).
-    TEST_ASSERT_EQUAL_PTR(frag0, udpard_fragment_seek(frag0, 0));
-    TEST_ASSERT_EQUAL_PTR(frag0, udpard_fragment_seek(frag1, 0));
-    TEST_ASSERT_EQUAL_PTR(frag0, udpard_fragment_seek(frag2, 0));
-
-    // Test seeking within first fragment [0-3).
-    TEST_ASSERT_EQUAL_PTR(frag0, udpard_fragment_seek(frag0, 0));
-    TEST_ASSERT_EQUAL_PTR(frag0, udpard_fragment_seek(frag0, 1));
-    TEST_ASSERT_EQUAL_PTR(frag0, udpard_fragment_seek(frag0, 2));
-
-    // Test seeking in gap [3-5) - should return NULL.
-    TEST_ASSERT_NULL(udpard_fragment_seek(frag0, 3));
-    TEST_ASSERT_NULL(udpard_fragment_seek(frag1, 4));
-
-    // Test seeking to start of second fragment [5-8).
-    TEST_ASSERT_EQUAL_PTR(frag1, udpard_fragment_seek(frag0, 5));
-    TEST_ASSERT_EQUAL_PTR(frag1, udpard_fragment_seek(frag1, 5));
-    TEST_ASSERT_EQUAL_PTR(frag1, udpard_fragment_seek(frag2, 5));
-
-    // Test seeking within second fragment.
-    TEST_ASSERT_EQUAL_PTR(frag1, udpard_fragment_seek(frag0, 6));
-    TEST_ASSERT_EQUAL_PTR(frag1, udpard_fragment_seek(frag1, 7));
-
-    // Test seeking in gap [8-10) - should return NULL.
-    TEST_ASSERT_NULL(udpard_fragment_seek(frag0, 8));
-    TEST_ASSERT_NULL(udpard_fragment_seek(frag1, 9));
-
-    // Test seeking to start of third fragment [10-14).
-    TEST_ASSERT_EQUAL_PTR(frag2, udpard_fragment_seek(frag0, 10));
-    TEST_ASSERT_EQUAL_PTR(frag2, udpard_fragment_seek(frag1, 10));
-    TEST_ASSERT_EQUAL_PTR(frag2, udpard_fragment_seek(frag2, 10));
-
-    // Test seeking within third fragment.
-    TEST_ASSERT_EQUAL_PTR(frag2, udpard_fragment_seek(frag0, 11));
-    TEST_ASSERT_EQUAL_PTR(frag2, udpard_fragment_seek(frag1, 12));
-    TEST_ASSERT_EQUAL_PTR(frag2, udpard_fragment_seek(frag2, 13));
-
-    // Test seeking beyond payload (should return NULL).
-    TEST_ASSERT_NULL(udpard_fragment_seek(frag0, 14));
-    TEST_ASSERT_NULL(udpard_fragment_seek(frag1, 14));
-    TEST_ASSERT_NULL(udpard_fragment_seek(frag2, 14));
-    TEST_ASSERT_NULL(udpard_fragment_seek(frag0, 100));
-
-    // Cleanup.
-    udpard_fragment_free_all((udpard_fragment_t*)root, mem_frag);
-    TEST_ASSERT_EQUAL_size_t(0, alloc_frag.allocated_fragments);
-    TEST_ASSERT_EQUAL_size_t(0, alloc_payload.allocated_fragments);
-
-    instrumented_allocator_reset(&alloc_frag);
-    instrumented_allocator_reset(&alloc_payload);
-
-    // Test with single fragment.
-    root = NULL;
-    cov  = 0;
-    rx_fragment_tree_update(&root, mem_frag, del_payload, make_frame_base(mem_payload, 0, 5, "hello"), 5, 5, &cov);
-    TEST_ASSERT_NOT_NULL(root);
-
-    udpard_fragment_t* single = fragment_at(root, 0);
-    TEST_ASSERT_NOT_NULL(single);
-
-    // Seek within single fragment.
-    TEST_ASSERT_EQUAL_PTR(single, udpard_fragment_seek(single, 0));
-    TEST_ASSERT_EQUAL_PTR(single, udpard_fragment_seek(single, 1));
-    TEST_ASSERT_EQUAL_PTR(single, udpard_fragment_seek(single, 2));
-    TEST_ASSERT_EQUAL_PTR(single, udpard_fragment_seek(single, 4));
-
-    // Seek beyond single fragment.
-    TEST_ASSERT_NULL(udpard_fragment_seek(single, 5));
-
-    // Cleanup.
-    udpard_fragment_free_all((udpard_fragment_t*)root, mem_frag);
-    TEST_ASSERT_EQUAL_size_t(0, alloc_frag.allocated_fragments);
-    TEST_ASSERT_EQUAL_size_t(0, alloc_payload.allocated_fragments);
-}
-
 void setUp(void) {}
 
 void tearDown(void) {}
@@ -2781,7 +2664,5 @@ int main(void)
 
     RUN_TEST(test_session_ordered);
 
-    RUN_TEST(test_udpard_fragment_seek);
-
     return UNITY_END();
 }

tests/src/test_public.cpp

@@ -0,0 +1,102 @@
+/// 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 <udpard.h>
+#include "helpers.h"
+#include <unity.h>
+#include <cstring>
+
+namespace {
+
+/// The data is copied.
+udpard_fragment_t* make_test_fragment(const udpard_mem_resource_t& fragment_memory,
+                                      const udpard_mem_resource_t& payload_memory,
+                                      const udpard_mem_deleter_t   payload_deleter,
+                                      const size_t                 offset,
+                                      const size_t                 size,
+                                      const void*                  data)
+{
+    auto* const frag =
+      static_cast<udpard_fragment_t*>(fragment_memory.alloc(fragment_memory.user, sizeof(udpard_fragment_t)));
+    if (frag == nullptr) {
+        return nullptr;
+    }
+    void* payload_data = payload_memory.alloc(payload_memory.user, size);
+    if (payload_data == nullptr) {
+        fragment_memory.free(fragment_memory.user, sizeof(udpard_fragment_t), frag);
+        return nullptr;
+    }
+    if (size > 0 && data != nullptr) {
+        std::memcpy(payload_data, data, size);
+    }
+    std::memset(frag, 0, sizeof(*frag));
+    frag->next            = nullptr;
+    frag->view.data       = payload_data;
+    frag->view.size       = size;
+    frag->origin.data     = payload_data;
+    frag->origin.size     = size;
+    frag->offset          = offset;
+    frag->payload_deleter = payload_deleter;
+    return frag;
+}
+
+void test_udpard_fragment_seek()
+{
+    instrumented_allocator_t alloc_frag{};
+    instrumented_allocator_new(&alloc_frag);
+    const udpard_mem_resource_t mem_frag = instrumented_allocator_make_resource(&alloc_frag);
+
+    instrumented_allocator_t alloc_payload{};
+    instrumented_allocator_new(&alloc_payload);
+    const udpard_mem_resource_t mem_payload = instrumented_allocator_make_resource(&alloc_payload);
+    const udpard_mem_deleter_t  del_payload = instrumented_allocator_make_deleter(&alloc_payload);
+
+    // Test with single fragment at offset 0.
+    // Note: udpard_fragment_seek() uses the index_offset tree structure internally,
+    // which can only be properly built by the RX pipeline. For public API testing,
+    // we can only test simple cases with standalone fragments.
+    udpard_fragment_t* single = make_test_fragment(mem_frag, mem_payload, del_payload, 0, 5, "hello");
+    TEST_ASSERT_NOT_NULL(single);
+    single->next = nullptr;
+    // Initialize the tree node to null (no parent, no children) - this makes it a standalone root
+    single->index_offset.up    = nullptr;
+    single->index_offset.lr[0] = nullptr;
+    single->index_offset.lr[1] = nullptr;
+    single->index_offset.bf    = 0;
+
+    // Seek to offset 0 should return the fragment itself.
+    TEST_ASSERT_EQUAL_PTR(single, udpard_fragment_seek(single, 0));
+
+    // Seek within single fragment range [0-5).
+    TEST_ASSERT_EQUAL_PTR(single, udpard_fragment_seek(single, 0));
+    TEST_ASSERT_EQUAL_PTR(single, udpard_fragment_seek(single, 1));
+    TEST_ASSERT_EQUAL_PTR(single, udpard_fragment_seek(single, 2));
+    TEST_ASSERT_EQUAL_PTR(single, udpard_fragment_seek(single, 4));
+
+    // Seek beyond single fragment should return NULL.
+    TEST_ASSERT_NULL(udpard_fragment_seek(single, 5));
+    TEST_ASSERT_NULL(udpard_fragment_seek(single, 100));
+
+    // Cleanup.
+    mem_payload.free(mem_payload.user, single->origin.size, single->origin.data);
+    mem_frag.free(mem_frag.user, sizeof(udpard_fragment_t), single);
+    TEST_ASSERT_EQUAL_size_t(0, alloc_frag.allocated_fragments);
+    TEST_ASSERT_EQUAL_size_t(0, alloc_payload.allocated_fragments);
+}
+
+} // namespace
+
+extern "C"
+{
+void setUp() {}
+void tearDown() {}
+}
+
+int main()
+{
+    UNITY_BEGIN();
+    RUN_TEST(test_udpard_fragment_seek);
+    return UNITY_END();
+}