data-structure-typed 2.4.1 → 2.4.3

package/build/_deps/benchmark-src/test/skip_with_error_test.cc

@@ -1,199 +0,0 @@
-
-#undef NDEBUG
-#include <cassert>
-#include <vector>
-
-#include "../src/check.h"  // NOTE: check.h is for internal use only!
-#include "benchmark/benchmark.h"
-
-namespace {
-
-class TestReporter : public benchmark::ConsoleReporter {
- public:
-  bool ReportContext(const Context& context) override {
-    return ConsoleReporter::ReportContext(context);
-  };
-
-  void ReportRuns(const std::vector<Run>& report) override {
-    all_runs_.insert(all_runs_.end(), begin(report), end(report));
-    ConsoleReporter::ReportRuns(report);
-  }
-
-  TestReporter() {}
-  ~TestReporter() override {}
-
-  mutable std::vector<Run> all_runs_;
-};
-
-struct TestCase {
-  std::string name;
-  bool error_occurred;
-  std::string error_message;
-
-  typedef benchmark::BenchmarkReporter::Run Run;
-
-  void CheckRun(Run const& run) const {
-    BM_CHECK(name == run.benchmark_name())
-        << "expected " << name << " got " << run.benchmark_name();
-    BM_CHECK_EQ(error_occurred,
-                benchmark::internal::SkippedWithError == run.skipped);
-    BM_CHECK(error_message == run.skip_message);
-    if (error_occurred) {
-      // BM_CHECK(run.iterations == 0);
-    } else {
-      BM_CHECK(run.iterations != 0);
-    }
-  }
-};
-
-std::vector<TestCase> ExpectedResults;
-
-int AddCases(const std::string& base_name,
-             std::initializer_list<TestCase> const& v) {
-  for (auto TC : v) {
-    TC.name = base_name + TC.name;
-    ExpectedResults.push_back(std::move(TC));
-  }
-  return 0;
-}
-
-#define CONCAT(x, y) CONCAT2(x, y)
-#define CONCAT2(x, y) x##y
-#define ADD_CASES(...) int CONCAT(dummy, __LINE__) = AddCases(__VA_ARGS__)
-
-}  // end namespace
-
-void BM_error_no_running(benchmark::State& state) {
-  state.SkipWithError("error message");
-}
-BENCHMARK(BM_error_no_running);
-ADD_CASES("BM_error_no_running", {{"", true, "error message"}});
-
-void BM_error_before_running(benchmark::State& state) {
-  state.SkipWithError("error message");
-  while (state.KeepRunning()) {
-    assert(false);
-  }
-}
-BENCHMARK(BM_error_before_running);
-ADD_CASES("BM_error_before_running", {{"", true, "error message"}});
-
-void BM_error_before_running_batch(benchmark::State& state) {
-  state.SkipWithError("error message");
-  while (state.KeepRunningBatch(17)) {
-    assert(false);
-  }
-}
-BENCHMARK(BM_error_before_running_batch);
-ADD_CASES("BM_error_before_running_batch", {{"", true, "error message"}});
-
-void BM_error_before_running_range_for(benchmark::State& state) {
-  state.SkipWithError("error message");
-  for (auto _ : state) {
-    assert(false);
-  }
-}
-BENCHMARK(BM_error_before_running_range_for);
-ADD_CASES("BM_error_before_running_range_for", {{"", true, "error message"}});
-
-void BM_error_during_running(benchmark::State& state) {
-  int first_iter = true;
-  while (state.KeepRunning()) {
-    if (state.range(0) == 1 && state.thread_index() <= (state.threads() / 2)) {
-      assert(first_iter);
-      first_iter = false;
-      state.SkipWithError("error message");
-    } else {
-      state.PauseTiming();
-      state.ResumeTiming();
-    }
-  }
-}
-BENCHMARK(BM_error_during_running)->Arg(1)->Arg(2)->ThreadRange(1, 8);
-ADD_CASES("BM_error_during_running", {{"/1/threads:1", true, "error message"},
-                                      {"/1/threads:2", true, "error message"},
-                                      {"/1/threads:4", true, "error message"},
-                                      {"/1/threads:8", true, "error message"},
-                                      {"/2/threads:1", false, ""},
-                                      {"/2/threads:2", false, ""},
-                                      {"/2/threads:4", false, ""},
-                                      {"/2/threads:8", false, ""}});
-
-void BM_error_during_running_ranged_for(benchmark::State& state) {
-  assert(state.max_iterations > 3 && "test requires at least a few iterations");
-  bool first_iter = true;
-  // NOTE: Users should not write the for loop explicitly.
-  for (auto It = state.begin(), End = state.end(); It != End; ++It) {
-    if (state.range(0) == 1) {
-      assert(first_iter);
-      first_iter = false;
-      (void)first_iter;
-      state.SkipWithError("error message");
-      // Test the unfortunate but documented behavior that the ranged-for loop
-      // doesn't automatically terminate when SkipWithError is set.
-      assert(++It != End);
-      break;  // Required behavior
-    }
-  }
-}
-BENCHMARK(BM_error_during_running_ranged_for)->Arg(1)->Arg(2)->Iterations(5);
-ADD_CASES("BM_error_during_running_ranged_for",
-          {{"/1/iterations:5", true, "error message"},
-           {"/2/iterations:5", false, ""}});
-
-void BM_error_after_running(benchmark::State& state) {
-  for (auto _ : state) {
-    auto iterations = state.iterations();
-    benchmark::DoNotOptimize(iterations);
-  }
-  if (state.thread_index() <= (state.threads() / 2))
-    state.SkipWithError("error message");
-}
-BENCHMARK(BM_error_after_running)->ThreadRange(1, 8);
-ADD_CASES("BM_error_after_running", {{"/threads:1", true, "error message"},
-                                     {"/threads:2", true, "error message"},
-                                     {"/threads:4", true, "error message"},
-                                     {"/threads:8", true, "error message"}});
-
-void BM_error_while_paused(benchmark::State& state) {
-  bool first_iter = true;
-  while (state.KeepRunning()) {
-    if (state.range(0) == 1 && state.thread_index() <= (state.threads() / 2)) {
-      assert(first_iter);
-      first_iter = false;
-      state.PauseTiming();
-      state.SkipWithError("error message");
-    } else {
-      state.PauseTiming();
-      state.ResumeTiming();
-    }
-  }
-}
-BENCHMARK(BM_error_while_paused)->Arg(1)->Arg(2)->ThreadRange(1, 8);
-ADD_CASES("BM_error_while_paused", {{"/1/threads:1", true, "error message"},
-                                    {"/1/threads:2", true, "error message"},
-                                    {"/1/threads:4", true, "error message"},
-                                    {"/1/threads:8", true, "error message"},
-                                    {"/2/threads:1", false, ""},
-                                    {"/2/threads:2", false, ""},
-                                    {"/2/threads:4", false, ""},
-                                    {"/2/threads:8", false, ""}});
-
-int main(int argc, char* argv[]) {
-  benchmark::Initialize(&argc, argv);
-
-  TestReporter test_reporter;
-  benchmark::RunSpecifiedBenchmarks(&test_reporter);
-
-  typedef benchmark::BenchmarkReporter::Run Run;
-  auto EB = ExpectedResults.begin();
-
-  for (Run const& run : test_reporter.all_runs_) {
-    assert(EB != ExpectedResults.end());
-    EB->CheckRun(run);
-    ++EB;
-  }
-  assert(EB == ExpectedResults.end());
-
-  return 0;
-}

