Change way of testing after fix on sparrow (#12)

Test offending line after fix on sparrow

Author: Hind-M

cmake/external_dependencies.cmake

@@ -11,7 +11,7 @@ endif()
 
 function(find_package_or_fetch)
     set(options)
-    set(oneValueArgs CONAN_PKG_NAME PACKAGE_NAME VERSION GIT_REPOSITORY TAG)
+    set(oneValueArgs CONAN_PKG_NAME PACKAGE_NAME GIT_REPOSITORY TAG)
     set(multiValueArgs)
     cmake_parse_arguments(PARSE_ARGV 0 arg
         "${options}" "${oneValueArgs}" "${multiValueArgs}"
@@ -48,9 +48,8 @@ endfunction()
 set(SPARROW_BUILD_SHARED ${SPARROW_IPC_BUILD_SHARED})
 find_package_or_fetch(
     PACKAGE_NAME sparrow
-    VERSION 1.0.0
     GIT_REPOSITORY https://github.com/man-group/sparrow.git
-    TAG 1.0.0
+    TAG 1.1.0
 )
 
 if(NOT TARGET sparrow::sparrow)
@@ -62,7 +61,6 @@ set(FLATBUFFERS_BUILD_SHAREDLIB ${SPARROW_IPC_BUILD_SHARED})
 find_package_or_fetch(
     CONAN_PKG_NAME flatbuffers
     PACKAGE_NAME FlatBuffers
-    VERSION v25.2.10
     GIT_REPOSITORY https://github.com/google/flatbuffers.git
     TAG v25.2.10
 )
@@ -75,7 +73,6 @@ unset(FLATBUFFERS_BUILD_TESTS CACHE)
 if(SPARROW_IPC_BUILD_TESTS)
     find_package_or_fetch(
         PACKAGE_NAME doctest
-        VERSION v2.4.12
         GIT_REPOSITORY https://github.com/doctest/doctest.git
         TAG v2.4.12
     )

environment-dev.yml

@@ -8,5 +8,5 @@ dependencies:
   - cxx-compiler
   # Libraries dependencies
   - flatbuffers
-  - sparrow
+  - sparrow >=1.1.0
   - doctest

tests/include/sparrow_ipc_tests_helpers.hpp

@@ -8,7 +8,7 @@ namespace sparrow_ipc
     namespace sp = sparrow;
 
     template <typename T1, typename T2>
-    void compare_metadata(T1& arr1, T2& arr2)
+    void compare_metadata(const T1& arr1, const T2& arr2)
     {
         if (!arr1.metadata().has_value())
         {

tests/test_primitive_array_serialization.cpp

@@ -18,91 +18,6 @@ namespace sparrow_ipc
         float,
         double>;
 
-    // TODO We should use comparison functions from sparrow, after making them available if not already
-    // after next release?
-    // Or even better, allow checking directly primitive_array equality in sparrow
-    void compare_arrow_schemas(const ArrowSchema& s1, const ArrowSchema& s2)
-    {
-        std::string_view s1_format = (s1.format != nullptr) ? std::string_view(s1.format) : "";
-        std::string_view s2_format = (s2.format != nullptr) ? std::string_view(s2.format) : "";
-        CHECK_EQ(s1_format, s2_format);
-
-        std::string_view s1_name = (s1.name != nullptr) ? std::string_view(s1.name) : "";
-        std::string_view s2_name = (s2.name != nullptr) ? std::string_view(s2.name) : "";
-        CHECK_EQ(s1_name, s2_name);
-
-        if (s1.metadata == nullptr)
-        {
-            CHECK_EQ(s2.metadata, nullptr);
-        }
-        else
-        {
-            REQUIRE_NE(s2.metadata, nullptr);
-        }
-
-        CHECK_EQ(s1.flags, s2.flags);
-        CHECK_EQ(s1.n_children, s2.n_children);
-
-        if (s1.n_children > 0)
-        {
-            REQUIRE_NE(s1.children, nullptr);
-            REQUIRE_NE(s2.children, nullptr);
-            for (int64_t i = 0; i < s1.n_children; ++i)
-            {
-                REQUIRE_NE(s1.children[i], nullptr);
-                REQUIRE_NE(s2.children[i], nullptr);
-                compare_arrow_schemas(*s1.children[i], *s2.children[i]);
-            }
-        }
-        else
-        {
-            CHECK_EQ(s1.children, nullptr);
-            CHECK_EQ(s2.children, nullptr);
-        }
-
-        if (s1.dictionary != nullptr)
-        {
-            REQUIRE_NE(s2.dictionary, nullptr);
-            compare_arrow_schemas(*s1.dictionary, *s2.dictionary);
-        }
-        else
-        {
-            CHECK_EQ(s2.dictionary, nullptr);
-        }
-    }
-
-    void compare_arrow_arrays(const ArrowArray& lhs, const ArrowArray& rhs)
-    {
-        CHECK_EQ(lhs.length, rhs.length);
-        CHECK_EQ(lhs.null_count, rhs.null_count);
-        CHECK_EQ(lhs.offset, rhs.offset);
-        CHECK_EQ(lhs.n_buffers, rhs.n_buffers);
-        CHECK_EQ(lhs.n_children, rhs.n_children);
-        CHECK_NE(lhs.buffers, rhs.buffers);
-        CHECK_NE(lhs.private_data, rhs.private_data);
-        for (size_t i = 0; i < static_cast<size_t>(lhs.n_buffers); ++i)
-        {
-            CHECK_NE(lhs.buffers[i], rhs.buffers[i]);
-        }
-        const auto lhs_buffers = reinterpret_cast<const int8_t**>(lhs.buffers);
-        const auto rhs_buffers = reinterpret_cast<const int8_t**>(rhs.buffers);
-
-        for (size_t i = 0; i < static_cast<size_t>(lhs.length); ++i)
-        {
-            CHECK_EQ(lhs_buffers[1][i], rhs_buffers[1][i]);
-        }
-    }
-
-    template <typename T>
-    void compare_values(const sp::primitive_array<T>& pa1, const sp::primitive_array<T>& pa2)
-    {
-        CHECK_EQ(pa1.size(), pa1.size());
-        for (size_t i = 0; i < pa1.size(); ++i)
-        {
-            CHECK_EQ(pa1[i], pa2[i]);
-        }
-    }
-
     template <typename T>
     void compare_bitmap(const sp::primitive_array<T>& pa1, const sp::primitive_array<T>& pa2)
     {
@@ -121,22 +36,9 @@ namespace sparrow_ipc
     }
 
     template <typename T>
-    void compare_primitive_arrays(sp::primitive_array<T>& ar, sp::primitive_array<T>& deserialized_ar)
+    void compare_primitive_arrays(const sp::primitive_array<T>& ar, const sp::primitive_array<T>& deserialized_ar)
     {
-        const auto [arrow_array_ar, arrow_schema_ar] = sp::get_arrow_structures(ar);
-        const auto [arrow_array_deserialized_ar, arrow_schema_deserialized_ar] = sp::get_arrow_structures(deserialized_ar);
-
-        // Check ArrowSchema equality
-        REQUIRE_NE(arrow_schema_ar, nullptr);
-        REQUIRE_NE(arrow_schema_deserialized_ar, nullptr);
-        compare_arrow_schemas(*arrow_schema_ar, *arrow_schema_deserialized_ar);
-
-        // Check ArrowArray equality
-        REQUIRE_NE(arrow_array_ar, nullptr);
-        REQUIRE_NE(arrow_array_deserialized_ar, nullptr);
-        compare_arrow_arrays(*arrow_array_ar, *arrow_array_deserialized_ar);
-
-//         compare_values<T>(ar, deserialized_ar);
+        CHECK_EQ(ar, deserialized_ar);
         compare_bitmap<T>(ar, deserialized_ar);
         compare_metadata(ar, deserialized_ar);
     }