- Added unittests for the type-specific byte_buffer implementations.

Author: avalerio-tkd

CMakeLists.txt

@@ -341,6 +341,14 @@ if(BUILD_TESTS)
   )
   target_include_directories(typed_buffer_test PRIVATE src/processing src/common)
 
+  # Typed buffer values tests
+  add_executable(typed_buffer_values_test src/processing/typed_buffer_values_test.cpp)
+  target_link_libraries(typed_buffer_values_test
+    dbps_byte_buffer_lib
+    gtest_main
+  )
+  target_include_directories(typed_buffer_values_test PRIVATE src/processing src/common)
+
   # Basic encryptor tests
   add_executable(basic_encryptor_test src/processing/encryptors/basic_encryptor_test.cpp)
   target_link_libraries(basic_encryptor_test
@@ -535,6 +543,7 @@ if(BUILD_TESTS)
       bytes_utils_test
       compression_utils_test
       typed_buffer_test
+      typed_buffer_values_test
       basic_encryptor_test
       auth_utils_test
       dbpa_interface_test
@@ -558,6 +567,7 @@ if(BUILD_TESTS)
   gtest_discover_tests(bytes_utils_test)
   gtest_discover_tests(compression_utils_test)
   gtest_discover_tests(typed_buffer_test)
+  gtest_discover_tests(typed_buffer_values_test)
   gtest_discover_tests(basic_encryptor_test)
   gtest_discover_tests(auth_utils_test)
   gtest_discover_tests(dbpa_interface_test)

src/processing/typed_buffer.h

@@ -535,39 +535,42 @@ void ByteBuffer<Codec>::SetElement(size_t position, const value_type& element) {
         codec_.Encode(element, write_span);
         return;
     }
+    
+    // Variable-sized elements - `else` is needed because it's a compile-time check.
+    else {
+        const size_t element_size = static_cast<size_t>(element.size());
 
-    const size_t element_size = static_cast<size_t>(element.size());
-
-    // Defensive check for unlikely extremely large element size that exceeds uint32.
-    if (element_size > static_cast<size_t>(std::numeric_limits<uint32_t>::max())) {
-        throw InvalidInputException("Variable-size element payload exceeds uint32 capacity.. Woohhh!!");
-    }
-
-    // For variable-size elements, we append the element to the write buffer and update offsets_.
-    //
-    // We append the element to the write buffer and update offsets_.
-    //
-    // This can result on orphaned bytes if a position is set multiple times or positions written out of order.
-    // This is intentional to allow random writes of elements while the buffer is built.
-    // During FinalizeAndTakeBuffer, the buffer is rebuilt to be sequential and orphaned bytes are removed.
-    const size_t offset = write_buffer_.size();
-    offsets_[position] = offset;
-    append_u32_le(write_buffer_, static_cast<uint32_t>(element_size));
-    const size_t payload_offset = write_buffer_.size();
-    write_buffer_.resize(payload_offset + element_size);
-    auto write_span = tcb::span<uint8_t>(write_buffer_.data() + payload_offset, element_size);
-    codec_.Encode(element, write_span);
-
-    // Update next_expected_write_position_ for sequential write checking.
-    if (next_expected_write_position_ != kUnsetVariableElementOffset) {
-        if (position == next_expected_write_position_) {
-            next_expected_write_position_ += 1;
-        } else {
-            next_expected_write_position_ = kUnsetVariableElementOffset;
+        // Defensive check for unlikely extremely large element size that exceeds uint32.
+        if (element_size > static_cast<size_t>(std::numeric_limits<uint32_t>::max())) {
+            throw InvalidInputException("Variable-size element payload exceeds uint32 capacity.. Woohhh!!");
         }
-    }
 
-    RebindSpanToWriteBuffer();
+        // For variable-size elements, we append the element to the write buffer and update offsets_.
+        //
+        // We append the element to the write buffer and update offsets_.
+        //
+        // This can result on orphaned bytes if a position is set multiple times or positions written out of order.
+        // This is intentional to allow random writes of elements while the buffer is built.
+        // During FinalizeAndTakeBuffer, the buffer is rebuilt to be sequential and orphaned bytes are removed.
+        const size_t offset = write_buffer_.size();
+        offsets_[position] = offset;
+        append_u32_le(write_buffer_, static_cast<uint32_t>(element_size));
+        const size_t payload_offset = write_buffer_.size();
+        write_buffer_.resize(payload_offset + element_size);
+        auto write_span = tcb::span<uint8_t>(write_buffer_.data() + payload_offset, element_size);
+        codec_.Encode(element, write_span);
+
+        // Update next_expected_write_position_ for sequential write checking.
+        if (next_expected_write_position_ != kUnsetVariableElementOffset) {
+            if (position == next_expected_write_position_) {
+                next_expected_write_position_ += 1;
+            } else {
+                next_expected_write_position_ = kUnsetVariableElementOffset;
+            }
+        }
+
+        RebindSpanToWriteBuffer();
+    }
 }
 
 template <class Codec>

src/processing/typed_buffer_codecs.h

@@ -19,6 +19,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <cstring>
 #include <string_view>
 #include <tcb/span.hpp>
 #include "exceptions.h"