package/build/_deps/benchmark-src/test/spec_arg_test.cc

@@ -1,105 +0,0 @@
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <limits>
-#include <string>
-#include <vector>
-
-#include "benchmark/benchmark.h"
-
-// Tests that we can override benchmark-spec value from FLAGS_benchmark_filter
-// with argument to RunSpecifiedBenchmarks(...).
-
-namespace {
-
-class TestReporter : public benchmark::ConsoleReporter {
- public:
-  bool ReportContext(const Context& context) override {
-    return ConsoleReporter::ReportContext(context);
-  };
-
-  void ReportRuns(const std::vector<Run>& report) override {
-    assert(report.size() == 1);
-    matched_functions.push_back(report[0].run_name.function_name);
-    ConsoleReporter::ReportRuns(report);
-  };
-
-  TestReporter() {}
-
-  ~TestReporter() override {}
-
-  const std::vector<std::string>& GetMatchedFunctions() const {
-    return matched_functions;
-  }
-
- private:
-  std::vector<std::string> matched_functions;
-};
-
-}  // end namespace
-
-static void BM_NotChosen(benchmark::State& state) {
-  assert(false && "SHOULD NOT BE CALLED");
-  for (auto _ : state) {
-  }
-}
-BENCHMARK(BM_NotChosen);
-
-static void BM_Chosen(benchmark::State& state) {
-  for (auto _ : state) {
-  }
-}
-BENCHMARK(BM_Chosen);
-
-int main(int argc, char** argv) {
-  const std::string flag = "BM_NotChosen";
-
-  // Verify that argv specify --benchmark_filter=BM_NotChosen.
-  bool found = false;
-  for (int i = 0; i < argc; ++i) {
-    if (strcmp("--benchmark_filter=BM_NotChosen", argv[i]) == 0) {
-      found = true;
-      break;
-    }
-  }
-  assert(found);
-
-  benchmark::Initialize(&argc, argv);
-
-  // Check that the current flag value is reported accurately via the
-  // GetBenchmarkFilter() function.
-  if (flag != benchmark::GetBenchmarkFilter()) {
-    std::cerr
-        << "Seeing different value for flags. GetBenchmarkFilter() returns ["
-        << benchmark::GetBenchmarkFilter() << "] expected flag=[" << flag
-        << "]\n";
-    return 1;
-  }
-  TestReporter test_reporter;
-  const char* const spec = "BM_Chosen";
-  const size_t returned_count =
-      benchmark::RunSpecifiedBenchmarks(&test_reporter, spec);
-  assert(returned_count == 1);
-  const std::vector<std::string> matched_functions =
-      test_reporter.GetMatchedFunctions();
-  assert(matched_functions.size() == 1);
-  if (strcmp(spec, matched_functions.front().c_str()) != 0) {
-    std::cerr << "Expected benchmark [" << spec << "] to run, but got ["
-              << matched_functions.front() << "]\n";
-    return 2;
-  }
-
-  // Test that SetBenchmarkFilter works.
-  const std::string golden_value = "golden_value";
-  benchmark::SetBenchmarkFilter(golden_value);
-  std::string current_value = benchmark::GetBenchmarkFilter();
-  if (golden_value != current_value) {
-    std::cerr << "Expected [" << golden_value
-              << "] for --benchmark_filter but got [" << current_value << "]\n";
-    return 3;
-  }
-  return 0;
-}

