LifetimeChecker

MorganCaron · MorganCaron · commit 66caad61c7d3 · 2026-03-28T20:16:11.000+01:00
diff --git a/README.md b/README.md
@@ -122,7 +122,7 @@
 - [`Variant`](modules/Type/Variant.mpp) - Generic print and comparison operators for `std::variant`
 
 ### 🧪 Unit Testing
-- [`DummyObject`](modules/UnitTest/DummyObject.mpp) - Dummy object that prints construction, destruction, copy and move operations, while counting copies and moves for test verification
+- [`LifetimeChecker`](modules/UnitTest/LifetimeChecker.mpp) - Object that prints construction, destruction, copy and move operations, while counting copies and moves for test verification
 - [`UnitTest`](modules/UnitTest/UnitTest.mpp) - Minimal test framework with assertions and filters
 
 ### 🧩 Miscellaneous
diff --git a/modules/UnitTest/LifetimeChecker.mpp b/modules/UnitTest/LifetimeChecker.mpp
@@ -1,13 +1,13 @@
-export module CppUtils.UnitTest.DummyObject;
+export module CppUtils.UnitTest.LifetimeChecker;
 
 import std;
 
 export namespace CppUtils::UnitTest
 {
-	class DummyObject
+	class LifetimeChecker
 	{
 	public:
-		inline DummyObject(std::function<void(std::string_view)> callback, std::string name, std::size_t indentationLevel = 0):
+		inline LifetimeChecker(std::function<void(std::string_view)> callback, std::string name, std::size_t indentationLevel = 0):
 			m_callback{std::move(callback)},
 			m_name{std::move(name)},
 			m_indentationLevel{indentationLevel}
@@ -25,12 +25,12 @@ export namespace CppUtils::UnitTest
 			return m_moveCount;
 		}
 
-		virtual ~DummyObject()
+		virtual ~LifetimeChecker()
 		{
 			m_callback(std::format("{}~{}()", std::string(m_indentationLevel, '\t'), m_name));
 		}
 
-		inline DummyObject(const DummyObject& other):
+		inline LifetimeChecker(const LifetimeChecker& other):
 			m_callback{other.m_callback},
 			m_name{other.m_name},
 			m_indentationLevel{other.m_indentationLevel},
@@ -40,7 +40,7 @@ export namespace CppUtils::UnitTest
 			m_callback(std::format("{}{}(const {}&)", std::string(m_indentationLevel, '\t'), m_name, m_name));
 		}
 
-		inline DummyObject(DummyObject&& other) noexcept:
+		inline LifetimeChecker(LifetimeChecker&& other) noexcept:
 			m_callback{other.m_callback},
 			m_name{std::move(other.m_name)},
 			m_indentationLevel{other.m_indentationLevel},
@@ -51,7 +51,7 @@ export namespace CppUtils::UnitTest
 			m_callback(std::format("{}{}({}&&)", std::string(m_indentationLevel, '\t'), m_name, m_name));
 		}
 
-		inline auto operator=(const DummyObject& rhs) -> DummyObject&
+		inline auto operator=(const LifetimeChecker& rhs) -> LifetimeChecker&
 		{
 			m_callback = rhs.m_callback;
 			m_name = rhs.m_name;
@@ -62,7 +62,7 @@ export namespace CppUtils::UnitTest
 			return *this;
 		}
 
