From 812a20866b078b9354f477e3e7924f0f56b35535 Mon Sep 17 00:00:00 2001
From: Milan Kriz <milan.kriz@eccam.com>
Date: Wed, 4 Oct 2023 16:45:31 +0200
Subject: [PATCH] Extend C++ runtime tests for Traits.h

---
 .../extensions/cpp/runtime/src/CMakeLists.txt |   1 +
 .../cpp/runtime/test/zserio/TraitsTest.cpp    | 155 ++++++++++++++++++
 2 files changed, 156 insertions(+)

diff --git a/compiler/extensions/cpp/runtime/src/CMakeLists.txt b/compiler/extensions/cpp/runtime/src/CMakeLists.txt
index 9d26ebf00..e26f1441a 100644
--- a/compiler/extensions/cpp/runtime/src/CMakeLists.txt
+++ b/compiler/extensions/cpp/runtime/src/CMakeLists.txt
@@ -93,6 +93,7 @@ set(ZSERIO_CPP_RUNTIME_LIB_SRCS
     zserio/SqliteFinalizer.h
     zserio/StringConvertUtil.h
     zserio/StringView.h
+    zserio/Traits.h
     zserio/TypeInfo.h
     zserio/TypeInfoUtil.cpp
     zserio/TypeInfoUtil.h
diff --git a/compiler/extensions/cpp/runtime/test/zserio/TraitsTest.cpp b/compiler/extensions/cpp/runtime/test/zserio/TraitsTest.cpp
index 9af3e3341..15e613fd9 100644
--- a/compiler/extensions/cpp/runtime/test/zserio/TraitsTest.cpp
+++ b/compiler/extensions/cpp/runtime/test/zserio/TraitsTest.cpp
@@ -40,6 +40,21 @@ class DummyObjectInitializeChildren
     void initializeChildren() {}
 };
 
+class DummyOwner
+{};
+
+class DummyObjectWithOwnerType
+{
+public:
+    using OwnerType = DummyOwner;
+};
+
+class DummyObjectWithAllocator
+{
+public:
+    using allocator_type = std::allocator<uint8_t>;
+};
+
 class DummyObjectReflectable
 {
 public:
@@ -56,6 +71,30 @@ class DummyObjectWithPackingContext
     {};
 };
 
+class DummyObjectInitializeOffset
+{
+public:
+    using OwnerType = DummyOwner;
+
+    void initializeOffset(OwnerType&, size_t, size_t) {}
+};
+
+class DummyObjectCheckOffset
+{
+public:
+    using OwnerType = DummyOwner;
+
+    void checkOffset(const OwnerType&, size_t, size_t) {}
+};
+
+class DummyObjectInitializeElement
+{
+public:
+    using OwnerType = DummyOwner;
+
+    void initializeElement(OwnerType&, DummyObjectInitializeChildren&, size_t) {}
+};
+
 class DummyBitmask
 {
 public:
@@ -89,6 +128,7 @@ TEST(TraitsTest, isAllocator)
     ASSERT_FALSE(is_allocator<uint64_t>::value);
     ASSERT_FALSE(is_allocator<std::vector<uint8_t>>::value);
     ASSERT_FALSE(is_allocator<AnyHolder<>>::value);
+    ASSERT_FALSE(is_allocator<DummyObjectWithAllocator>::value);
 }
 
 TEST(TraitsTest, isFirstAllocator)
@@ -106,6 +146,49 @@ TEST(TraitsTest, isFirstAllocator)
     assertFalse(is_first_allocator<int, std::allocator<uint8_t>, std::allocator<uint8_t>>::value);
     assertFalse(is_first_allocator<int, pmr::PolymorphicAllocator<uint8_t>, std::allocator<uint8_t>>::value);
     assertFalse(is_first_allocator<char, pmr::PolymorphicAllocator<uint8_t>>::value);