package/build/_deps/benchmark-src/test/spec_arg_verbosity_test.cc

@@ -1,43 +0,0 @@
-#include <string.h>
-
-#include <iostream>
-
-#include "benchmark/benchmark.h"
-
-// Tests that the user specified verbosity level can be get.
-static void BM_Verbosity(benchmark::State& state) {
-  for (auto _ : state) {
-  }
-}
-BENCHMARK(BM_Verbosity);
-
-int main(int argc, char** argv) {
-  const int32_t flagv = 42;
-
-  // Verify that argv specify --v=42.
-  bool found = false;
-  for (int i = 0; i < argc; ++i) {
-    if (strcmp("--v=42", argv[i]) == 0) {
-      found = true;
-      break;
-    }
-  }
-  if (!found) {
-    std::cerr << "This test requires '--v=42' to be passed as a command-line "
-              << "argument.\n";
-    return 1;
-  }
-
-  benchmark::Initialize(&argc, argv);
-
-  // Check that the current flag value is reported accurately via the
-  // GetBenchmarkVerbosity() function.
-  if (flagv != benchmark::GetBenchmarkVerbosity()) {
-    std::cerr
-        << "Seeing different value for flags. GetBenchmarkVerbosity() returns ["
-        << benchmark::GetBenchmarkVerbosity() << "] expected flag=[" << flagv
-        << "]\n";
-    return 1;
-  }
-  return 0;
-}

