From ad37b6bb1d7947a355af34901bd9d928b7a43f7f Mon Sep 17 00:00:00 2001 From: Simon Hoinkis Date: Thu, 29 Sep 2022 14:08:48 +0200 Subject: [PATCH] iox-#605 Remove superfluous namespace and extend release note entry Signed-off-by: Simon Hoinkis --- .../release-notes/iceoryx-unreleased.md | 4 +- .../moduletests/test_relative_pointer.cpp | 110 +++++++++--------- 2 files changed, 56 insertions(+), 58 deletions(-) diff --git a/doc/website/release-notes/iceoryx-unreleased.md b/doc/website/release-notes/iceoryx-unreleased.md index 4048a55dc24..777a2e10cad 100644 --- a/doc/website/release-notes/iceoryx-unreleased.md +++ b/doc/website/release-notes/iceoryx-unreleased.md @@ -403,12 +403,12 @@ } ``` -21. Renamed `BaseRelativePointer` to `UntypedRelativePointer` +21. Renamed `BaseRelativePointer` to `UntypedRelativePointer` and moved it from namespace `rp::` to `memory::` ```cpp // before #include "iceoryx_hoofs/internal/memory/base_relative_pointer.hpp" - iox::memory::BaseRelativePointer myUntypedRelativePointer; + iox::rp::BaseRelativePointer myUntypedRelativePointer; // after #include "iceoryx_hoofs/memory/relative_pointer.hpp" diff --git a/iceoryx_hoofs/test/moduletests/test_relative_pointer.cpp b/iceoryx_hoofs/test/moduletests/test_relative_pointer.cpp index ca9658edc4b..1f181b9d1f8 100644 --- a/iceoryx_hoofs/test/moduletests/test_relative_pointer.cpp +++ b/iceoryx_hoofs/test/moduletests/test_relative_pointer.cpp @@ -78,13 +78,11 @@ TYPED_TEST(RelativePointer_test, ConstrTests) ::testing::Test::RecordProperty("TEST_ID", "cae7b4d4-86eb-42f6-b938-90a76f01bea5"); // NOLINTJUSTIFICATION Pointer arithmetic needed for tests // NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast) - EXPECT_EQ(RelativePointer::registerPtrWithId(iox::memory::segment_id_t{1U}, - reinterpret_cast(this->memoryPartition[0]), - SHARED_MEMORY_SIZE), + EXPECT_EQ(RelativePointer::registerPtrWithId( + segment_id_t{1U}, reinterpret_cast(this->memoryPartition[0]), SHARED_MEMORY_SIZE), true); - EXPECT_EQ(RelativePointer::registerPtrWithId(iox::memory::segment_id_t{2U}, - reinterpret_cast(this->memoryPartition[1]), - SHARED_MEMORY_SIZE), + EXPECT_EQ(RelativePointer::registerPtrWithId( + segment_id_t{2U}, reinterpret_cast(this->memoryPartition[1]), SHARED_MEMORY_SIZE), true); // NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast) @@ -190,10 +188,10 @@ TYPED_TEST(RelativePointer_test, AssignmentOperatorTests) // NOLINTJUSTIFICATION Pointer arithmetic needed for tests // NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast) EXPECT_EQ(RelativePointer::registerPtrWithId( - iox::memory::segment_id_t{1U}, reinterpret_cast(ptr0), SHARED_MEMORY_SIZE), + segment_id_t{1U}, reinterpret_cast(ptr0), SHARED_MEMORY_SIZE), true); EXPECT_EQ(RelativePointer::registerPtrWithId( - iox::memory::segment_id_t{2U}, reinterpret_cast(ptr1), SHARED_MEMORY_SIZE), + segment_id_t{2U}, reinterpret_cast(ptr1), SHARED_MEMORY_SIZE), true); // NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast) @@ -289,8 +287,8 @@ TYPED_TEST(RelativePointer_test, IdAndOffsetAreTranslatedToRawPointerCorrectly) // No pointer arithmetic involved hence reinterpret_cast can be avoided auto* typedPtr = static_cast(static_cast(ptr)); - RelativePointer rp1(typedPtr, iox::memory::segment_id_t{1U}); - EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), true); + RelativePointer rp1(typedPtr, segment_id_t{1U}); + EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), true); // NOLINTJUSTIFICATION Pointer arithmetic needed for tests // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) EXPECT_EQ(rp1.getOffset(), reinterpret_cast(typedPtr)); @@ -300,7 +298,7 @@ TYPED_TEST(RelativePointer_test, IdAndOffsetAreTranslatedToRawPointerCorrectly) // NOLINTJUSTIFICATION Pointer arithmetic needed for tests // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast) auto* addressAtOffset = reinterpret_cast(ptr + offset); - RelativePointer rp2(addressAtOffset, iox::memory::segment_id_t{1U}); + RelativePointer rp2(addressAtOffset, segment_id_t{1U}); EXPECT_EQ(rp2.getOffset(), offset); EXPECT_EQ(rp2.getId(), 1U); EXPECT_EQ(rp2.get(), addressAtOffset); @@ -313,16 +311,16 @@ TYPED_TEST(RelativePointer_test, GetOffsetReturnsCorrectOffset) // No pointer arithmetic involved hence reinterpret_cast can be avoided auto* typedPtr = static_cast(static_cast(ptr)); - RelativePointer rp1(typedPtr, iox::memory::segment_id_t{1U}); - EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), true); - EXPECT_EQ(UntypedRelativePointer::getOffset(iox::memory::segment_id_t{1U}, typedPtr), 0U); + RelativePointer rp1(typedPtr, segment_id_t{1U}); + EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), true); + EXPECT_EQ(UntypedRelativePointer::getOffset(segment_id_t{1U}, typedPtr), 0U); int offset = SHARED_MEMORY_SIZE / 2U; // NOLINTJUSTIFICATION Pointer arithmetic needed for tests // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast) auto* addressAtOffset = reinterpret_cast(ptr + offset); - RelativePointer rp2(addressAtOffset, iox::memory::segment_id_t{1U}); - EXPECT_EQ(UntypedRelativePointer::getOffset(iox::memory::segment_id_t{1U}, addressAtOffset), offset); + RelativePointer rp2(addressAtOffset, segment_id_t{1U}); + EXPECT_EQ(UntypedRelativePointer::getOffset(segment_id_t{1U}, addressAtOffset), offset); } TYPED_TEST(RelativePointer_test, GetPtrReturnsAddressWithCorrectOffset) @@ -331,16 +329,16 @@ TYPED_TEST(RelativePointer_test, GetPtrReturnsAddressWithCorrectOffset) auto* ptr = this->partitionPtr(0U); // No pointer arithmetic involved hence reinterpret_cast can be avoided auto* typedPtr = static_cast(static_cast(this->partitionPtr(0U))); - RelativePointer rp1(typedPtr, iox::memory::segment_id_t{1U}); - EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), true); - EXPECT_EQ(UntypedRelativePointer::getPtr(iox::memory::segment_id_t{1U}, 0), typedPtr); + RelativePointer rp1(typedPtr, segment_id_t{1U}); + EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), true); + EXPECT_EQ(UntypedRelativePointer::getPtr(segment_id_t{1U}, 0), typedPtr); uint64_t offset = SHARED_MEMORY_SIZE / 2U; // NOLINTJUSTIFICATION Pointer arithmetic needed for tests // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic, cppcoreguidelines-pro-type-reinterpret-cast) auto* addressAtOffset = reinterpret_cast(ptr + offset); - RelativePointer rp2(addressAtOffset, iox::memory::segment_id_t{1}); - EXPECT_EQ(UntypedRelativePointer::getPtr(iox::memory::segment_id_t{1U}, offset), addressAtOffset); + RelativePointer rp2(addressAtOffset, segment_id_t{1}); + EXPECT_EQ(UntypedRelativePointer::getPtr(segment_id_t{1U}, offset), addressAtOffset); } TYPED_TEST(RelativePointer_test, RegisteringAndUnregisteringRelativePointerWorks) @@ -349,12 +347,12 @@ TYPED_TEST(RelativePointer_test, RegisteringAndUnregisteringRelativePointerWorks // No pointer arithmetic involved hence reinterpret_cast can be avoided auto* typedPtr = static_cast(static_cast(this->partitionPtr(0U))); - RelativePointer rp1(typedPtr, iox::memory::segment_id_t{1U}); + RelativePointer rp1(typedPtr, segment_id_t{1U}); - EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), true); - EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), false); - EXPECT_EQ(rp1.unregisterPtr(iox::memory::segment_id_t{1U}), true); - EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), true); + EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), true); + EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), false); + EXPECT_EQ(rp1.unregisterPtr(segment_id_t{1U}), true); + EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), true); } @@ -365,11 +363,11 @@ TYPED_TEST(RelativePointer_test, UnRegisteringOneRelativePointerWorks) // No pointer arithmetic involved hence reinterpret_cast can be avoided auto* typedPtr = static_cast(static_cast(ptr)); - RelativePointer rp1(typedPtr, iox::memory::segment_id_t{1U}); + RelativePointer rp1(typedPtr, segment_id_t{1U}); - rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr); - EXPECT_EQ(rp1.unregisterPtr(iox::memory::segment_id_t{1U}), true); - EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr), true); + rp1.registerPtrWithId(segment_id_t{1U}, typedPtr); + EXPECT_EQ(rp1.unregisterPtr(segment_id_t{1U}), true); + EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr), true); } TYPED_TEST(RelativePointer_test, UnregisteringAllRelativePointerWorks) @@ -380,14 +378,14 @@ TYPED_TEST(RelativePointer_test, UnregisteringAllRelativePointerWorks) auto* typedPtr0 = static_cast(static_cast(this->partitionPtr(0U))); auto* typedPtr1 = static_cast(static_cast(this->partitionPtr(1U))); - RelativePointer rp1(typedPtr0, iox::memory::segment_id_t{1U}); - RelativePointer rp2(typedPtr1, iox::memory::segment_id_t{9999U}); + RelativePointer rp1(typedPtr0, segment_id_t{1U}); + RelativePointer rp2(typedPtr1, segment_id_t{9999U}); - EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr0), true); - EXPECT_EQ(rp2.registerPtrWithId(iox::memory::segment_id_t{9999U}, typedPtr1), true); + EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr0), true); + EXPECT_EQ(rp2.registerPtrWithId(segment_id_t{9999U}, typedPtr1), true); UntypedRelativePointer::unregisterAll(); - EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr0), true); - EXPECT_EQ(rp2.registerPtrWithId(iox::memory::segment_id_t{9999U}, typedPtr1), true); + EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr0), true); + EXPECT_EQ(rp2.registerPtrWithId(segment_id_t{9999U}, typedPtr1), true); } TYPED_TEST(RelativePointer_test, RegisterPtrWithIdFailsWhenTooLarge) @@ -397,11 +395,11 @@ TYPED_TEST(RelativePointer_test, RegisterPtrWithIdFailsWhenTooLarge) auto* typedPtr0 = static_cast(static_cast(this->partitionPtr(0U))); auto* typedPtr1 = static_cast(static_cast(this->partitionPtr(1U))); - RelativePointer rp1(typedPtr0, iox::memory::segment_id_t{1U}); - RelativePointer rp2(typedPtr1, iox::memory::segment_id_t{10000U}); + RelativePointer rp1(typedPtr0, segment_id_t{1U}); + RelativePointer rp2(typedPtr1, segment_id_t{10000U}); - EXPECT_EQ(rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr0), true); - EXPECT_EQ(rp2.registerPtrWithId(iox::memory::segment_id_t{10000U}, typedPtr1), false); + EXPECT_EQ(rp1.registerPtrWithId(segment_id_t{1U}, typedPtr0), true); + EXPECT_EQ(rp2.registerPtrWithId(segment_id_t{10000U}, typedPtr1), false); } TYPED_TEST(RelativePointer_test, BasePointerIsSameAfterRegistering) @@ -410,10 +408,10 @@ TYPED_TEST(RelativePointer_test, BasePointerIsSameAfterRegistering) // No pointer arithmetic involved hence reinterpret_cast can be avoided auto* typedPtr = static_cast(static_cast(this->partitionPtr(0U))); - RelativePointer rp1(typedPtr, iox::memory::segment_id_t{1U}); - EXPECT_EQ(rp1.getBasePtr(iox::memory::segment_id_t{1U}), nullptr); - rp1.registerPtrWithId(iox::memory::segment_id_t{1U}, typedPtr); - EXPECT_EQ(typedPtr, rp1.getBasePtr(iox::memory::segment_id_t{1U})); + RelativePointer rp1(typedPtr, segment_id_t{1U}); + EXPECT_EQ(rp1.getBasePtr(segment_id_t{1U}), nullptr); + rp1.registerPtrWithId(segment_id_t{1U}, typedPtr); + EXPECT_EQ(typedPtr, rp1.getBasePtr(segment_id_t{1U})); } TYPED_TEST(RelativePointer_test, AssignmentOperatorResultsInSameBasePointerIdAndOffset) @@ -422,7 +420,7 @@ TYPED_TEST(RelativePointer_test, AssignmentOperatorResultsInSameBasePointerIdAnd // No pointer arithmetic involved hence reinterpret_cast can be avoided auto* typedPtr = static_cast(static_cast(this->partitionPtr(0U))); - RelativePointer rp1(typedPtr, iox::memory::segment_id_t{1U}); + RelativePointer rp1(typedPtr, segment_id_t{1U}); // NOLINTJUSTIFICATION Copy needed for tests // NOLINTNEXTLINE(performance-unnecessary-copy-initialization) RelativePointer rp2 = rp1; @@ -439,7 +437,7 @@ TYPED_TEST(RelativePointer_test, DereferencingOperatorResultsInSameValue) auto* typedPtr = static_cast(static_cast(this->partitionPtr(0U))); *typedPtr = static_cast(88); - RelativePointer rp1(typedPtr, iox::memory::segment_id_t{1U}); + RelativePointer rp1(typedPtr, segment_id_t{1U}); EXPECT_EQ(*rp1, *typedPtr); *typedPtr = static_cast(99); @@ -484,13 +482,13 @@ TYPED_TEST(RelativePointer_test, MemoryRemappingWorks) EXPECT_EQ(*adr1, 12); EXPECT_EQ(*adr2, 21); - EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(iox::memory::segment_id_t{1U}, base1), true); - EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(iox::memory::segment_id_t{2U}, base2), true); + EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(segment_id_t{1U}, base1), true); + EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(segment_id_t{2U}, base2), true); { // the relative pointers point to base 1 and base 2l - RelativePointer rp1(base1, iox::memory::segment_id_t{1U}); - RelativePointer rp2(base2, iox::memory::segment_id_t{2U}); + RelativePointer rp1(base1, segment_id_t{1U}); + RelativePointer rp2(base2, segment_id_t{2U}); EXPECT_EQ(rp1.getId(), 1U); EXPECT_EQ(rp2.getId(), 2U); @@ -504,8 +502,8 @@ TYPED_TEST(RelativePointer_test, MemoryRemappingWorks) { // now test with a type that is larger than 1 byte - RelativePointer rp1(adr1, iox::memory::segment_id_t{1U}); - RelativePointer rp2(adr2, iox::memory::segment_id_t{2U}); + RelativePointer rp1(adr1, segment_id_t{1U}); + RelativePointer rp2(adr2, segment_id_t{2U}); EXPECT_EQ(rp1.getId(), 1U); EXPECT_EQ(rp2.getId(), 2U); @@ -519,11 +517,11 @@ TYPED_TEST(RelativePointer_test, MemoryRemappingWorks) EXPECT_EQ(*rp2, 21); // simulate a remapping, index 1 now refers to base 2 and vice versa ... - EXPECT_EQ(UntypedRelativePointer::unregisterPtr(iox::memory::segment_id_t{1U}), true); - EXPECT_EQ(UntypedRelativePointer::unregisterPtr(iox::memory::segment_id_t{2U}), true); + EXPECT_EQ(UntypedRelativePointer::unregisterPtr(segment_id_t{1U}), true); + EXPECT_EQ(UntypedRelativePointer::unregisterPtr(segment_id_t{2U}), true); - EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(iox::memory::segment_id_t{1}, base2), true); - EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(iox::memory::segment_id_t{2}, base1), true); + EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(segment_id_t{1}, base2), true); + EXPECT_EQ(UntypedRelativePointer::registerPtrWithId(segment_id_t{2}, base1), true); // which, despite the relative pointer objects not having changed themselves, // leads to them referencing the respective other value now (compared to *** above)