From 2c84e729cd5d327b2bc58f5b343f5a18f522171a Mon Sep 17 00:00:00 2001 From: Mathias Kraus Date: Sun, 15 Oct 2023 20:29:55 +0200 Subject: [PATCH] iox-#2041 Move 'CTorTest' to 'iox::testing::CTorAndAssignmentOperatorTestClass' --- .../moduletests/test_container_vector.cpp | 240 ++++++------------ ...tor_and_assignment_operator_test_class.hpp | 134 ++++++++++ 2 files changed, 210 insertions(+), 164 deletions(-) create mode 100644 iceoryx_hoofs/testing/include/iceoryx_hoofs/testing/ctor_and_assignment_operator_test_class.hpp diff --git a/iceoryx_hoofs/test/moduletests/test_container_vector.cpp b/iceoryx_hoofs/test/moduletests/test_container_vector.cpp index b8bbe3c2ef9..1981c60c900 100644 --- a/iceoryx_hoofs/test/moduletests/test_container_vector.cpp +++ b/iceoryx_hoofs/test/moduletests/test_container_vector.cpp @@ -16,6 +16,7 @@ // SPDX-License-Identifier: Apache-2.0 #include "iceoryx_hoofs/error_handling/error_handling.hpp" +#include "iceoryx_hoofs/testing/ctor_and_assignment_operator_test_class.hpp" #include "iceoryx_hoofs/testing/fatal_failure.hpp" #include "iox/vector.hpp" #include "test.hpp" @@ -31,108 +32,19 @@ using namespace iox::testing; class vector_test : public Test { public: - static uint64_t cTor; - static uint64_t customCTor; - static uint64_t copyCTor; - static uint64_t moveCTor; - static uint64_t moveAssignment; - static uint64_t copyAssignment; - static uint64_t dTor; - static uint64_t classValue; - - static std::vector dtorOrder; - - class CTorTest - { - public: - CTorTest() - { - cTor++; - classValue = value; - } - - explicit CTorTest(const uint64_t value) - : value(value) - { - customCTor++; - classValue = value; - } - - CTorTest(const CTorTest& rhs) - : value(rhs.value) - { - copyCTor++; - classValue = value; - } - - CTorTest(CTorTest&& rhs) noexcept - : value(rhs.value) - { - moveCTor++; - classValue = value; - } - - CTorTest& operator=(const CTorTest& rhs) - { - if (this != &rhs) - { - copyAssignment++; - value = rhs.value; - classValue = value; - } - return *this; - } - - CTorTest& operator=(CTorTest&& rhs) noexcept - { - moveAssignment++; - value = rhs.value; - classValue = value; - return *this; - } - - bool operator==(const CTorTest& rhs) const - { - return value == rhs.value; - } - - ~CTorTest() - { - dTor++; - classValue = value; - dtorOrder.emplace_back(value); - } - - uint64_t value = 0; - }; + using CTorTest = CTorAndAssignmentOperatorTestClass<>; void SetUp() override { - cTor = 0U; - customCTor = 0U; - copyCTor = 0U; - moveCTor = 0U; - moveAssignment = 0U; - copyAssignment = 0U; - dTor = 0U; - classValue = 0U; - dtorOrder.clear(); + stats.reset(); } + CTorTest::Statistics& stats = CTorTest::stats; + static constexpr uint64_t VECTOR_CAPACITY{10}; vector sut; }; -uint64_t vector_test::cTor; -uint64_t vector_test::customCTor; -uint64_t vector_test::copyCTor; -uint64_t vector_test::moveCTor; -uint64_t vector_test::moveAssignment; -uint64_t vector_test::copyAssignment; -uint64_t vector_test::dTor; -uint64_t vector_test::classValue; -std::vector vector_test::dtorOrder; - TEST_F(vector_test, NewlyCreatedVectorIsEmpty) { ::testing::Test::RecordProperty("TEST_ID", "8ebb8b11-d044-459e-b9a1-4a3076c8d49c"); @@ -268,10 +180,10 @@ TEST_F(vector_test, PopBackNonEmptyVector) vector sut; sut.emplace_back(101U); ASSERT_THAT(sut.size(), Eq(1U)); - dTor = 0; + stats.dTor = 0; sut.pop_back(); ASSERT_THAT(sut.size(), Eq(0U)); - ASSERT_THAT(dTor, Eq(1)); + ASSERT_THAT(stats.dTor, Eq(1)); } TEST_F(vector_test, SizeIncreasesWhenElementIsAdded) @@ -333,7 +245,7 @@ TEST_F(vector_test, CopyConstructor) sut1.emplace_back(102U); vector sut2(sut1); - EXPECT_THAT(copyCTor, Eq(2U)); + EXPECT_THAT(stats.copyCTor, Eq(2U)); EXPECT_THAT(sut2.at(0).value, Eq(101U)); EXPECT_THAT(sut2.at(1).value, Eq(102U)); EXPECT_THAT(sut2.empty(), Eq(false)); @@ -347,7 +259,7 @@ TEST_F(vector_test, CopyConstructorWithEmptyVector) // NOLINTJUSTIFICATION Testing empty copy // NOLINTNEXTLINE(performance-unnecessary-copy-initialization) vector sut2(sut1); - EXPECT_THAT(copyCTor, Eq(0U)); + EXPECT_THAT(stats.copyCTor, Eq(0U)); EXPECT_THAT(sut2.size(), Eq(0U)); EXPECT_THAT(sut2.empty(), Eq(true)); } @@ -367,7 +279,7 @@ TEST_F(vector_test, CopyConstructorWithFullVector) EXPECT_THAT(sut2.at(i).value, Eq(i)); } - EXPECT_THAT(copyCTor, Eq(10U)); + EXPECT_THAT(stats.copyCTor, Eq(10U)); EXPECT_THAT(sut2.size(), Eq(10U)); EXPECT_THAT(sut2.empty(), Eq(false)); } @@ -381,7 +293,7 @@ TEST_F(vector_test, MoveConstructor) vector sut2(std::move(sut1)); - EXPECT_THAT(moveCTor, Eq(2U)); + EXPECT_THAT(stats.moveCTor, Eq(2U)); EXPECT_THAT(sut2.at(0).value, Eq(8101U)); EXPECT_THAT(sut2.at(1).value, Eq(8102U)); EXPECT_THAT(sut2.empty(), Eq(false)); @@ -395,7 +307,7 @@ TEST_F(vector_test, MoveConstructorWithEmptyVector) vector sut2(std::move(sut1)); - EXPECT_THAT(moveCTor, Eq(0U)); + EXPECT_THAT(stats.moveCTor, Eq(0U)); EXPECT_THAT(sut2.size(), Eq(0U)); EXPECT_THAT(sut2.empty(), Eq(true)); } @@ -416,7 +328,7 @@ TEST_F(vector_test, MoveConstructorWithFullVector) EXPECT_THAT(sut2.at(i).value, Eq(i)); } - EXPECT_THAT(moveCTor, Eq(10U)); + EXPECT_THAT(stats.moveCTor, Eq(10U)); EXPECT_THAT(sut2.size(), Eq(10U)); EXPECT_THAT(sut2.empty(), Eq(false)); } @@ -427,7 +339,7 @@ TEST_F(vector_test, DestructorWithEmptyVector) { vector sut1; } - EXPECT_THAT(dTor, Eq(0U)); + EXPECT_THAT(stats.dTor, Eq(0U)); } TEST_F(vector_test, DestructorSomeElements) @@ -439,7 +351,7 @@ TEST_F(vector_test, DestructorSomeElements) sut1.emplace_back(9191U); sut1.emplace_back(1U); } - EXPECT_THAT(dTor, Eq(3U)); + EXPECT_THAT(stats.dTor, Eq(3U)); } TEST_F(vector_test, DestructorWithFullVector) @@ -454,7 +366,7 @@ TEST_F(vector_test, DestructorWithFullVector) } } - EXPECT_THAT(dTor, Eq(CAPACITY)); + EXPECT_THAT(stats.dTor, Eq(CAPACITY)); } TEST_F(vector_test, EmplacingElementInTheMiddleCallsDTor) @@ -470,17 +382,17 @@ TEST_F(vector_test, EmplacingElementInTheMiddleCallsDTor) sut.emplace_back(1234U); } - EXPECT_THAT(customCTor, Eq(EXPECTED_NUMBER_OF_CTOR_CALLS - 1U)); + EXPECT_THAT(stats.customCTor, Eq(EXPECTED_NUMBER_OF_CTOR_CALLS - 1U)); EXPECT_TRUE(sut.emplace(EMPLACE_POSITION, 42U)); - EXPECT_THAT(customCTor, Eq(EXPECTED_NUMBER_OF_CTOR_CALLS)); - EXPECT_THAT(moveCTor, Eq(1U)); - EXPECT_THAT(moveAssignment, Eq(CAPACITY_OF_VECTOR - 1U - EMPLACE_POSITION - 1U)); - EXPECT_THAT(dTor, Eq(1U)); + EXPECT_THAT(stats.customCTor, Eq(EXPECTED_NUMBER_OF_CTOR_CALLS)); + EXPECT_THAT(stats.moveCTor, Eq(1U)); + EXPECT_THAT(stats.moveAssignment, Eq(CAPACITY_OF_VECTOR - 1U - EMPLACE_POSITION - 1U)); + EXPECT_THAT(stats.dTor, Eq(1U)); } // Last element in the vector is moved and not constructed, hence #moveCTor + #customCTor = #dTor - EXPECT_THAT(moveCTor, Eq(1U)); - EXPECT_THAT(customCTor, Eq(EXPECTED_NUMBER_OF_CTOR_CALLS)); - EXPECT_THAT(dTor, Eq(EXPECTED_NUMBER_OF_CTOR_CALLS + 1U)); + EXPECT_THAT(stats.moveCTor, Eq(1U)); + EXPECT_THAT(stats.customCTor, Eq(EXPECTED_NUMBER_OF_CTOR_CALLS)); + EXPECT_THAT(stats.dTor, Eq(EXPECTED_NUMBER_OF_CTOR_CALLS + 1U)); } TEST_F(vector_test, CopyAssignmentWithEmptySource) @@ -494,9 +406,9 @@ TEST_F(vector_test, CopyAssignmentWithEmptySource) sut1 = sut2; - EXPECT_THAT(dTor, Eq(3U)); - EXPECT_THAT(copyAssignment, Eq(0U)); - EXPECT_THAT(copyCTor, Eq(0U)); + EXPECT_THAT(stats.dTor, Eq(3U)); + EXPECT_THAT(stats.copyAssignment, Eq(0U)); + EXPECT_THAT(stats.copyCTor, Eq(0U)); EXPECT_THAT(sut1.size(), Eq(0U)); EXPECT_THAT(sut1.empty(), Eq(true)); } @@ -512,9 +424,9 @@ TEST_F(vector_test, CopyAssignmentWithEmptyDestination) sut2 = sut1; - EXPECT_THAT(dTor, Eq(0U)); - EXPECT_THAT(copyAssignment, Eq(0U)); - EXPECT_THAT(copyCTor, Eq(3U)); + EXPECT_THAT(stats.dTor, Eq(0U)); + EXPECT_THAT(stats.copyAssignment, Eq(0U)); + EXPECT_THAT(stats.copyCTor, Eq(3U)); EXPECT_THAT(sut2.size(), Eq(3U)); EXPECT_THAT(sut2.empty(), Eq(false)); @@ -537,9 +449,9 @@ TEST_F(vector_test, CopyAssignmentWithLargerDestination) sut1 = sut2; - EXPECT_THAT(dTor, Eq(2U)); - EXPECT_THAT(copyAssignment, Eq(2U)); - EXPECT_THAT(copyCTor, Eq(0U)); + EXPECT_THAT(stats.dTor, Eq(2U)); + EXPECT_THAT(stats.copyAssignment, Eq(2U)); + EXPECT_THAT(stats.copyCTor, Eq(0U)); EXPECT_THAT(sut1.size(), Eq(2U)); EXPECT_THAT(sut1.empty(), Eq(false)); EXPECT_THAT(sut1.at(0U).value, Eq(313U)); @@ -560,9 +472,9 @@ TEST_F(vector_test, CopyAssignmentWithLargerSource) sut2 = sut1; - EXPECT_THAT(dTor, Eq(0U)); - EXPECT_THAT(copyAssignment, Eq(2U)); - EXPECT_THAT(copyCTor, Eq(2U)); + EXPECT_THAT(stats.dTor, Eq(0U)); + EXPECT_THAT(stats.copyAssignment, Eq(2U)); + EXPECT_THAT(stats.copyCTor, Eq(2U)); EXPECT_THAT(sut2.size(), Eq(4U)); EXPECT_THAT(sut2.empty(), Eq(false)); EXPECT_THAT(sut2.at(0U).value, Eq(15842U)); @@ -583,11 +495,11 @@ TEST_F(vector_test, ReverseDestructionOrderInCopyAssignment) } sut1 = sut2; - EXPECT_THAT(dTor, Eq(VECTOR_CAPACITY)); - ASSERT_THAT(dtorOrder.size(), Eq(VECTOR_CAPACITY)); + EXPECT_THAT(stats.dTor, Eq(VECTOR_CAPACITY)); + ASSERT_THAT(stats.dTorOrder.size(), Eq(VECTOR_CAPACITY)); for (uint64_t i{0}; i < VECTOR_CAPACITY; ++i) { - EXPECT_THAT(dtorOrder[i], Eq(VECTOR_CAPACITY - 1 - i)); + EXPECT_THAT(stats.dTorOrder[i], Eq(VECTOR_CAPACITY - 1 - i)); } } @@ -603,11 +515,11 @@ TEST_F(vector_test, ReverseDestructionOrderInMoveAssignment) } sut1 = std::move(sut2); - EXPECT_THAT(dTor, Eq(VECTOR_CAPACITY)); - ASSERT_THAT(dtorOrder.size(), Eq(VECTOR_CAPACITY)); + EXPECT_THAT(stats.dTor, Eq(VECTOR_CAPACITY)); + ASSERT_THAT(stats.dTorOrder.size(), Eq(VECTOR_CAPACITY)); for (uint64_t i{0}; i < VECTOR_CAPACITY; ++i) { - EXPECT_THAT(dtorOrder[i], Eq(VECTOR_CAPACITY - i)); + EXPECT_THAT(stats.dTorOrder[i], Eq(VECTOR_CAPACITY - i)); } } @@ -622,9 +534,9 @@ TEST_F(vector_test, MoveAssignmentWithEmptySource) sut1 = std::move(sut2); - EXPECT_THAT(dTor, Eq(3U)); - EXPECT_THAT(moveAssignment, Eq(0U)); - EXPECT_THAT(moveCTor, Eq(0U)); + EXPECT_THAT(stats.dTor, Eq(3U)); + EXPECT_THAT(stats.moveAssignment, Eq(0U)); + EXPECT_THAT(stats.moveCTor, Eq(0U)); EXPECT_THAT(sut1.size(), Eq(0U)); EXPECT_THAT(sut1.empty(), Eq(true)); } @@ -640,9 +552,9 @@ TEST_F(vector_test, MoveAssignmentWithEmptyDestination) sut2 = std::move(sut1); - EXPECT_THAT(dTor, Eq(3U)); - EXPECT_THAT(moveAssignment, Eq(0U)); - EXPECT_THAT(moveCTor, Eq(3U)); + EXPECT_THAT(stats.dTor, Eq(3U)); + EXPECT_THAT(stats.moveAssignment, Eq(0U)); + EXPECT_THAT(stats.moveCTor, Eq(3U)); EXPECT_THAT(sut2.size(), Eq(3U)); EXPECT_THAT(sut2.empty(), Eq(false)); EXPECT_THAT(sut2.at(0U).value, Eq(5812U)); @@ -664,9 +576,9 @@ TEST_F(vector_test, MoveAssignmentWithLargerDestination) sut1 = std::move(sut2); - EXPECT_THAT(dTor, Eq(4U)); - EXPECT_THAT(moveAssignment, Eq(2U)); - EXPECT_THAT(moveCTor, Eq(0U)); + EXPECT_THAT(stats.dTor, Eq(4U)); + EXPECT_THAT(stats.moveAssignment, Eq(2U)); + EXPECT_THAT(stats.moveCTor, Eq(0U)); EXPECT_THAT(sut1.size(), Eq(2U)); EXPECT_THAT(sut1.empty(), Eq(false)); EXPECT_THAT(sut1.at(0U).value, Eq(313U)); @@ -687,9 +599,9 @@ TEST_F(vector_test, MoveAssignmentWithLargerSource) sut2 = std::move(sut1); - EXPECT_THAT(dTor, Eq(4U)); - EXPECT_THAT(moveAssignment, Eq(2U)); - EXPECT_THAT(moveCTor, Eq(2U)); + EXPECT_THAT(stats.dTor, Eq(4U)); + EXPECT_THAT(stats.moveAssignment, Eq(2U)); + EXPECT_THAT(stats.moveCTor, Eq(2U)); EXPECT_THAT(sut2.size(), Eq(4U)); EXPECT_THAT(sut2.empty(), Eq(false)); EXPECT_THAT(sut2.at(0U).value, Eq(15842U)); @@ -943,8 +855,8 @@ TEST_F(vector_test, EraseOfLastElementCallsDTorOnly) EXPECT_TRUE(sut1.erase(sut1.begin() + 2U)); - EXPECT_THAT(dTor, Eq(1U)); - EXPECT_THAT(classValue, Eq(9U)); + EXPECT_THAT(stats.dTor, Eq(1U)); + EXPECT_THAT(stats.classValue, Eq(9U)); } TEST_F(vector_test, EraseOfMiddleElementCallsDTorAndMove) @@ -959,8 +871,8 @@ TEST_F(vector_test, EraseOfMiddleElementCallsDTorAndMove) EXPECT_TRUE(sut1.erase(sut1.begin() + 2U)); - EXPECT_THAT(dTor, Eq(1U)); - EXPECT_THAT(moveAssignment, Eq(2U)); + EXPECT_THAT(stats.dTor, Eq(1U)); + EXPECT_THAT(stats.moveAssignment, Eq(2U)); } TEST_F(vector_test, AccessOfNonExistingElementOnEmptyVectorLeadTermination) @@ -1053,8 +965,8 @@ TEST_F(vector_test, EraseOfFrontElementCallsDTorAndMove) EXPECT_TRUE(sut1.erase(sut1.begin())); - EXPECT_THAT(dTor, Eq(1U)); - EXPECT_THAT(moveAssignment, Eq(4U)); + EXPECT_THAT(stats.dTor, Eq(1U)); + EXPECT_THAT(stats.moveAssignment, Eq(4U)); } TEST_F(vector_test, EraseMiddleElementDataCorrectAfterwards) @@ -1169,7 +1081,7 @@ TEST_F(vector_test, ConstructorWithSizeParameterSmallerThanCapacity) { ::testing::Test::RecordProperty("TEST_ID", "b55f3818-ded5-420a-ad9a-88d5e90b429e"); vector sut(2U); - EXPECT_THAT(vector_test::cTor, Eq(2U)); + EXPECT_THAT(stats.cTor, Eq(2U)); ASSERT_THAT(sut.size(), Eq(2U)); } @@ -1177,7 +1089,7 @@ TEST_F(vector_test, ConstructorWithSizeParameterGreaterThanCapacity) { ::testing::Test::RecordProperty("TEST_ID", "57d86dd4-ba23-4911-a451-bbc78d3f899a"); vector sut(7U); - EXPECT_THAT(vector_test::cTor, Eq(5U)); + EXPECT_THAT(stats.cTor, Eq(5U)); ASSERT_THAT(sut.size(), Eq(5U)); } @@ -1348,10 +1260,10 @@ TEST_F(vector_test, FullVectorDestroysElementsInReverseOrder) } } - ASSERT_THAT(dtorOrder.size(), Eq(VECTOR_CAPACITY)); + ASSERT_THAT(stats.dTorOrder.size(), Eq(VECTOR_CAPACITY)); for (uint64_t i = 0U; i < VECTOR_CAPACITY; ++i) { - EXPECT_THAT(dtorOrder[i], Eq(INDEX_END - i + SOME_OFFSET)); + EXPECT_THAT(stats.dTorOrder[i], Eq(INDEX_END - i + SOME_OFFSET)); } } @@ -1372,10 +1284,10 @@ TEST_F(vector_test, PartiallyFullVectorDestroysElementsInReverseOrder) } } - ASSERT_THAT(dtorOrder.size(), Eq(VECTOR_SIZE)); + ASSERT_THAT(stats.dTorOrder.size(), Eq(VECTOR_SIZE)); for (uint64_t i = 0U; i < VECTOR_SIZE; ++i) { - EXPECT_THAT(dtorOrder[i], Eq(INDEX_END - i + SOME_OFFSET)); + EXPECT_THAT(stats.dTorOrder[i], Eq(INDEX_END - i + SOME_OFFSET)); } } @@ -1465,11 +1377,11 @@ TEST_F(vector_test, SizeDecreaseWithResizeAndDefaultCTorWorks) } EXPECT_TRUE(sut.resize(7U)); - EXPECT_THAT(dTor, Eq(3U)); - ASSERT_THAT(dtorOrder.size(), Eq(3U)); - EXPECT_THAT(dtorOrder[0], Eq(9)); - EXPECT_THAT(dtorOrder[1], Eq(8)); - EXPECT_THAT(dtorOrder[2], Eq(7)); + EXPECT_THAT(stats.dTor, Eq(3U)); + ASSERT_THAT(stats.dTorOrder.size(), Eq(3U)); + EXPECT_THAT(stats.dTorOrder[0], Eq(9)); + EXPECT_THAT(stats.dTorOrder[1], Eq(8)); + EXPECT_THAT(stats.dTorOrder[2], Eq(7)); } TEST_F(vector_test, SizeDecreaseWithResizeAndTemplateValueWorks) @@ -1483,11 +1395,11 @@ TEST_F(vector_test, SizeDecreaseWithResizeAndTemplateValueWorks) } EXPECT_TRUE(sut.resize(7U, 66807U)); - EXPECT_THAT(dTor, Eq(3U)); - ASSERT_THAT(dtorOrder.size(), Eq(3U)); - EXPECT_THAT(dtorOrder[0], Eq(19)); - EXPECT_THAT(dtorOrder[1], Eq(18)); - EXPECT_THAT(dtorOrder[2], Eq(17)); + EXPECT_THAT(stats.dTor, Eq(3U)); + ASSERT_THAT(stats.dTorOrder.size(), Eq(3U)); + EXPECT_THAT(stats.dTorOrder[0], Eq(19)); + EXPECT_THAT(stats.dTorOrder[1], Eq(18)); + EXPECT_THAT(stats.dTorOrder[2], Eq(17)); } TEST_F(vector_test, ResizeWithDefaultCTorChangesNothingIfSizeAlreadyFits) diff --git a/iceoryx_hoofs/testing/include/iceoryx_hoofs/testing/ctor_and_assignment_operator_test_class.hpp b/iceoryx_hoofs/testing/include/iceoryx_hoofs/testing/ctor_and_assignment_operator_test_class.hpp new file mode 100644 index 00000000000..9be1afd804a --- /dev/null +++ b/iceoryx_hoofs/testing/include/iceoryx_hoofs/testing/ctor_and_assignment_operator_test_class.hpp @@ -0,0 +1,134 @@ +// Copyright (c) 2019 by Robert Bosch GmbH. All rights reserved. +// Copyright (c) 2021 - 2022 by Apex.AI Inc. All rights reserved. +// Copyright (c) 2023 by Mathias Kraus . All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// SPDX-License-Identifier: Apache-2.0 + +#ifndef IOX_HOOFS_TESTING_CTOR_AND_ASSIGNMENT_OPERATOR_TEST_CLASS_HPP +#define IOX_HOOFS_TESTING_CTOR_AND_ASSIGNMENT_OPERATOR_TEST_CLASS_HPP + +#include +#include + +namespace iox +{ +namespace testing +{ +template +class CTorAndAssignmentOperatorTestClass +{ + public: + CTorAndAssignmentOperatorTestClass() + { + stats.cTor++; + stats.classValue = value; + } + + // NOLINTNEXTLINE(hicpp-explicit-conversions) we want to use this class in tests transparently to a 'T' + CTorAndAssignmentOperatorTestClass(const T value) + : value(value) + { + stats.customCTor++; + stats.classValue = value; + } + + CTorAndAssignmentOperatorTestClass(const CTorAndAssignmentOperatorTestClass& rhs) + : value(rhs.value) + { + stats.copyCTor++; + stats.classValue = value; + } + + CTorAndAssignmentOperatorTestClass(CTorAndAssignmentOperatorTestClass&& rhs) noexcept + : value(rhs.value) + { + stats.moveCTor++; + stats.classValue = value; + } + + CTorAndAssignmentOperatorTestClass& operator=(const CTorAndAssignmentOperatorTestClass& rhs) + { + if (this != &rhs) + { + stats.copyAssignment++; + value = rhs.value; + stats.classValue = value; + } + return *this; + } + + CTorAndAssignmentOperatorTestClass& operator=(CTorAndAssignmentOperatorTestClass&& rhs) noexcept + { + if (this != &rhs) + { + stats.moveAssignment++; + value = rhs.value; + stats.classValue = value; + } + return *this; + } + + bool operator==(const CTorAndAssignmentOperatorTestClass& rhs) const + { + return value == rhs.value; + } + + ~CTorAndAssignmentOperatorTestClass() + { + stats.dTor++; + stats.classValue = value; + stats.dTorOrder.emplace_back(value); + } + + struct Statistics + { + uint64_t cTor{0}; + uint64_t customCTor{0}; + uint64_t copyCTor{0}; + uint64_t moveCTor{0}; + uint64_t moveAssignment{0}; + uint64_t copyAssignment{0}; + uint64_t dTor{0}; + T classValue{0}; + + std::vector dTorOrder; + + void reset() + { + cTor = 0; + customCTor = 0; + copyCTor = 0; + moveCTor = 0; + moveAssignment = 0; + copyAssignment = 0; + dTor = 0; + classValue = 0; + dTorOrder.clear(); + } + }; + + //NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) only used for tests + static Statistics stats; + + T value = DEFAULT_VALUE; +}; + +template +typename CTorAndAssignmentOperatorTestClass::Statistics + CTorAndAssignmentOperatorTestClass::stats{}; +} // namespace testing +} // namespace iox + +#endif // IOX_HOOFS_TESTING_CTOR_AND_ASSIGNMENT_OPERATOR_TEST_CLASS_HPP