+    assertFalse(is_first_allocator<DummyObjectWithAllocator, pmr::PolymorphicAllocator<uint8_t>>::value);
+}
+
+TEST(TraitsTest, hasOwnerType)
+{
+    ASSERT_TRUE(has_owner_type<DummyObjectWithOwnerType>::value);
+    ASSERT_TRUE(has_owner_type<DummyObjectInitializeOffset>::value);
+    ASSERT_TRUE(has_owner_type<DummyObjectCheckOffset>::value);
+    ASSERT_TRUE(has_owner_type<DummyObjectInitializeElement>::value);
+    ASSERT_FALSE(has_owner_type<DummyObjectInitialize>::value);
+    ASSERT_FALSE(has_owner_type<DummyObjectInitializeChildren>::value);
+    ASSERT_FALSE(has_owner_type<DummyObjectWithPackingContext>::value);
+    ASSERT_FALSE(has_owner_type<DummyObjectWithAllocator>::value);
+    ASSERT_FALSE(has_owner_type<DummyBitmask>::value);
+    ASSERT_FALSE(has_owner_type<std::string>::value);
+    ASSERT_FALSE(has_owner_type<std::vector<uint8_t>>::value);
+    ASSERT_FALSE(has_owner_type<std::vector<DummyObjectWithOwnerType>>::value);
+}
+
+TEST(TraitsTest, hasZserioPackingContext)
+{
+    ASSERT_TRUE(has_zserio_packing_context<DummyObjectWithPackingContext>::value);
+    ASSERT_FALSE(has_zserio_packing_context<DummyObjectInitialize>::value);
+    ASSERT_FALSE(has_zserio_packing_context<DummyObjectInitializeChildren>::value);
+    ASSERT_FALSE(has_zserio_packing_context<DummyObjectWithOwnerType>::value);
+    ASSERT_FALSE(has_zserio_packing_context<DummyObjectWithAllocator>::value);
+    ASSERT_FALSE(has_zserio_packing_context<DummyBitmask>::value);
+    ASSERT_FALSE(has_zserio_packing_context<std::string>::value);
+    ASSERT_FALSE(has_zserio_packing_context<std::vector<uint8_t>>::value);
+    ASSERT_FALSE(has_zserio_packing_context<std::vector<DummyObjectWithPackingContext>>::value);
+}
+
+TEST(TraitsTest, hasAllocator)
+{
+    ASSERT_TRUE(has_allocator<DummyObjectWithAllocator>::value);
+    ASSERT_TRUE(has_allocator<std::string>::value);
+    ASSERT_TRUE(has_allocator<std::vector<uint8_t>>::value);
+    ASSERT_TRUE(has_allocator<std::vector<DummyObjectWithAllocator>>::value);
+    ASSERT_FALSE(has_allocator<DummyObjectInitialize>::value);
+    ASSERT_FALSE(has_allocator<DummyObjectInitializeChildren>::value);
+    ASSERT_FALSE(has_allocator<DummyObjectWithOwnerType>::value);
+    ASSERT_FALSE(has_allocator<DummyObjectWithPackingContext>::value);
+    ASSERT_FALSE(has_allocator<DummyBitmask>::value);
 }
 
 TEST(TraitsTest, hasInitialize)
@@ -113,6 +196,8 @@ TEST(TraitsTest, hasInitialize)
     ASSERT_TRUE(has_initialize<DummyObjectInitialize>::value);
     DummyObjectInitialize().initialize();
     ASSERT_FALSE(has_initialize<DummyObjectInitializeChildren>::value);
+    ASSERT_FALSE(has_initialize<DummyObjectWithOwnerType>::value);
+    ASSERT_FALSE(has_initialize<DummyObjectWithPackingContext>::value);
     ASSERT_FALSE(has_initialize<DummyBitmask>::value);
     ASSERT_FALSE(has_initialize<std::string>::value);
     ASSERT_FALSE(has_initialize<std::vector<uint8_t>>::value);
@@ -123,6 +208,8 @@ TEST(TraitsTest, hasInitializeChildren)
     ASSERT_TRUE(has_initialize_children<DummyObjectInitializeChildren>::value);
     DummyObjectInitializeChildren().initializeChildren();
     ASSERT_FALSE(has_initialize_children<DummyObjectInitialize>::value);
+    ASSERT_FALSE(has_initialize_children<DummyObjectWithOwnerType>::value);
+    ASSERT_FALSE(has_initialize_children<DummyObjectWithPackingContext>::value);
     ASSERT_FALSE(has_initialize_children<DummyBitmask>::value);
     ASSERT_FALSE(has_initialize_children<std::string>::value);
     ASSERT_FALSE(has_initialize_children<std::vector<uint8_t>>::value);
@@ -133,21 +220,89 @@ TEST(TraitsTest, hasReflectable)
     ASSERT_TRUE(has_reflectable<DummyObjectReflectable>::value);
     ASSERT_EQ(nullptr, DummyObjectReflectable().reflectable());
     ASSERT_FALSE(has_reflectable<DummyObjectInitialize>::value);
+    ASSERT_FALSE(has_reflectable<DummyObjectWithOwnerType>::value);
+    ASSERT_FALSE(has_reflectable<DummyObjectWithPackingContext>::value);
+    ASSERT_FALSE(has_reflectable<DummyObjectWithAllocator>::value);
     ASSERT_FALSE(has_reflectable<DummyBitmask>::value);
     ASSERT_FALSE(has_reflectable<std::string>::value);
     ASSERT_FALSE(has_reflectable<std::vector<uint8_t>>::value);
 }
 