package/build/_deps/benchmark-src/test/state_assembly_test.cc

@@ -1,68 +0,0 @@
-#include <benchmark/benchmark.h>
-
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wreturn-type"
-#endif
-
-// clang-format off
-extern "C" {
-  extern int ExternInt;
-  benchmark::State& GetState();
-  void Fn();
-}
-// clang-format on
-
-using benchmark::State;
-
-// CHECK-LABEL: test_for_auto_loop:
-extern "C" int test_for_auto_loop() {
-  State& S = GetState();
-  int x = 42;
-  // CHECK: 	[[CALL:call(q)*]]	_ZN9benchmark5State16StartKeepRunningEv
-  // CHECK-NEXT: testq %rbx, %rbx
-  // CHECK-NEXT: je [[LOOP_END:.*]]
-
-  for (auto _ : S) {
-    // CHECK: .L[[LOOP_HEAD:[a-zA-Z0-9_]+]]:
-    // CHECK-GNU-NEXT: subq $1, %rbx
-    // CHECK-CLANG-NEXT: {{(addq \$1, %rax|incq %rax|addq \$-1, %rbx)}}
-    // CHECK-NEXT: jne .L[[LOOP_HEAD]]
-    benchmark::DoNotOptimize(x);
-  }
-  // CHECK: [[LOOP_END]]:
-  // CHECK: [[CALL]]	_ZN9benchmark5State17FinishKeepRunningEv
-
-  // CHECK: movl $101, %eax
-  // CHECK: ret
-  return 101;
-}
-
-// CHECK-LABEL: test_while_loop:
-extern "C" int test_while_loop() {
-  State& S = GetState();
-  int x = 42;
-
-  // CHECK: j{{(e|mp)}} .L[[LOOP_HEADER:[a-zA-Z0-9_]+]]
-  // CHECK-NEXT: .L[[LOOP_BODY:[a-zA-Z0-9_]+]]:
-  while (S.KeepRunning()) {
-    // CHECK-GNU-NEXT: subq $1, %[[IREG:[a-z]+]]
-    // CHECK-CLANG-NEXT: {{(addq \$-1,|decq)}} %[[IREG:[a-z]+]]
-    // CHECK: movq %[[IREG]], [[DEST:.*]]
-    benchmark::DoNotOptimize(x);
-  }
-  // CHECK-DAG: movq [[DEST]], %[[IREG]]
-  // CHECK-DAG: testq %[[IREG]], %[[IREG]]
-  // CHECK-DAG: jne .L[[LOOP_BODY]]
-  // CHECK-DAG: .L[[LOOP_HEADER]]:
-
-  // CHECK: cmpb $0
-  // CHECK-NEXT: jne .L[[LOOP_END:[a-zA-Z0-9_]+]]
-  // CHECK: [[CALL:call(q)*]] _ZN9benchmark5State16StartKeepRunningEv
-
-  // CHECK: .L[[LOOP_END]]:
-  // CHECK: [[CALL]] _ZN9benchmark5State17FinishKeepRunningEv
-
-  // CHECK: movl $101, %eax
-  // CHECK: ret
-  return 101;
-}

