refactor GetNamespace tests and implementation to standardize variable naming and trim type prefixes

Author: allnes

modules/core/performance/tests/perf_tests.cpp

@@ -263,14 +263,14 @@ using TestTypes = ::testing::Types<my::nested::Type, my::Another, int>;
 TYPED_TEST_SUITE(GetNamespaceTest, TestTypes);
 
 TYPED_TEST(GetNamespaceTest, ExtractsNamespaceCorrectly) {
-  std::string kNs = ppc::util::GetNamespace<TypeParam>();
+  std::string k_ns = ppc::util::GetNamespace<TypeParam>();
 
   if constexpr (std::is_same_v<TypeParam, my::nested::Type>) {
-    EXPECT_EQ(kNs, "my::nested");
+    EXPECT_EQ(k_ns, "my::nested");
   } else if constexpr (std::is_same_v<TypeParam, my::Another>) {
-    EXPECT_EQ(kNs, "my");
+    EXPECT_EQ(k_ns, "my");
   } else if constexpr (std::is_same_v<TypeParam, int>) {
-    EXPECT_EQ(kNs, "");
+    EXPECT_EQ(k_ns, "");
   } else {
     FAIL() << "Unhandled type in test";
   }

modules/core/util/include/util.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <cstdint>
 #include <cstdlib>
 #include <memory>
@@ -60,6 +61,14 @@ std::string GetNamespace() {
                                                    std::free};
   name = (status == 0) ? demangled.get() : name;
 #endif
+  const std::string prefixes[] = {"class ", "struct ", "enum ", "union "};
+  for (const auto& prefix : prefixes) {
+    if (name.starts_with(prefix)) {
+      name = name.substr(prefix.size());
+      break;
+    }
+  }
+  name.erase(0, name.find_first_not_of(' '));
   auto pos = name.rfind("::");
   return (pos != std::string::npos) ? name.substr(0, pos) : std::string{};
 }

modules/core/util/tests/util.cpp

@@ -12,8 +12,8 @@ struct Type {};
 }  // namespace my::nested
 
 TEST(util_tests, extracts_correct_namespace) {
-  std::string kNs = ppc::util::GetNamespace<my::nested::Type>();
-  EXPECT_EQ(kNs, "my::nested");
+  std::string k_ns = ppc::util::GetNamespace<my::nested::Type>();
+  EXPECT_EQ(k_ns, "my::nested");
 }
 
 TEST(util_tests, threads_control_check_openmp_disabled_valgrind) {
@@ -29,49 +29,49 @@ struct TypeInNamespace {};
 struct PlainType {};
 
 TEST(GetNamespaceTest, ReturnsExpectedNamespace) {
-  std::string kNs = ppc::util::GetNamespace<test_ns::TypeInNamespace>();
-  EXPECT_EQ(kNs, "test_ns");
+  std::string k_ns = ppc::util::GetNamespace<test_ns::TypeInNamespace>();
+  EXPECT_EQ(k_ns, "test_ns");
 }
 
 TEST(GetNamespaceTest, ReturnsEmptyIfNoNamespace_PrimitiveType) {
-  std::string kNs = ppc::util::GetNamespace<int>();
-  EXPECT_EQ(kNs, "");
+  std::string k_ns = ppc::util::GetNamespace<int>();
+  EXPECT_EQ(k_ns, "");
 }
 
 TEST(GetNamespaceTest, ReturnsEmptyIfNoNamespace_PlainStruct) {
-  std::string kNs = ppc::util::GetNamespace<PlainType>();
-  EXPECT_EQ(kNs, "");
+  std::string k_ns = ppc::util::GetNamespace<PlainType>();
+  EXPECT_EQ(k_ns, "");
 }
 
 namespace test_ns {
 struct Nested {};
 }  // namespace test_ns
 
 TEST(GetNamespaceTest, ReturnsNamespaceCorrectly) {
-  std::string kNs = ppc::util::GetNamespace<test_ns::Nested>();
-  EXPECT_EQ(kNs, "test_ns");
+  std::string k_ns = ppc::util::GetNamespace<test_ns::Nested>();
+  EXPECT_EQ(k_ns, "test_ns");
 }
 
 struct NoNamespaceType {};
 
 TEST(GetNamespaceTest, NoNamespaceInType) {
-  std::string kNs = ppc::util::GetNamespace<NoNamespaceType>();
-  EXPECT_EQ(kNs, "");
+  std::string k_ns = ppc::util::GetNamespace<NoNamespaceType>();
+  EXPECT_EQ(k_ns, "");
 }
 
 template <typename T>
 struct NotATemplate {};
 
 TEST(GetNamespaceTest, NoKeyInPrettyFunction) {
-  std::string kNs = ppc::util::GetNamespace<NotATemplate<void>>();
-  EXPECT_EQ(kNs, "");
+  std::string k_ns = ppc::util::GetNamespace<NotATemplate<void>>();
+  EXPECT_EQ(k_ns, "");
 }
 
 namespace crazy {
 struct VeryLongTypeNameWithOnlyLettersAndUnderscores {};
 }  // namespace crazy
 
 TEST(GetNamespaceTest, NoTerminatorCharactersInPrettyFunction) {
-  std::string kNs = ppc::util::GetNamespace<crazy::VeryLongTypeNameWithOnlyLettersAndUnderscores>();
-  EXPECT_EQ(kNs, "crazy");
+  std::string k_ns = ppc::util::GetNamespace<crazy::VeryLongTypeNameWithOnlyLettersAndUnderscores>();
+  EXPECT_EQ(k_ns, "crazy");
 }