+TEST(TraitsTest, hasInitializeOffset)
+{
+    ASSERT_TRUE(has_initialize_offset<DummyObjectInitializeOffset>::value);
+    DummyOwner owner;
+    DummyObjectInitializeOffset().initializeOffset(owner, 0, 0);
+    ASSERT_FALSE(has_initialize_offset<DummyObjectCheckOffset>::value);
+    ASSERT_FALSE(has_initialize_offset<DummyObjectInitializeElement>::value);
+    ASSERT_FALSE(has_initialize_offset<DummyObjectInitialize>::value);
+    ASSERT_FALSE(has_initialize_offset<DummyObjectInitializeChildren>::value);
+    ASSERT_FALSE(has_initialize_offset<DummyObjectReflectable>::value);
+    ASSERT_FALSE(has_initialize_offset<DummyObjectWithOwnerType>::value);
+    ASSERT_FALSE(has_initialize_offset<DummyObjectWithAllocator>::value);
+    ASSERT_FALSE(has_initialize_offset<DummyObjectWithPackingContext>::value);
+}
+
+TEST(TraitsTest, hasCheckOffset)
+{
+    ASSERT_TRUE(has_check_offset<DummyObjectCheckOffset>::value);
+    DummyObjectCheckOffset().checkOffset(DummyOwner(), 0, 0);
+    ASSERT_FALSE(has_check_offset<DummyObjectInitializeOffset>::value);
+    ASSERT_FALSE(has_check_offset<DummyObjectInitializeElement>::value);
+    ASSERT_FALSE(has_check_offset<DummyObjectInitialize>::value);
+    ASSERT_FALSE(has_check_offset<DummyObjectInitializeChildren>::value);
+    ASSERT_FALSE(has_check_offset<DummyObjectReflectable>::value);
+    ASSERT_FALSE(has_check_offset<DummyObjectWithOwnerType>::value);
+    ASSERT_FALSE(has_check_offset<DummyObjectWithAllocator>::value);
+    ASSERT_FALSE(has_check_offset<DummyObjectWithPackingContext>::value);
+}
+
+TEST(TraitsTest, hasInitializeElement)
+{
+    ASSERT_TRUE(has_initialize_element<DummyObjectInitializeElement>::value);
+    DummyOwner owner;
+    DummyObjectInitializeChildren element;
+    DummyObjectInitializeElement().initializeElement(owner, element, 0);
+    ASSERT_FALSE(has_initialize_element<DummyObjectInitializeOffset>::value);
+    ASSERT_FALSE(has_initialize_element<DummyObjectCheckOffset>::value);
+    ASSERT_FALSE(has_initialize_element<DummyObjectInitialize>::value);
+    ASSERT_FALSE(has_initialize_element<DummyObjectInitializeChildren>::value);
+    ASSERT_FALSE(has_initialize_element<DummyObjectReflectable>::value);
+    ASSERT_FALSE(has_initialize_element<DummyObjectWithOwnerType>::value);
+    ASSERT_FALSE(has_initialize_element<DummyObjectWithAllocator>::value);
+    ASSERT_FALSE(has_initialize_element<DummyObjectWithPackingContext>::value);
+}
+
 TEST(TraitsTest, isBitmask)
 {
     ASSERT_TRUE(is_bitmask<DummyBitmask>::value);
     ASSERT_EQ(0, DummyBitmask().getValue());
     ASSERT_FALSE(is_bitmask<DummyObjectInitializeChildren>::value);
     ASSERT_FALSE(is_bitmask<DummyObjectInitialize>::value);
+    ASSERT_FALSE(is_bitmask<DummyObjectWithOwnerType>::value);
+    ASSERT_FALSE(is_bitmask<DummyObjectWithPackingContext>::value);
+    ASSERT_FALSE(is_bitmask<DummyObjectWithAllocator>::value);
     ASSERT_FALSE(is_bitmask<std::string>::value);
     ASSERT_FALSE(is_bitmask<std::vector<uint8_t>>::value);
 }
 
+TEST(TraitsTest, isSpan)
+{
+    ASSERT_TRUE(is_span<zserio::Span<uint8_t>>::value);
+    ASSERT_TRUE(is_span<zserio::Span<const uint8_t>>::value);
+    ASSERT_TRUE(is_span<zserio::Span<char* const>>::value);
+    ASSERT_TRUE(is_span<zserio::Span<char*>>::value);
+    assertFalse(is_span<std::array<uint8_t, 2>>::value);
+    ASSERT_FALSE(is_span<std::vector<uint8_t>>::value);
+    ASSERT_FALSE(is_span<uint8_t>::value);
+    ASSERT_FALSE(is_span<std::string>::value);
+    ASSERT_FALSE(is_span<DummyObjectInitializeChildren>::value);
+    ASSERT_FALSE(is_span<DummyObjectInitialize>::value);
+    ASSERT_FALSE(is_span<DummyObjectWithOwnerType>::value);
+    ASSERT_FALSE(is_span<DummyObjectWithPackingContext>::value);
+    ASSERT_FALSE(is_span<DummyObjectWithAllocator>::value);
+}
+
 TEST(TraitsTest, isFieldConstructorEnabled)
 {
     assertTrue(has_field_ctor<int, DummyObjectInitialize, std::allocator<uint8_t>>::value);