package/build/_deps/benchmark-src/test/statistics_gtest.cc

@@ -1,35 +0,0 @@
-//===---------------------------------------------------------------------===//
-// statistics_test - Unit tests for src/statistics.cc
-//===---------------------------------------------------------------------===//
-
-#include "../src/statistics.h"
-#include "gtest/gtest.h"
-
-namespace {
-TEST(StatisticsTest, Mean) {
-  EXPECT_DOUBLE_EQ(benchmark::StatisticsMean({42, 42, 42, 42}), 42.0);
-  EXPECT_DOUBLE_EQ(benchmark::StatisticsMean({1, 2, 3, 4}), 2.5);
-  EXPECT_DOUBLE_EQ(benchmark::StatisticsMean({1, 2, 5, 10, 10, 14}), 7.0);
-}
-
-TEST(StatisticsTest, Median) {
-  EXPECT_DOUBLE_EQ(benchmark::StatisticsMedian({42, 42, 42, 42}), 42.0);
-  EXPECT_DOUBLE_EQ(benchmark::StatisticsMedian({1, 2, 3, 4}), 2.5);
-  EXPECT_DOUBLE_EQ(benchmark::StatisticsMedian({1, 2, 5, 10, 10}), 5.0);
-}
-
-TEST(StatisticsTest, StdDev) {
-  EXPECT_DOUBLE_EQ(benchmark::StatisticsStdDev({101, 101, 101, 101}), 0.0);
-  EXPECT_DOUBLE_EQ(benchmark::StatisticsStdDev({1, 2, 3}), 1.0);
-  EXPECT_DOUBLE_EQ(benchmark::StatisticsStdDev({2.5, 2.4, 3.3, 4.2, 5.1}),
-                   1.151086443322134);
-}
-
-TEST(StatisticsTest, CV) {
-  EXPECT_DOUBLE_EQ(benchmark::StatisticsCV({101, 101, 101, 101}), 0.0);
-  EXPECT_DOUBLE_EQ(benchmark::StatisticsCV({1, 2, 3}), 1. / 2.);
-  EXPECT_DOUBLE_EQ(benchmark::StatisticsCV({2.5, 2.4, 3.3, 4.2, 5.1}),
-                   0.32888184094918121);
-}
-
-}  // end namespace

package/build/_deps/benchmark-src/test/string_util_gtest.cc

