fix(google_benchmark): generate proper uri

examples/google_benchmark/main.cpp

@@ -1,6 +1,60 @@
 #include <benchmark/benchmark.h>
 #include <cstring>
 
+// Passing Arbitrary Arguments to a Benchmark
+// See:
+// https://github.com/google/benchmark/blob/main/docs/user_guide.md#passing-arbitrary-arguments-to-a-benchmark
+template <class... Args>
+void BM_takes_args(benchmark::State &state, Args &&...args) {
+  auto args_tuple = std::make_tuple(std::move(args)...);
+  for (auto _ : state) {
+  }
+}
+BENCHMARK_CAPTURE(BM_takes_args, int_string_test, 42, std::string("abc"));
+BENCHMARK_CAPTURE(BM_takes_args, int_test, 42, 43);
+
+// Benchmark template
+//
+template <class T> void BM_VectorPushBack(benchmark::State &state) {
+  std::vector<T> v;
+  for (auto _ : state) {
+    v.push_back(T());
+  }
+}
+BENCHMARK_TEMPLATE(BM_VectorPushBack, int);
+BENCHMARK_TEMPLATE(BM_VectorPushBack, std::string);
+
+template <typename T> void BM_Template1(benchmark::State &state) {
+  T val = T();
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(val++);
+  }
+}
+BENCHMARK_TEMPLATE1(BM_Template1, int);
+
+template <typename T, typename U> void BM_Template2(benchmark::State &state) {
+  T t = T();
+  U u = U();
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(t + u);
+  }
+}
+BENCHMARK_TEMPLATE2(BM_Template2, int, double);
+
+// Benchmark template capture
+//
+template <typename T, class... ExtraArgs>
+void BM_takes_args(benchmark::State &state, ExtraArgs &&...extra_args) {
+  auto args_tuple = std::make_tuple(std::move(extra_args)...);
+  for (auto _ : state) {
+  }
+}
+BENCHMARK_TEMPLATE1_CAPTURE(BM_takes_args, void, int_string_test, 42,
+                            std::string("abc"));
+
+BENCHMARK_TEMPLATE2_CAPTURE(BM_takes_args, int, double, two_type_test, 42,
+                            std::string("abc"));
+
 // Function to benchmark
 static void BM_rand_vector(benchmark::State &state) {
   std::vector<int> v;

google_benchmark/include/benchmark/benchmark.h

@@ -1440,21 +1440,23 @@ class Fixture : public internal::Benchmark {
 
 #ifdef CODSPEED_ENABLED
 #include <filesystem>
-#define BENCHMARK(...)                                                   \
-  BENCHMARK_PRIVATE_DECLARE(_benchmark_) =                               \
-      (::benchmark::internal::RegisterBenchmarkInternal(                 \
-          std::make_unique<::benchmark::internal::FunctionBenchmark>(    \
-              std::filesystem::relative(__FILE__, CODSPEED_GIT_ROOT_DIR) \
-                      .string() +                                        \
-                  "::" + #__VA_ARGS__,                                   \
-              __VA_ARGS__)))
+#define CUR_FILE \
+  std::filesystem::relative(__FILE__, CODSPEED_GIT_ROOT_DIR).string() + "::"
+#define TYPE_START "["
+#define TYPE_END "]"
+#define FUNC_TEST_SEP "::"
 #else
+#define CUR_FILE std::string()
+#define TYPE_START "<"
+#define TYPE_END ">"
+#define FUNC_TEST_SEP "/"
+#endif
+
 #define BENCHMARK(...)                                                \
   BENCHMARK_PRIVATE_DECLARE(_benchmark_) =                            \
       (::benchmark::internal::RegisterBenchmarkInternal(              \
           std::make_unique<::benchmark::internal::FunctionBenchmark>( \
-              #__VA_ARGS__, __VA_ARGS__)))
-#endif
+              CUR_FILE + #__VA_ARGS__, __VA_ARGS__)))
 
 // Old-style macros
 #define BENCHMARK_WITH_ARG(n, a) BENCHMARK(n)->Arg((a))
@@ -1479,7 +1481,7 @@ class Fixture : public internal::Benchmark {
   BENCHMARK_PRIVATE_DECLARE(_benchmark_) =                            \
       (::benchmark::internal::RegisterBenchmarkInternal(              \
           std::make_unique<::benchmark::internal::FunctionBenchmark>( \
-              #func "/" #test_case_name,                              \
+              CUR_FILE + #func FUNC_TEST_SEP #test_case_name,         \
               [](::benchmark::State& st) { func(st, __VA_ARGS__); })))
 
 // This will register a benchmark for a templatized function.  For example:
@@ -1494,19 +1496,20 @@ class Fixture : public internal::Benchmark {
   BENCHMARK_PRIVATE_DECLARE(n) =                                      \
       (::benchmark::internal::RegisterBenchmarkInternal(              \
           std::make_unique<::benchmark::internal::FunctionBenchmark>( \
-              #n "<" #a ">", n<a>)))
+              CUR_FILE + #n TYPE_START #a TYPE_END, n<a>)))
 
 #define BENCHMARK_TEMPLATE2(n, a, b)                                  \
   BENCHMARK_PRIVATE_DECLARE(n) =                                      \
       (::benchmark::internal::RegisterBenchmarkInternal(              \
           std::make_unique<::benchmark::internal::FunctionBenchmark>( \
-              #n "<" #a "," #b ">", n<a, b>)))
+              CUR_FILE + #n TYPE_START #a "," #b TYPE_END, n<a, b>)))
 
 #define BENCHMARK_TEMPLATE(n, ...)                                    \
   BENCHMARK_PRIVATE_DECLARE(n) =                                      \
       (::benchmark::internal::RegisterBenchmarkInternal(              \
           std::make_unique<::benchmark::internal::FunctionBenchmark>( \
-              #n "<" #__VA_ARGS__ ">", n<__VA_ARGS__>)))
+              CUR_FILE + #n TYPE_START #__VA_ARGS__ TYPE_END,         \
+              n<__VA_ARGS__>)))
 
 // This will register a benchmark for a templatized function,
 // with the additional arguments specified by `...`.
@@ -1520,15 +1523,20 @@ class Fixture : public internal::Benchmark {
 // /* Registers a benchmark named "BM_takes_args<void>/int_string_test` */
 // BENCHMARK_TEMPLATE1_CAPTURE(BM_takes_args, void, int_string_test, 42,
 //                             std::string("abc"));
+#ifdef CODSPEED_ENABLED
+#define BENCHMARK_TEMPLATE1_CAPTURE(func, a, test_case_name, ...) \
+  BENCHMARK_CAPTURE(func, test_case_name, __VA_ARGS__)
+#else
 #define BENCHMARK_TEMPLATE1_CAPTURE(func, a, test_case_name, ...) \
   BENCHMARK_CAPTURE(func<a>, test_case_name, __VA_ARGS__)
+#endif
 
 #define BENCHMARK_TEMPLATE2_CAPTURE(func, a, b, test_case_name, ...)  \
   BENCHMARK_PRIVATE_DECLARE(func) =                                   \
       (::benchmark::internal::RegisterBenchmarkInternal(              \
           std::make_unique<::benchmark::internal::FunctionBenchmark>( \
-              #func "<" #a "," #b ">"                                 \
-                    "/" #test_case_name,                              \
+              CUR_FILE + #func TYPE_START #a                          \
+                  "," #b TYPE_END FUNC_TEST_SEP #test_case_name,      \
               [](::benchmark::State& st) { func<a, b>(st, __VA_ARGS__); })))
 
 #define BENCHMARK_PRIVATE_DECLARE_F(BaseClass, Method)        \
@@ -1680,6 +1688,7 @@ struct BENCHMARK_EXPORT SystemInfo {
 // which allows individual fields to be modified or cleared before
 // building the final name using 'str()'.
 struct BENCHMARK_EXPORT BenchmarkName {
+  std::string path;
   std::string function_name;
   std::string args;
   std::string min_time;