refactor tests: enhance GetNamespace coverage and modernize type usage

Refactored tests to improve clarity and robustness. Updated type definitions to modern equivalents (`std::array`, `enum` with explicit width, etc.) and replaced namespace definitions with inline syntax. Expanded test cases for built-in, unsigned, floating-point, and character types to ensure comprehensive coverage of edge scenarios.

Author: allnes

modules/util/tests/util.cpp

@@ -2,6 +2,8 @@
 
 #include <gtest/gtest.h>
 
+#include <array>
+#include <cstdint>
 #include <libenvpp/detail/environment.hpp>
 #include <libenvpp/detail/get.hpp>
 #include <string>
@@ -101,7 +103,7 @@ TEST(GetNamespaceTest, GetNamespace_WithAnonymousNamespace_HandlesCorrectly) {
 // Additional edge case tests for better coverage
 TEST(GetNamespaceTest, GetNamespace_WithGlobalNamespaceType_ReturnsEmpty) {
   // Global namespace enum defined inside a function gets special handling
-  enum GlobalEnum { VALUE };
+  enum GlobalEnum : std::uint8_t { kValue };
   std::string k_ns = ppc::util::GetNamespace<GlobalEnum>();
   // Local enums defined in functions can have function names in their type
   EXPECT_TRUE(k_ns.find("GetNamespaceTest") != std::string::npos || k_ns.empty());
@@ -117,23 +119,20 @@ TEST(GetNamespaceTest, GetNamespace_WithFunctionPointer_HandlesCorrectly) {
 
 // Test with array type
 TEST(GetNamespaceTest, GetNamespace_WithArrayType_ReturnsEmpty) {
-  using ArrayType = int[10];
+  using ArrayType = std::array<int, 10>;
   std::string k_ns = ppc::util::GetNamespace<ArrayType>();
-  EXPECT_EQ(k_ns, "");
+  // std::array is in std namespace
+  EXPECT_TRUE(k_ns.find("std") == 0);
 }
 
 // Test with deeply nested template to stress the demangler
-namespace deeply {
-namespace nested {
-namespace ns {
+namespace deeply::nested::ns {
 template <typename T, typename U, typename V>
 struct ComplexTemplate {
   template <typename X, typename Y>
   struct Inner {};
 };
-}  // namespace ns
-}  // namespace nested
-}  // namespace deeply
+}  // namespace deeply::nested::ns
 
 TEST(GetNamespaceTest, GetNamespace_WithDeeplyNestedTemplate_ExtractsCorrectly) {
   using ComplexType = deeply::nested::ns::ComplexTemplate<int, double, char>::Inner<float, bool>;

modules/util/tests/util_demangle_edge_cases.cpp

@@ -1,13 +1,15 @@
 #include <gtest/gtest.h>
 
+#include <string>
+
 #include "util/include/util.hpp"
 
 // This file tests edge cases that might cause demangling failures
 // or other uncovered branches in GetNamespace
 
 // Test with an extern "C" function type that might have special handling
 extern "C" {
-typedef void (*CFunction)();
+using CFunction = void (*)();
 }
 
 TEST(GetNamespaceEdgeCases, GetNamespace_WithExternCFunction_HandlesCorrectly) {
@@ -25,21 +27,35 @@ TEST(GetNamespaceEdgeCases, GetNamespace_WithNoColonColon_ReturnsEmpty) {
   EXPECT_EQ(k_ns, "");
 }
 
-// Test with built-in types that might have special mangling
-TEST(GetNamespaceEdgeCases, GetNamespace_WithBuiltinTypes_ReturnsEmpty) {
+// Test with basic built-in types
+TEST(GetNamespaceEdgeCases, GetNamespace_WithBasicBuiltinTypes_ReturnsEmpty) {
   EXPECT_EQ(ppc::util::GetNamespace<void>(), "");
   EXPECT_EQ(ppc::util::GetNamespace<char>(), "");
   EXPECT_EQ(ppc::util::GetNamespace<short>(), "");
+  EXPECT_EQ(ppc::util::GetNamespace<int>(), "");
   EXPECT_EQ(ppc::util::GetNamespace<long>(), "");
   EXPECT_EQ(ppc::util::GetNamespace<long long>(), "");
+  EXPECT_EQ(ppc::util::GetNamespace<bool>(), "");
+}
+
+// Test with unsigned built-in types
+TEST(GetNamespaceEdgeCases, GetNamespace_WithUnsignedBuiltinTypes_ReturnsEmpty) {
   EXPECT_EQ(ppc::util::GetNamespace<unsigned char>(), "");
   EXPECT_EQ(ppc::util::GetNamespace<unsigned short>(), "");
+  EXPECT_EQ(ppc::util::GetNamespace<unsigned int>(), "");
   EXPECT_EQ(ppc::util::GetNamespace<unsigned long>(), "");
   EXPECT_EQ(ppc::util::GetNamespace<unsigned long long>(), "");
+}
+
+// Test with floating point types
+TEST(GetNamespaceEdgeCases, GetNamespace_WithFloatingPointTypes_ReturnsEmpty) {
   EXPECT_EQ(ppc::util::GetNamespace<float>(), "");
   EXPECT_EQ(ppc::util::GetNamespace<double>(), "");
   EXPECT_EQ(ppc::util::GetNamespace<long double>(), "");
-  EXPECT_EQ(ppc::util::GetNamespace<bool>(), "");
+}
+
+// Test with character types
+TEST(GetNamespaceEdgeCases, GetNamespace_WithCharacterTypes_ReturnsEmpty) {
   EXPECT_EQ(ppc::util::GetNamespace<wchar_t>(), "");
   EXPECT_EQ(ppc::util::GetNamespace<char16_t>(), "");
   EXPECT_EQ(ppc::util::GetNamespace<char32_t>(), "");
@@ -49,23 +65,9 @@ TEST(GetNamespaceEdgeCases, GetNamespace_WithBuiltinTypes_ReturnsEmpty) {
 }
 
 // Test with very long namespace chain
-namespace a {
-namespace b {
-namespace c {
-namespace d {
-namespace e {
-namespace f {
-namespace g {
-namespace h {
+namespace a::b::c::d::e::f::g::h {
 struct DeepType {};
-}  // namespace h
-}  // namespace g
-}  // namespace f
-}  // namespace e
-}  // namespace d
-}  // namespace c
-}  // namespace b
-}  // namespace a
+}  // namespace a::b::c::d::e::f::g::h
 
 TEST(GetNamespaceEdgeCases, GetNamespace_WithVeryDeepNamespace_ExtractsCorrectly) {
   std::string k_ns = ppc::util::GetNamespace<a::b::c::d::e::f::g::h::DeepType>();