iox-#2301 Fix tests for 32 bit builds

iceoryx_binding_c/source/c_subscriber.cpp

@@ -110,8 +110,9 @@ iox_sub_t iox_sub_init(iox_sub_storage_t* self,
     auto meWithStoragePointer = new SubscriberWithStoragePointer();
     meWithStoragePointer->subscriberStorage = self;
     auto me = &meWithStoragePointer->subscriber;
-    assert(reinterpret_cast<uint64_t>(me) - reinterpret_cast<uint64_t>(meWithStoragePointer) == sizeof(void*)
-           && "Size mismatch for SubscriberWithStoragePointer!");
+    auto ptrDiff = reinterpret_cast<size_t>(me) - reinterpret_cast<size_t>(meWithStoragePointer);
+    IOX_ENFORCE(ptrDiff >= sizeof(void*), "Size mismatch for SubscriberWithStoragePointer!");
+    IOX_ENFORCE(ptrDiff <= 2 * sizeof(void*), "Size mismatch for SubscriberWithStoragePointer!");
 
     me->m_portData =
         PoshRuntime::getInstance().getMiddlewareSubscriber(ServiceDescription{IdString_t(TruncateToCapacity, service),

iceoryx_binding_c/test/moduletests/test_client.cpp

@@ -109,7 +109,7 @@ class iox_client_test : public Test
     char managementMemory[MANAGEMENT_MEMORY_SIZE];
     iox::BumpAllocator mgmtAllocator{managementMemory, MANAGEMENT_MEMORY_SIZE};
     static constexpr uint64_t DATA_MEMORY_SIZE = 1024 * 1024;
-    char dataMemory[DATA_MEMORY_SIZE];
+    alignas(8) char dataMemory[DATA_MEMORY_SIZE];
     iox::BumpAllocator dataAllocator{dataMemory, DATA_MEMORY_SIZE};
     iox::mepoo::MemoryManager memoryManager;
     iox::mepoo::MePooConfig memoryConfig;

iceoryx_binding_c/test/moduletests/test_publisher.cpp

@@ -97,7 +97,7 @@ class iox_pub_test : public Test
     }
 
     static constexpr size_t MEMORY_SIZE = 1024 * 1024;
-    uint8_t m_memory[MEMORY_SIZE];
+    alignas(8) uint8_t m_memory[MEMORY_SIZE];
     static constexpr uint32_t NUM_CHUNKS_IN_POOL = 20;
     static constexpr uint64_t CHUNK_SIZE = 256;
 

iceoryx_binding_c/test/moduletests/test_server.cpp

@@ -104,7 +104,7 @@ class iox_server_test : public Test
     char managementMemory[MANAGEMENT_MEMORY_SIZE];
     iox::BumpAllocator mgmtAllocator{managementMemory, MANAGEMENT_MEMORY_SIZE};
     static constexpr uint64_t DATA_MEMORY_SIZE = 1024 * 1024;
-    char dataMemory[DATA_MEMORY_SIZE];
+    alignas(8) char dataMemory[DATA_MEMORY_SIZE];
     iox::BumpAllocator dataAllocator{dataMemory, DATA_MEMORY_SIZE};
     iox::mepoo::MemoryManager memoryManager;
     iox::mepoo::MePooConfig memoryConfig;

iceoryx_binding_c/test/moduletests/test_subscriber.cpp

@@ -25,6 +25,7 @@
 #include "iceoryx_posh/internal/popo/ports/subscriber_port_user.hpp"
 #include "iceoryx_posh/mepoo/mepoo_config.hpp"
 #include "iox/detail/hoofs_error_reporting.hpp"
+#include "iox/detail/system_configuration.hpp"
 
 #include "iceoryx_hoofs/testing/fatal_failure.hpp"
 #include "iceoryx_posh/roudi_env/minimal_iceoryx_config.hpp"
@@ -98,8 +99,8 @@ class iox_sub_test : public Test
     }
 
     static iox_sub_t m_triggerCallbackLatestArgument;
-    static constexpr size_t MEMORY_SIZE = 1024 * 1024 * 100;
-    uint8_t m_memory[MEMORY_SIZE];
+    static constexpr size_t MEMORY_SIZE = 1024 * 1024;
+    alignas(8) uint8_t m_memory[MEMORY_SIZE];
     static constexpr uint32_t NUM_CHUNKS_IN_POOL = MAX_CHUNKS_HELD_PER_SUBSCRIBER_SIMULTANEOUSLY + 2U;
     static constexpr uint64_t CHUNK_SIZE = 128U;
 
@@ -145,6 +146,12 @@ TEST_F(iox_sub_test, initSubscriberWithNotInitializedSubscriberOptionsTerminates
 TEST_F(iox_sub_test, initSubscriberWithDefaultOptionsWorks)
 {
     ::testing::Test::RecordProperty("TEST_ID", "40eaa006-4781-46cd-bde3-40fa7d572f29");
+
+    if (iox::detail::isCompiledOn32BitSystem())
+    {
+        GTEST_SKIP() << "@todo: 2310 This test does not work on 32 bit builds due to the usage of RouDiEnv";
+    }
+
     RouDiEnv roudiEnv;
 
     iox_runtime_init("hypnotoad");
@@ -402,6 +409,12 @@ TEST_F(iox_sub_test, hasDataTriggersWaitSetWithCorrectCallback)
 TEST_F(iox_sub_test, deinitSubscriberDetachesTriggerFromWaitSet)
 {
     ::testing::Test::RecordProperty("TEST_ID", "93e350fb-5430-43ff-982b-b43c6ae9b890");
+
+    if (iox::detail::isCompiledOn32BitSystem())
+    {
+        GTEST_SKIP() << "@todo: 2310 This test does not work on 32 bit builds due to the usage of RouDiEnv";
+    }
+
     RouDiEnv roudiEnv;
     iox_runtime_init("hypnotoad");
 

iceoryx_hoofs/test/moduletests/test_time_unit_duration.cpp

@@ -1050,7 +1050,7 @@ TEST(Duration_test, ConvertTimespecWithNoneReferenceFromDurationMoreThanOneSecon
 TEST(Duration_test, ConvertTimespecWithNoneReferenceFromDurationResultsNotYetInSaturation)
 {
     ::testing::Test::RecordProperty("TEST_ID", "70f11b99-78ec-442a-aefe-4dd9152b7903");
-    constexpr int64_t SECONDS{std::numeric_limits<int64_t>::max()};
+    constexpr int64_t SECONDS{std::numeric_limits<decltype(timespec::tv_sec)>::max()};
     constexpr int64_t NANOSECONDS{NANOSECS_PER_SECOND - 1U};
 
     auto duration = createDuration(SECONDS, NANOSECONDS);
@@ -1064,7 +1064,7 @@ TEST(Duration_test, ConvertTimespecWithNoneReferenceFromDurationResultsNotYetInS
 TEST(Duration_test, ConvertTimespecWithNoneReferenceFromMaxDurationResultsInSaturation)
 {
     ::testing::Test::RecordProperty("TEST_ID", "3bf4bb34-46f3-4889-84f5-9220b32fff73");
-    constexpr int64_t SECONDS{std::numeric_limits<int64_t>::max()};
+    constexpr int64_t SECONDS{std::numeric_limits<decltype(timespec::tv_sec)>::max()};
     constexpr int64_t NANOSECONDS{NANOSECS_PER_SECOND - 1U};
 
     const timespec sut = DurationAccessor::max().timespec(iox::units::TimeSpecReference::None);
@@ -1101,7 +1101,7 @@ TEST(Duration_test, ConvertTimespecWithMonotonicReference)
 TEST(Duration_test, ConvertTimespecWithMonotonicReferenceFromMaxDurationResultsInSaturation)
 {
     ::testing::Test::RecordProperty("TEST_ID", "ff5a1fe2-65c8-490a-b31d-4d8ea615c91a");
-    constexpr int64_t SECONDS{std::numeric_limits<int64_t>::max()};
+    constexpr int64_t SECONDS{std::numeric_limits<decltype(timespec::tv_sec)>::max()};
     constexpr int64_t NANOSECONDS{NANOSECS_PER_SECOND - 1U};
 
     const timespec sut = DurationAccessor::max().timespec(iox::units::TimeSpecReference::Monotonic);
@@ -1129,7 +1129,7 @@ TEST(Duration_test, ConvertTimespecWithEpochReference)
 TEST(Duration_test, ConvertTimespecWithEpochReferenceFromMaxDurationResultsInSaturation)
 {
     ::testing::Test::RecordProperty("TEST_ID", "97ff4204-a7f7-43ef-b81e-0e359d1dce93");
-    constexpr int64_t SECONDS{std::numeric_limits<int64_t>::max()};
+    constexpr int64_t SECONDS{std::numeric_limits<decltype(timespec::tv_sec)>::max()};
     constexpr int64_t NANOSECONDS{NANOSECS_PER_SECOND - 1U};
 
     const timespec sut = DurationAccessor::max().timespec(iox::units::TimeSpecReference::Epoch);

iceoryx_hoofs/testing/CMakeLists.txt

@@ -38,6 +38,9 @@ iox_add_library(
         error_reporting/testing_support.cpp
 )
 
+# deactivate _FORTIFY_SOURCE since it causes issues with longjmp in the testing logger and error handler
+target_compile_options(iceoryx_hoofs_testing PRIVATE -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=0)
+
 if(TEST_WITH_ADDITIONAL_USER)
     target_compile_definitions(iceoryx_hoofs_testing PUBLIC -DTEST_WITH_ADDITIONAL_USER)
 endif(TEST_WITH_ADDITIONAL_USER)

iceoryx_posh/test/moduletests/test_mepoo_mempool.cpp

@@ -20,6 +20,7 @@
 #include "iceoryx_posh/internal/posh_error_reporting.hpp"
 #include "iox/bump_allocator.hpp"
 #include "iox/detail/hoofs_error_reporting.hpp"
+#include "iox/detail/system_configuration.hpp"
 
 #include "iceoryx_hoofs/testing/fatal_failure.hpp"
 #include "test.hpp"
@@ -46,9 +47,6 @@ class MemPool_test : public Test
     {
     }
 
-    void SetUp(){};
-    void TearDown(){};
-
     alignas(MemPool::CHUNK_MEMORY_ALIGNMENT) uint8_t
         m_rawMemory[NUMBER_OF_CHUNKS * CHUNK_SIZE + LOFFLI_MEMORY_REQUIREMENT];
     iox::BumpAllocator allocator;
@@ -138,14 +136,23 @@ TEST_F(MemPool_test, MempoolPointeToIndexConversionForMemoryOffsetsLargerThan4GB
     constexpr uint64_t GB{1ULL << 30};
     constexpr uint64_t CHUNK_SIZE{128 * MB};
     constexpr uint64_t RAW_MEMORY_BASE{0x7f60d90c5000ULL};
-    uint8_t* const RAW_MEMORY_PTR{reinterpret_cast<uint8_t*>(RAW_MEMORY_BASE)};
-    constexpr uint32_t EXPECTED_INDEX{42};
-    uint8_t* const CHUNK_PTR{RAW_MEMORY_PTR + static_cast<uint64_t>(EXPECTED_INDEX) * CHUNK_SIZE};
 
-    const auto index = MemPool::pointerToIndex(CHUNK_PTR, CHUNK_SIZE, RAW_MEMORY_PTR);
+    if constexpr (iox::detail::isCompiledOn32BitSystem())
+    {
+        GTEST_SKIP() << "This test does not work on 32 bit builds since it requires pointer larger than the 32 bit "
+                        "address space";
+    }
+    else
+    {
+        uint8_t* const RAW_MEMORY_PTR{reinterpret_cast<uint8_t*>(RAW_MEMORY_BASE)};
+        constexpr uint32_t EXPECTED_INDEX{42};
+        uint8_t* const CHUNK_PTR{RAW_MEMORY_PTR + static_cast<uint64_t>(EXPECTED_INDEX) * CHUNK_SIZE};
 
-    EXPECT_THAT(index, Eq(EXPECTED_INDEX));
-    EXPECT_THAT(reinterpret_cast<uint64_t>(CHUNK_PTR) - RAW_MEMORY_BASE, Gt(5 * GB));
+        const auto index = MemPool::pointerToIndex(CHUNK_PTR, CHUNK_SIZE, RAW_MEMORY_PTR);
+
+        EXPECT_THAT(index, Eq(EXPECTED_INDEX));
+        EXPECT_THAT(reinterpret_cast<uint64_t>(CHUNK_PTR) - RAW_MEMORY_BASE, Gt(5 * GB));
+    }
 }
 
 TEST_F(MemPool_test, MempoolCtorInitialisesTheObjectWithValuesPassedToTheCtor)

iceoryx_posh/test/moduletests/test_mepoo_segment.cpp

@@ -90,7 +90,7 @@ class MePooSegment_test : public Test
         uint64_t m_memorySizeInBytes{0};
         void* m_baseAddressHint{nullptr};
         static constexpr int MEM_SIZE = 100000;
-        char memory[MEM_SIZE];
+        alignas(8) char memory[MEM_SIZE];
         shm_handle_t filehandle;
         static createFct createVerificator;
     };