-		inline auto operator=(DummyObject&& rhs) noexcept -> DummyObject&
+		inline auto operator=(LifetimeChecker&& rhs) noexcept -> LifetimeChecker&
 		{
 			m_callback = rhs.m_callback;
 			m_name = std::move(rhs.m_name);
diff --git a/modules/UnitTest/UnitTest.mpp b/modules/UnitTest/UnitTest.mpp
@@ -15,7 +15,7 @@ import CppUtils.String;
 import CppUtils.Terminal;
 import CppUtils.System.Main;
 
-export import CppUtils.UnitTest.DummyObject;
+export import CppUtils.UnitTest.LifetimeChecker;
 
 namespace CppUtils::UnitTest
 {
@@ -249,7 +249,7 @@ namespace CppUtils::UnitTest
 
 		// Todo C++23: std::stacktrace stacktrace = std::current_stacktrace()
 		inline auto expect(const auto& condition, std::source_location sourceLocation = std::source_location::current()) -> void
-			requires requires { static_cast<bool>(condition); }
+		requires requires { static_cast<bool>(condition); }
 		{
 			if (not static_cast<bool>(condition)) [[unlikely]]
 				throw TestException{std::format("In {}\nAt line {}, column {}\nIn expect(condition)",
diff --git a/tests/Container/NetworkPtr.mpp b/tests/Container/NetworkPtr.mpp
@@ -7,8 +7,8 @@ namespace CppUtils::UnitTest::Container::NetworkPtr
 {
 	auto _ = TestSuite{"Container/NetworkPtr", {"Logger", "Thread/UniqueLocker", "Container/SafeShared"}, [](TestSuite& suite) {
 		using Logger = TestSuite::Logger;
-		using DummyObject = CppUtils::UnitTest::DummyObject;
-		using NetworkPtr = CppUtils::Container::NetworkPtr<DummyObject>;
+		using LifetimeChecker = CppUtils::UnitTest::LifetimeChecker;
+		using NetworkPtr = CppUtils::Container::NetworkPtr<LifetimeChecker>;
 		using StringNetworkPtr = CppUtils::Container::NetworkPtr<std::string>;
 
 		auto logger = [](std::string_view message) {
diff --git a/tests/UnitTest/LifetimeChecker.mpp b/tests/UnitTest/LifetimeChecker.mpp
@@ -1,75 +1,75 @@
-export module CppUtils.UnitTests.UnitTest.DummyObject;
+export module CppUtils.UnitTests.UnitTest.LifetimeChecker;
 
 import std;
 import CppUtils;
 
 namespace CppUtils::UnitTest
 {
-	auto _ = TestSuite{"UnitTest/DummyObject", [](TestSuite& suite) {
+	auto _ = TestSuite{"UnitTest/LifetimeChecker", [](TestSuite& suite) {
 		using Logger = TestSuite::Logger;
 
 		suite.addTest("No Copy No Move", [&] {
-			auto object = DummyObject{[](std::string_view message) { Logger::print<"info">("{}", message); }, "DummyObject"};
+			auto object = LifetimeChecker{[](std::string_view message) { Logger::print<"info">("{}", message); }, "LifetimeChecker"};
 			suite.expectEqual(object.getCopyCount(), 0uz);
 			suite.expectEqual(object.getMoveCount(), 0uz);
 		});
 
 		suite.addTest("Copy Construction", [&] {
-			auto object = DummyObject{[](std::string_view message) { Logger::print<"info">("{}", message); }, "DummyObject"};
+			auto object = LifetimeChecker{[](std::string_view message) { Logger::print<"info">("{}", message); }, "LifetimeChecker"};
 			auto copied = object;
 			suite.expectEqual(copied.getCopyCount(), 1uz);
 			suite.expectEqual(copied.getMoveCount(), 0uz);
 		});
 
 		suite.addTest("Move Construction", [&] {
-			auto object = DummyObject{[](std::string_view message) { Logger::print<"info">("{}", message); }, "DummyObject"};
+			auto object = LifetimeChecker{[](std::string_view message) { Logger::print<"info">("{}", message); }, "LifetimeChecker"};
 			auto moved = std::move(object);
 			suite.expectEqual(moved.getCopyCount(), 0uz);
 			suite.expectEqual(moved.getMoveCount(), 1uz);
 		});
 
 		suite.addTest("Copy Assignment", [&] {
-			auto object = DummyObject{[](std::string_view message) { Logger::print<"info">("{}", message); }, "DummyObject"};
-			auto target = DummyObject{[](std::string_view message) { Logger::print<"info">("{}", message); }, "Target"};
+			auto object = LifetimeChecker{[](std::string_view message) { Logger::print<"info">("{}", message); }, "LifetimeChecker"};
+			auto target = LifetimeChecker{[](std::string_view message) { Logger::print<"info">("{}", message); }, "Target"};
 			target = object;
 			suite.expectEqual(target.getCopyCount(), 1uz);
 			suite.expectEqual(target.getMoveCount(), 0uz);
 		});
 
 		suite.addTest("Move Assignment", [&] {
-			auto object = DummyObject{[](std::string_view message) { Logger::print<"info">("{}", message); }, "DummyObject"};
-			auto target = DummyObject{[](std::string_view message) { Logger::print<"info">("{}", message); }, "Target"};
+			auto object = LifetimeChecker{[](std::string_view message) { Logger::print<"info">("{}", message); }, "LifetimeChecker"};
+			auto target = LifetimeChecker{[](std::string_view message) { Logger::print<"info">("{}", message); }, "Target"};
 			target = std::move(object);
 			suite.expectEqual(target.getCopyCount(), 0uz);
 			suite.expectEqual(target.getMoveCount(), 1uz);
 		});
 
 		suite.addTest("Two Copies", [&] {
-			auto object = DummyObject{[](std::string_view message) { Logger::print<"info">("{}", message); }, "DummyObject"};
+			auto object = LifetimeChecker{[](std::string_view message) { Logger::print<"info">("{}", message); }, "LifetimeChecker"};
 			auto copy1 = object;
 			auto copy2 = copy1;
 			suite.expectEqual(copy2.getCopyCount(), 2uz);
 			suite.expectEqual(copy2.getMoveCount(), 0uz);
 		});
 
 		suite.addTest("Two Moves", [&] {
-			auto object = DummyObject{[](std::string_view message) { Logger::print<"info">("{}", message); }, "DummyObject"};
+			auto object = LifetimeChecker{[](std::string_view message) { Logger::print<"info">("{}", message); }, "LifetimeChecker"};
 			auto moved1 = std::move(object);
 			auto moved2 = std::move(moved1);
 			suite.expectEqual(moved2.getCopyCount(), 0uz);
 			suite.expectEqual(moved2.getMoveCount(), 2uz);
 		});
 
 		suite.addTest("Copy then Move", [&] {
-			auto object = DummyObject{[](std::string_view message) { Logger::print<"info">("{}", message); }, "DummyObject"};
+			auto object = LifetimeChecker{[](std::string_view message) { Logger::print<"info">("{}", message); }, "LifetimeChecker"};
 			auto copy = object;
 			auto moved = std::move(copy);
 			suite.expectEqual(moved.getCopyCount(), 1uz);
 			suite.expectEqual(moved.getMoveCount(), 1uz);
 		});
 
 		suite.addTest("Move then Copy", [&] {
-			auto object = DummyObject{[](std::string_view message) { Logger::print<"info">("{}", message); }, "DummyObject"};
+			auto object = LifetimeChecker{[](std::string_view message) { Logger::print<"info">("{}", message); }, "LifetimeChecker"};
 			auto moved = std::move(object);
 			auto copy = moved;
 			suite.expectEqual(copy.getCopyCount(), 1uz);
diff --git a/tests/UnitTests.mpp b/tests/UnitTests.mpp
@@ -70,4 +70,4 @@ export import CppUtils.UnitTests.Type.Enum;
 export import CppUtils.UnitTests.Type.Mapping;
 export import CppUtils.UnitTests.Type.Tuple;
 export import CppUtils.UnitTests.UnitTest;
-export import CppUtils.UnitTests.UnitTest.DummyObject;
+export import CppUtils.UnitTests.UnitTest.LifetimeChecker;

Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,13 @@`
`1`		`-export module CppUtils.UnitTest.DummyObject;`
	`1`	`+export module CppUtils.UnitTest.LifetimeChecker;`
`2`	`2`
`3`	`3`	`import std;`
`4`	`4`
`5`	`5`	`export namespace CppUtils::UnitTest`
`6`	`6`	`{`
`7`		`- class DummyObject`
	`7`	`+ class LifetimeChecker`
`8`	`8`	`{`
`9`	`9`	`public:`
`10`		`- inline DummyObject(std::function<void(std::string_view)> callback, std::string name, std::size_t indentationLevel = 0):`
	`10`	`+ inline LifetimeChecker(std::function<void(std::string_view)> callback, std::string name, std::size_t indentationLevel = 0):`
`11`	`11`	`m_callback{std::move(callback)},`
`12`	`12`	`m_name{std::move(name)},`
`13`	`13`	`m_indentationLevel{indentationLevel}`
`@@ -25,12 +25,12 @@ export namespace CppUtils::UnitTest`
`25`	`25`	`return m_moveCount;`
`26`	`26`	`}`
`27`	`27`
`28`		`- virtual ~DummyObject()`
	`28`	`+ virtual ~LifetimeChecker()`
`29`	`29`	`{`
`30`	`30`	`m_callback(std::format("{}~{}()", std::string(m_indentationLevel, '\t'), m_name));`
`31`	`31`	`}`
`32`	`32`
`33`		`- inline DummyObject(const DummyObject& other):`
	`33`	`+ inline LifetimeChecker(const LifetimeChecker& other):`
`34`	`34`	`m_callback{other.m_callback},`
`35`	`35`	`m_name{other.m_name},`
`36`	`36`	`m_indentationLevel{other.m_indentationLevel},`
`@@ -40,7 +40,7 @@ export namespace CppUtils::UnitTest`
`40`	`40`	`m_callback(std::format("{}{}(const {}&)", std::string(m_indentationLevel, '\t'), m_name, m_name));`
`41`	`41`	`}`
`42`	`42`
`43`		`- inline DummyObject(DummyObject&& other) noexcept:`
	`43`	`+ inline LifetimeChecker(LifetimeChecker&& other) noexcept:`
`44`	`44`	`m_callback{other.m_callback},`
`45`	`45`	`m_name{std::move(other.m_name)},`
`46`	`46`	`m_indentationLevel{other.m_indentationLevel},`
`@@ -51,7 +51,7 @@ export namespace CppUtils::UnitTest`
`51`	`51`	`m_callback(std::format("{}{}({}&&)", std::string(m_indentationLevel, '\t'), m_name, m_name));`
`52`	`52`	`}`
`53`	`53`
`54`		`- inline auto operator=(const DummyObject& rhs) -> DummyObject&`
	`54`	`+ inline auto operator=(const LifetimeChecker& rhs) -> LifetimeChecker&`
`55`	`55`	`{`
`56`	`56`	`m_callback = rhs.m_callback;`
`57`	`57`	`m_name = rhs.m_name;`
`@@ -62,7 +62,7 @@ export namespace CppUtils::UnitTest`
`62`	`62`	`return *this;`
`63`	`63`	`}`
`64`	`64`
`65`		`- inline auto operator=(DummyObject&& rhs) noexcept -> DummyObject&`
	`65`	`+ inline auto operator=(LifetimeChecker&& rhs) noexcept -> LifetimeChecker&`
`66`	`66`	`{`
`67`	`67`	`m_callback = rhs.m_callback;`
`68`	`68`	`m_name = std::move(rhs.m_name);`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ import CppUtils.String;`
`15`	`15`	`import CppUtils.Terminal;`
`16`	`16`	`import CppUtils.System.Main;`
`17`	`17`
`18`		`-export import CppUtils.UnitTest.DummyObject;`
	`18`	`+export import CppUtils.UnitTest.LifetimeChecker;`
`19`	`19`
`20`	`20`	`namespace CppUtils::UnitTest`
`21`	`21`	`{`
`@@ -249,7 +249,7 @@ namespace CppUtils::UnitTest`
`249`	`249`
`250`	`250`	`// Todo C++23: std::stacktrace stacktrace = std::current_stacktrace()`
`251`	`251`	`inline auto expect(const auto& condition, std::source_location sourceLocation = std::source_location::current()) -> void`
`252`		`- requires requires { static_cast<bool>(condition); }`
	`252`	`+ requires requires { static_cast<bool>(condition); }`
`253`	`253`	`{`
`254`	`254`	`if (not static_cast<bool>(condition)) [[unlikely]]`
`255`	`255`	`throw TestException{std::format("In {}\nAt line {}, column {}\nIn expect(condition)",`