feat(google_benchmark): add tests

Author: not-matthias

.github/workflows/ci.yml

@@ -7,6 +7,39 @@ on:
   workflow_dispatch:
 
 jobs:
+  tests:
+    runs-on: ubuntu-latest
+    steps: 
+    - name: Checkout code
+      uses: actions/checkout@v3
+
+    - name: Cache build
+      uses: actions/cache@v3
+      with:
+        path: core/build-tests
+        key: ${{ runner.os }}-build-tests-${{ hashFiles('**/CMakeLists.txt', '**/examples/google_benchmark/**') }}
+
+    - name: Create build directory
+      run: mkdir -p core/build-tests
+
+    - name: Build tests
+      run: |
+        cd core/build-tests
+        cmake .. -DENABLE_TESTS=ON
+        make -j
+
+    - name: Run tests
+      run: | 
+        cd core/build-tests
+        GTEST_OUTPUT=json:test-results/ ctest
+
+    - name: Upload test results
+      uses: actions/upload-artifact@v4
+      if: failure()
+      with:
+        name: test_results
+        path: ${{runner.workspace}}/core/build-tests/test/test-results/**/*.json
+  
   instrumentation:
     runs-on: ubuntu-latest
 

core/CMakeLists.txt

@@ -28,3 +28,9 @@ target_include_directories(
     codspeed
     PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
 )
+
+option(ENABLE_TESTS "Enable building the unit tests which depend on gtest" OFF)
+if(ENABLE_TESTS)
+    enable_testing() 
+    add_subdirectory(test)
+endif()

core/src/uri.cpp

@@ -2,32 +2,46 @@
 #include <string>
 #include <iostream>
 
-std::string extract_lambda_namespace(const std::string& pretty_func) {
-  if (pretty_func.find("(anonymous namespace)") != std::string::npos) {
-    std::cerr << "[ERROR] Anonymous namespace not supported in " << pretty_func << std::endl;
-    return {};
-  }
-
-#ifdef __clang__
-  // Example: auto outer::test12::(anonymous class)::operator()() const
-
-  std::size_t anon_class_pos = pretty_func.find("(anonymous class)");
+// Example: auto outer::test12::(anonymous class)::operator()() const
+// Returns: outer::test12::
+std::string extract_namespace_clang(const std::string& pretty_func) {
+  std::size_t anon_class_pos = pretty_func.find("::(anonymous class)");
   std::size_t space_pos = pretty_func.find(' ');
 
   if (space_pos == std::string::npos || anon_class_pos == std::string::npos) {
     return {};
   }
+  space_pos += 1; // Skip the space
 
   return pretty_func.substr(space_pos, anon_class_pos - space_pos) + "::";
-#elif __GNUC__
-    // Example: outer::test12::<lambda()>
+}
 
+// Example: outer::test12::<lambda()>
+// Returns: outer::test12::
+std::string extract_namespace_gcc(const std::string& pretty_func) {
     auto lambda_pos = pretty_func.find("::<lambda()>");
     if (lambda_pos == std::string::npos) {
         return {};
     }
 
     return pretty_func.substr(0, lambda_pos) + "::";
+}
+
+// Has to pass the pretty function from a lambda: 
+//   (([]() { return __PRETTY_FUNCTION__; })())
+//
+// Returns: An empty string if the namespace could not be extracted, 
+//         otherwise the namespace with a trailing "::"
+std::string extract_lambda_namespace(const std::string& pretty_func) {
+  if (pretty_func.find("(anonymous namespace)") != std::string::npos) {
+    std::cerr << "[ERROR] Anonymous namespace not supported in " << pretty_func << std::endl;
+    return {};
+  }
+
+#ifdef __clang__
+    return extract_namespace_clang(pretty_func);
+#elif __GNUC__
+    return extract_namespace_gcc(pretty_func);
 #else
 #error "Unsupported compiler"
 #endif

core/test/CMakeLists.txt

@@ -0,0 +1,22 @@
+include(FetchContent)
+FetchContent_Declare(
+    googletest
+    GIT_REPOSITORY https://github.com/google/googletest.git
+    GIT_TAG v1.16.0
+)
+FetchContent_MakeAvailable(googletest)
+
+add_executable(unit_tests
+  uri.cpp
+)
+
+target_link_libraries(unit_tests
+  PRIVATE
+  codspeed
+  GTest::gtest
+  GTest::gtest_main
+)
+
+include(GoogleTest)
+gtest_discover_tests(unit_tests)
+

core/test/uri.cpp

@@ -0,0 +1,30 @@
+
+#include <gtest/gtest.h>
+#include "codspeed.h"
+
+// Manual definition (to avoid including it in the public header):
+std::string extract_namespace_clang(const std::string& func_str); 
+std::string extract_namespace_gcc(const std::string& func_str);
+
+TEST(UriTest, TestExtractNamespaceClang) {
+    EXPECT_EQ(extract_namespace_clang("auto outer::test12::(anonymous class)::operator()() const"), "outer::test12::");
+    EXPECT_EQ(extract_namespace_clang("auto outer::(anonymous namespace)::test12::(anonymous class)::operator()() const"), "outer::(anonymous namespace)::test12::");
+}
+
+TEST(UriTest, TestExtractNamespaceGcc) {
+    EXPECT_EQ(extract_namespace_gcc("outer::test12::<lambda()>"), "outer::test12::");
+    EXPECT_EQ(extract_namespace_gcc("outer::(anonymous namespace)::test12::<lambda()>"), "outer::(anonymous namespace)::test12::");
+}
+
+
+namespace a {
+namespace b {
+namespace c {
+static std::string pretty_func = ([]() { return __PRETTY_FUNCTION__; })();
+
+TEST(UriTest, TestExtractNamespace) {
+    EXPECT_EQ(extract_lambda_namespace(pretty_func), "a::b::c::");
+}
+}
+}
+}