@@ -1,199 +0,0 @@
-//===---------------------------------------------------------------------===//
-// string_util_test - Unit tests for src/string_util.cc
-//===---------------------------------------------------------------------===//
-
-#include <tuple>
-
-#include "../src/internal_macros.h"
-#include "../src/string_util.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-namespace {
-TEST(StringUtilTest, stoul) {
-  {
-    size_t pos = 0;
-    EXPECT_EQ(0ul, benchmark::stoul("0", &pos));
-    EXPECT_EQ(1ul, pos);
-  }
-  {
-    size_t pos = 0;
-    EXPECT_EQ(7ul, benchmark::stoul("7", &pos));
-    EXPECT_EQ(1ul, pos);
-  }
-  {
-    size_t pos = 0;
-    EXPECT_EQ(135ul, benchmark::stoul("135", &pos));
-    EXPECT_EQ(3ul, pos);
-  }
-#if ULONG_MAX == 0xFFFFFFFFul
-  {
-    size_t pos = 0;
-    EXPECT_EQ(0xFFFFFFFFul, benchmark::stoul("4294967295", &pos));
-    EXPECT_EQ(10ul, pos);
-  }
-#elif ULONG_MAX == 0xFFFFFFFFFFFFFFFFul
-  {
-    size_t pos = 0;
-    EXPECT_EQ(0xFFFFFFFFFFFFFFFFul,
-              benchmark::stoul("18446744073709551615", &pos));
-    EXPECT_EQ(20ul, pos);
-  }
-#endif
-  {
-    size_t pos = 0;
-    EXPECT_EQ(10ul, benchmark::stoul("1010", &pos, 2));
-    EXPECT_EQ(4ul, pos);
-  }
-  {
-    size_t pos = 0;
-    EXPECT_EQ(520ul, benchmark::stoul("1010", &pos, 8));
-    EXPECT_EQ(4ul, pos);
-  }
-  {
-    size_t pos = 0;
-    EXPECT_EQ(1010ul, benchmark::stoul("1010", &pos, 10));
-    EXPECT_EQ(4ul, pos);
-  }
-  {
-    size_t pos = 0;
-    EXPECT_EQ(4112ul, benchmark::stoul("1010", &pos, 16));
-    EXPECT_EQ(4ul, pos);
-  }
-  {
-    size_t pos = 0;
-    EXPECT_EQ(0xBEEFul, benchmark::stoul("BEEF", &pos, 16));
-    EXPECT_EQ(4ul, pos);
-  }
-#ifndef BENCHMARK_HAS_NO_EXCEPTIONS
-  {
-    ASSERT_THROW(std::ignore = benchmark::stoul("this is a test"),
-                 std::invalid_argument);
-  }
-#endif
-}
-
-TEST(StringUtilTest, stoi){{size_t pos = 0;
-EXPECT_EQ(0, benchmark::stoi("0", &pos));
-EXPECT_EQ(1ul, pos);
-}  // namespace
-{
-  size_t pos = 0;
-  EXPECT_EQ(-17, benchmark::stoi("-17", &pos));
-  EXPECT_EQ(3ul, pos);
-}
-{
-  size_t pos = 0;
-  EXPECT_EQ(1357, benchmark::stoi("1357", &pos));
-  EXPECT_EQ(4ul, pos);
-}
-{
-  size_t pos = 0;
-  EXPECT_EQ(10, benchmark::stoi("1010", &pos, 2));
-  EXPECT_EQ(4ul, pos);
-}
-{
-  size_t pos = 0;
-  EXPECT_EQ(520, benchmark::stoi("1010", &pos, 8));
-  EXPECT_EQ(4ul, pos);
-}
-{
-  size_t pos = 0;
-  EXPECT_EQ(1010, benchmark::stoi("1010", &pos, 10));
-  EXPECT_EQ(4ul, pos);
-}
-{
-  size_t pos = 0;
-  EXPECT_EQ(4112, benchmark::stoi("1010", &pos, 16));
-  EXPECT_EQ(4ul, pos);
-}
-{
-  size_t pos = 0;
-  EXPECT_EQ(0xBEEF, benchmark::stoi("BEEF", &pos, 16));
-  EXPECT_EQ(4ul, pos);
-}
-#ifndef BENCHMARK_HAS_NO_EXCEPTIONS
-{
-  ASSERT_THROW(std::ignore = benchmark::stoi("this is a test"),
-               std::invalid_argument);
-}
-#endif
-}
-
-TEST(StringUtilTest, stod){{size_t pos = 0;
-EXPECT_EQ(0.0, benchmark::stod("0", &pos));
-EXPECT_EQ(1ul, pos);
-}
-{
-  size_t pos = 0;
-  EXPECT_EQ(-84.0, benchmark::stod("-84", &pos));
-  EXPECT_EQ(3ul, pos);
-}
-{
-  size_t pos = 0;
-  EXPECT_EQ(1234.0, benchmark::stod("1234", &pos));
-  EXPECT_EQ(4ul, pos);
-}
-{
-  size_t pos = 0;
-  EXPECT_EQ(1.5, benchmark::stod("1.5", &pos));
-  EXPECT_EQ(3ul, pos);
-}
-{
-  size_t pos = 0;
-  /* Note: exactly representable as double */
-  EXPECT_EQ(-1.25e+9, benchmark::stod("-1.25e+9", &pos));
-  EXPECT_EQ(8ul, pos);
-}
-#ifndef BENCHMARK_HAS_NO_EXCEPTIONS
-{
-  ASSERT_THROW(std::ignore = benchmark::stod("this is a test"),
-               std::invalid_argument);
-}
-#endif
-}
-
-TEST(StringUtilTest, StrSplit) {
-  EXPECT_EQ(benchmark::StrSplit("", ','), std::vector<std::string>{});
-  EXPECT_EQ(benchmark::StrSplit("hello", ','),
-            std::vector<std::string>({"hello"}));
-  EXPECT_EQ(benchmark::StrSplit("hello,there,is,more", ','),
-            std::vector<std::string>({"hello", "there", "is", "more"}));
-}
-
-using HumanReadableFixture = ::testing::TestWithParam<
-    std::tuple<double, benchmark::Counter::OneK, std::string>>;
-
-INSTANTIATE_TEST_SUITE_P(
-    HumanReadableTests, HumanReadableFixture,
-    ::testing::Values(
-        std::make_tuple(0.0, benchmark::Counter::kIs1024, "0"),
-        std::make_tuple(999.0, benchmark::Counter::kIs1024, "999"),
-        std::make_tuple(1000.0, benchmark::Counter::kIs1024, "1000"),
-        std::make_tuple(1024.0, benchmark::Counter::kIs1024, "1Ki"),
-        std::make_tuple(1000 * 1000.0, benchmark::Counter::kIs1024,
-                        "976\\.56.Ki"),
-        std::make_tuple(1024 * 1024.0, benchmark::Counter::kIs1024, "1Mi"),
-        std::make_tuple(1000 * 1000 * 1000.0, benchmark::Counter::kIs1024,
-                        "953\\.674Mi"),
-        std::make_tuple(1024 * 1024 * 1024.0, benchmark::Counter::kIs1024,
-                        "1Gi"),
-        std::make_tuple(0.0, benchmark::Counter::kIs1000, "0"),
-        std::make_tuple(999.0, benchmark::Counter::kIs1000, "999"),
-        std::make_tuple(1000.0, benchmark::Counter::kIs1000, "1k"),
-        std::make_tuple(1024.0, benchmark::Counter::kIs1000, "1.024k"),
-        std::make_tuple(1000 * 1000.0, benchmark::Counter::kIs1000, "1M"),
-        std::make_tuple(1024 * 1024.0, benchmark::Counter::kIs1000,
-                        "1\\.04858M"),
-        std::make_tuple(1000 * 1000 * 1000.0, benchmark::Counter::kIs1000,
-                        "1G"),
-        std::make_tuple(1024 * 1024 * 1024.0, benchmark::Counter::kIs1000,
-                        "1\\.07374G")));
-
-TEST_P(HumanReadableFixture, HumanReadableNumber) {
-  std::string str = benchmark::HumanReadableNumber(std::get<0>(GetParam()),
-                                                   std::get<1>(GetParam()));
-  ASSERT_THAT(str, ::testing::MatchesRegex(std::get<2>(GetParam())));
-}
-
-}  // end namespace

package/build/_deps/benchmark-src/test/templated_fixture_test.cc

@@ -1,28 +0,0 @@
-
-#include <cassert>
-#include <memory>
-
-#include "benchmark/benchmark.h"
-
-template <typename T>
-class MyFixture : public ::benchmark::Fixture {
- public:
-  MyFixture() : data(0) {}
-
-  T data;
-};
-
-BENCHMARK_TEMPLATE_F(MyFixture, Foo, int)(benchmark::State& st) {
-  for (auto _ : st) {
-    data += 1;
-  }
-}
-
-BENCHMARK_TEMPLATE_DEFINE_F(MyFixture, Bar, double)(benchmark::State& st) {
-  for (auto _ : st) {
-    data += 1.0;
-  }
-}
-BENCHMARK_REGISTER_F(MyFixture, Bar);
-
-BENCHMARK_MAIN();