data-structure-typed 2.4.0 → 2.4.2

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

@@ -1,169 +0,0 @@
-#include <map>
-#include <string>
-#include <vector>
-
-#include "../src/benchmark_register.h"
-#include "benchmark/benchmark.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-namespace benchmark {
-namespace internal {
-
-namespace {
-
-TEST(AddRangeTest, Simple) {
-  std::vector<int> dst;
-  AddRange(&dst, 1, 2, 2);
-  EXPECT_THAT(dst, testing::ElementsAre(1, 2));
-}
-
-TEST(AddRangeTest, Simple64) {
-  std::vector<int64_t> dst;
-  AddRange(&dst, static_cast<int64_t>(1), static_cast<int64_t>(2), 2);
-  EXPECT_THAT(dst, testing::ElementsAre(1, 2));
-}
-
-TEST(AddRangeTest, Advanced) {
-  std::vector<int> dst;
-  AddRange(&dst, 5, 15, 2);
-  EXPECT_THAT(dst, testing::ElementsAre(5, 8, 15));
-}
-
-TEST(AddRangeTest, Advanced64) {
-  std::vector<int64_t> dst;
-  AddRange(&dst, static_cast<int64_t>(5), static_cast<int64_t>(15), 2);
-  EXPECT_THAT(dst, testing::ElementsAre(5, 8, 15));
-}
-
-TEST(AddRangeTest, FullRange8) {
-  std::vector<int8_t> dst;
-  AddRange(&dst, int8_t{1}, std::numeric_limits<int8_t>::max(), int8_t{8});
-  EXPECT_THAT(
-      dst, testing::ElementsAre(int8_t{1}, int8_t{8}, int8_t{64}, int8_t{127}));
-}
-
-TEST(AddRangeTest, FullRange64) {
-  std::vector<int64_t> dst;
-  AddRange(&dst, int64_t{1}, std::numeric_limits<int64_t>::max(), 1024);
-  EXPECT_THAT(
-      dst, testing::ElementsAre(1LL, 1024LL, 1048576LL, 1073741824LL,
-                                1099511627776LL, 1125899906842624LL,
-                                1152921504606846976LL, 9223372036854775807LL));
-}
-
-TEST(AddRangeTest, NegativeRanges) {
-  std::vector<int> dst;
-  AddRange(&dst, -8, 0, 2);
-  EXPECT_THAT(dst, testing::ElementsAre(-8, -4, -2, -1, 0));
-}
-
-TEST(AddRangeTest, StrictlyNegative) {
-  std::vector<int> dst;
-  AddRange(&dst, -8, -1, 2);
-  EXPECT_THAT(dst, testing::ElementsAre(-8, -4, -2, -1));
-}
-
-TEST(AddRangeTest, SymmetricNegativeRanges) {
-  std::vector<int> dst;
-  AddRange(&dst, -8, 8, 2);
-  EXPECT_THAT(dst, testing::ElementsAre(-8, -4, -2, -1, 0, 1, 2, 4, 8));
-}
-
-TEST(AddRangeTest, SymmetricNegativeRangesOddMult) {
-  std::vector<int> dst;
-  AddRange(&dst, -30, 32, 5);
-  EXPECT_THAT(dst, testing::ElementsAre(-30, -25, -5, -1, 0, 1, 5, 25, 32));
-}
-
-TEST(AddRangeTest, NegativeRangesAsymmetric) {
-  std::vector<int> dst;
-  AddRange(&dst, -3, 5, 2);
-  EXPECT_THAT(dst, testing::ElementsAre(-3, -2, -1, 0, 1, 2, 4, 5));
-}
-
-TEST(AddRangeTest, NegativeRangesLargeStep) {
-  // Always include -1, 0, 1 when crossing zero.
-  std::vector<int> dst;
-  AddRange(&dst, -8, 8, 10);
-  EXPECT_THAT(dst, testing::ElementsAre(-8, -1, 0, 1, 8));
-}
-
-TEST(AddRangeTest, ZeroOnlyRange) {
-  std::vector<int> dst;
-  AddRange(&dst, 0, 0, 2);
-  EXPECT_THAT(dst, testing::ElementsAre(0));
-}
-
-TEST(AddRangeTest, ZeroStartingRange) {
-  std::vector<int> dst;
-  AddRange(&dst, 0, 2, 2);
-  EXPECT_THAT(dst, testing::ElementsAre(0, 1, 2));
-}
-
-TEST(AddRangeTest, NegativeRange64) {
-  std::vector<int64_t> dst;
-  AddRange<int64_t>(&dst, -4, 4, 2);
-  EXPECT_THAT(dst, testing::ElementsAre(-4, -2, -1, 0, 1, 2, 4));
-}
-
-TEST(AddRangeTest, NegativeRangePreservesExistingOrder) {
-  // If elements already exist in the range, ensure we don't change
-  // their ordering by adding negative values.
-  std::vector<int64_t> dst = {1, 2, 3};
-  AddRange<int64_t>(&dst, -2, 2, 2);
-  EXPECT_THAT(dst, testing::ElementsAre(1, 2, 3, -2, -1, 0, 1, 2));
-}
-
-TEST(AddRangeTest, FullNegativeRange64) {
-  std::vector<int64_t> dst;
-  const auto min = std::numeric_limits<int64_t>::min();
-  const auto max = std::numeric_limits<int64_t>::max();
-  AddRange(&dst, min, max, 1024);
-  EXPECT_THAT(
-      dst, testing::ElementsAreArray(std::vector<int64_t>{
-               min, -1152921504606846976LL, -1125899906842624LL,
-               -1099511627776LL, -1073741824LL, -1048576LL, -1024LL, -1LL, 0LL,
-               1LL, 1024LL, 1048576LL, 1073741824LL, 1099511627776LL,
-               1125899906842624LL, 1152921504606846976LL, max}));
-}
-
-TEST(AddRangeTest, Simple8) {
-  std::vector<int8_t> dst;
-  AddRange<int8_t>(&dst, int8_t{1}, int8_t{8}, int8_t{2});
-  EXPECT_THAT(dst,
-              testing::ElementsAre(int8_t{1}, int8_t{2}, int8_t{4}, int8_t{8}));
-}
-
-TEST(AddCustomContext, Simple) {
-  std::map<std::string, std::string> *&global_context = GetGlobalContext();
-  EXPECT_THAT(global_context, nullptr);
-
-  AddCustomContext("foo", "bar");
-  AddCustomContext("baz", "qux");
-
-  EXPECT_THAT(*global_context,
-              testing::UnorderedElementsAre(testing::Pair("foo", "bar"),
-                                            testing::Pair("baz", "qux")));
-
-  delete global_context;
-  global_context = nullptr;
-}
-
-TEST(AddCustomContext, DuplicateKey) {
-  std::map<std::string, std::string> *&global_context = GetGlobalContext();
-  EXPECT_THAT(global_context, nullptr);
-
-  AddCustomContext("foo", "bar");
-  AddCustomContext("foo", "qux");
-
-  EXPECT_THAT(*global_context,
-              testing::UnorderedElementsAre(testing::Pair("foo", "bar")));
-
-  delete global_context;
-  global_context = nullptr;
-}
-
-}  // namespace
-}  // namespace internal
-}  // namespace benchmark

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

@@ -1,66 +0,0 @@
-#include <cassert>
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include "benchmark/benchmark.h"
-
-// Tests that we can specify the number of iterations with
-// --benchmark_min_time=<NUM>x.
-namespace {
-
-class TestReporter : public benchmark::ConsoleReporter {
- public:
-  virtual bool ReportContext(const Context& context) BENCHMARK_OVERRIDE {
-    return ConsoleReporter::ReportContext(context);
-  };
-
-  virtual void ReportRuns(const std::vector<Run>& report) BENCHMARK_OVERRIDE {
-    assert(report.size() == 1);
-    iter_nums_.push_back(report[0].iterations);
-    ConsoleReporter::ReportRuns(report);
-  };
-
-  TestReporter() {}
-
-  virtual ~TestReporter() {}
-
-  const std::vector<benchmark::IterationCount>& GetIters() const {
-    return iter_nums_;
-  }
-
- private:
-  std::vector<benchmark::IterationCount> iter_nums_;
-};
-
-}  // end namespace
-
-static void BM_MyBench(benchmark::State& state) {
-  for (auto s : state) {
-  }
-}
-BENCHMARK(BM_MyBench);
-
-int main(int argc, char** argv) {
-  // Make a fake argv and append the new --benchmark_min_time=<foo> to it.
-  int fake_argc = argc + 1;
-  const char** fake_argv = new const char*[static_cast<size_t>(fake_argc)];
-  for (int i = 0; i < argc; ++i) fake_argv[i] = argv[i];
-  fake_argv[argc] = "--benchmark_min_time=4x";
-
-  benchmark::Initialize(&fake_argc, const_cast<char**>(fake_argv));
-
-  TestReporter test_reporter;
-  const size_t returned_count =
-      benchmark::RunSpecifiedBenchmarks(&test_reporter, "BM_MyBench");
-  assert(returned_count == 1);
-
-  // Check the executed iters.
-  const std::vector<benchmark::IterationCount> iters = test_reporter.GetIters();
-  assert(!iters.empty() && iters[0] == 4);
-
-  delete[] fake_argv;
-  return 0;
-}

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

@@ -1,90 +0,0 @@
-#include <cassert>
-#include <climits>
-#include <cmath>
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include "benchmark/benchmark.h"
-
-// Tests that we can specify the min time with
-// --benchmark_min_time=<NUM> (no suffix needed) OR
-// --benchmark_min_time=<NUM>s
-namespace {
-
-// This is from benchmark.h
-typedef int64_t IterationCount;
-
-class TestReporter : public benchmark::ConsoleReporter {
- public:
-  virtual bool ReportContext(const Context& context) BENCHMARK_OVERRIDE {
-    return ConsoleReporter::ReportContext(context);
-  };
-
-  virtual void ReportRuns(const std::vector<Run>& report) BENCHMARK_OVERRIDE {
-    assert(report.size() == 1);
-    ConsoleReporter::ReportRuns(report);
-  };
-
-  virtual void ReportRunsConfig(double min_time, bool /* has_explicit_iters */,
-                                IterationCount /* iters */) BENCHMARK_OVERRIDE {
-    min_times_.push_back(min_time);
-  }
-
-  TestReporter() {}
-
-  virtual ~TestReporter() {}
-
-  const std::vector<double>& GetMinTimes() const { return min_times_; }
-
- private:
-  std::vector<double> min_times_;
-};
-
-bool AlmostEqual(double a, double b) {
-  return std::fabs(a - b) < std::numeric_limits<double>::epsilon();
-}
-
-void DoTestHelper(int* argc, const char** argv, double expected) {
-  benchmark::Initialize(argc, const_cast<char**>(argv));
-
-  TestReporter test_reporter;
-  const size_t returned_count =
-      benchmark::RunSpecifiedBenchmarks(&test_reporter, "BM_MyBench");
-  assert(returned_count == 1);
-
-  // Check the min_time
-  const std::vector<double>& min_times = test_reporter.GetMinTimes();
-  assert(!min_times.empty() && AlmostEqual(min_times[0], expected));
-}
-
-}  // end namespace
-
-static void BM_MyBench(benchmark::State& state) {
-  for (auto s : state) {
-  }
-}
-BENCHMARK(BM_MyBench);
-
-int main(int argc, char** argv) {
-  // Make a fake argv and append the new --benchmark_min_time=<foo> to it.
-  int fake_argc = argc + 1;
-  const char** fake_argv = new const char*[static_cast<size_t>(fake_argc)];
-
-  for (int i = 0; i < argc; ++i) fake_argv[i] = argv[i];
-
-  const char* no_suffix = "--benchmark_min_time=4";
-  const char* with_suffix = "--benchmark_min_time=4.0s";
-  double expected = 4.0;
-
-  fake_argv[argc] = no_suffix;
-  DoTestHelper(&fake_argc, fake_argv, expected);
-
-  fake_argv[argc] = with_suffix;
-  DoTestHelper(&fake_argc, fake_argv, expected);
-
-  delete[] fake_argv;
-  return 0;
-}

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

@@ -1,82 +0,0 @@
-#include "benchmark/benchmark.h"
-#include "gtest/gtest.h"
-
-namespace {
-
-using namespace benchmark;
-using namespace benchmark::internal;
-
-TEST(BenchmarkNameTest, Empty) {
-  const auto name = BenchmarkName();
-  EXPECT_EQ(name.str(), std::string());
-}
-
-TEST(BenchmarkNameTest, FunctionName) {
-  auto name = BenchmarkName();
-  name.function_name = "function_name";
-  EXPECT_EQ(name.str(), "function_name");
-}
-
-TEST(BenchmarkNameTest, FunctionNameAndArgs) {
-  auto name = BenchmarkName();
-  name.function_name = "function_name";
-  name.args = "some_args:3/4/5";
-  EXPECT_EQ(name.str(), "function_name/some_args:3/4/5");
-}
-
-TEST(BenchmarkNameTest, MinTime) {
-  auto name = BenchmarkName();
-  name.function_name = "function_name";
-  name.args = "some_args:3/4";
-  name.min_time = "min_time:3.4s";
-  EXPECT_EQ(name.str(), "function_name/some_args:3/4/min_time:3.4s");
-}
-
-TEST(BenchmarkNameTest, MinWarmUpTime) {
-  auto name = BenchmarkName();
-  name.function_name = "function_name";
-  name.args = "some_args:3/4";
-  name.min_warmup_time = "min_warmup_time:3.5s";
-  EXPECT_EQ(name.str(), "function_name/some_args:3/4/min_warmup_time:3.5s");
-}
-
-TEST(BenchmarkNameTest, Iterations) {
-  auto name = BenchmarkName();
-  name.function_name = "function_name";
-  name.min_time = "min_time:3.4s";
-  name.iterations = "iterations:42";
-  EXPECT_EQ(name.str(), "function_name/min_time:3.4s/iterations:42");
-}
-
-TEST(BenchmarkNameTest, Repetitions) {
-  auto name = BenchmarkName();
-  name.function_name = "function_name";
-  name.min_time = "min_time:3.4s";
-  name.repetitions = "repetitions:24";
-  EXPECT_EQ(name.str(), "function_name/min_time:3.4s/repetitions:24");
-}
-
-TEST(BenchmarkNameTest, TimeType) {
-  auto name = BenchmarkName();
-  name.function_name = "function_name";
-  name.min_time = "min_time:3.4s";
-  name.time_type = "hammer_time";
-  EXPECT_EQ(name.str(), "function_name/min_time:3.4s/hammer_time");
-}
-
-TEST(BenchmarkNameTest, Threads) {
-  auto name = BenchmarkName();
-  name.function_name = "function_name";
-  name.min_time = "min_time:3.4s";
-  name.threads = "threads:256";
-  EXPECT_EQ(name.str(), "function_name/min_time:3.4s/threads:256");
-}
-
-TEST(BenchmarkNameTest, TestEmptyFunctionName) {
-  auto name = BenchmarkName();
-  name.args = "first:3/second:4";
-  name.threads = "threads:22";
-  EXPECT_EQ(name.str(), "first:3/second:4/threads:22");
-}
-
-}  // end namespace

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

@@ -1,126 +0,0 @@
-#include <queue>
-#include <string>
-#include <vector>
-
-#include "../src/commandlineflags.h"
-#include "../src/string_util.h"
-#include "benchmark/benchmark.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-namespace benchmark {
-
-BM_DECLARE_bool(benchmark_enable_random_interleaving);
-BM_DECLARE_string(benchmark_filter);
-BM_DECLARE_int32(benchmark_repetitions);
-
-namespace internal {
-namespace {
-
-class EventQueue : public std::queue<std::string> {
- public:
-  void Put(const std::string& event) { push(event); }
-
-  void Clear() {
-    while (!empty()) {
-      pop();
-    }
-  }
-
-  std::string Get() {
-    std::string event = front();
-    pop();
-    return event;
-  }
-};
-
-EventQueue* queue = new EventQueue();
-
-class NullReporter : public BenchmarkReporter {
- public:
-  bool ReportContext(const Context& /*context*/) override { return true; }
-  void ReportRuns(const std::vector<Run>& /* report */) override {}
-};
-
-class BenchmarkTest : public testing::Test {
- public:
-  static void SetupHook(int /* num_threads */) { queue->push("Setup"); }
-
-  static void TeardownHook(int /* num_threads */) { queue->push("Teardown"); }
-
-  void Execute(const std::string& pattern) {
-    queue->Clear();
-
-    std::unique_ptr<BenchmarkReporter> reporter(new NullReporter());
-    FLAGS_benchmark_filter = pattern;
-    RunSpecifiedBenchmarks(reporter.get());
-
-    queue->Put("DONE");  // End marker
-  }
-};
-
-void BM_Match1(benchmark::State& state) {
-  const int64_t arg = state.range(0);
-
-  for (auto _ : state) {
-  }
-  queue->Put(StrFormat("BM_Match1/%d", static_cast<int>(arg)));
-}
-BENCHMARK(BM_Match1)
-    ->Iterations(100)
-    ->Arg(1)
-    ->Arg(2)
-    ->Arg(3)
-    ->Range(10, 80)
-    ->Args({90})
-    ->Args({100});
-
-TEST_F(BenchmarkTest, Match1) {
-  Execute("BM_Match1");
-  ASSERT_EQ("BM_Match1/1", queue->Get());
-  ASSERT_EQ("BM_Match1/2", queue->Get());
-  ASSERT_EQ("BM_Match1/3", queue->Get());
-  ASSERT_EQ("BM_Match1/10", queue->Get());
-  ASSERT_EQ("BM_Match1/64", queue->Get());
-  ASSERT_EQ("BM_Match1/80", queue->Get());
-  ASSERT_EQ("BM_Match1/90", queue->Get());
-  ASSERT_EQ("BM_Match1/100", queue->Get());
-  ASSERT_EQ("DONE", queue->Get());
-}
-
-TEST_F(BenchmarkTest, Match1WithRepetition) {
-  FLAGS_benchmark_repetitions = 2;
-
-  Execute("BM_Match1/(64|80)");
-  ASSERT_EQ("BM_Match1/64", queue->Get());
-  ASSERT_EQ("BM_Match1/64", queue->Get());
-  ASSERT_EQ("BM_Match1/80", queue->Get());
-  ASSERT_EQ("BM_Match1/80", queue->Get());
-  ASSERT_EQ("DONE", queue->Get());
-}
-
-TEST_F(BenchmarkTest, Match1WithRandomInterleaving) {
-  FLAGS_benchmark_enable_random_interleaving = true;
-  FLAGS_benchmark_repetitions = 100;
-
-  std::map<std::string, int> element_count;
-  std::map<std::string, int> interleaving_count;
-  Execute("BM_Match1/(64|80)");
-  for (int i = 0; i < 100; ++i) {
-    std::vector<std::string> interleaving;
-    interleaving.push_back(queue->Get());
-    interleaving.push_back(queue->Get());
-    element_count[interleaving[0]]++;
-    element_count[interleaving[1]]++;
-    interleaving_count[StrFormat("%s,%s", interleaving[0].c_str(),
-                                 interleaving[1].c_str())]++;
-  }
-  EXPECT_EQ(element_count["BM_Match1/64"], 100) << "Unexpected repetitions.";
-  EXPECT_EQ(element_count["BM_Match1/80"], 100) << "Unexpected repetitions.";
-  EXPECT_GE(interleaving_count.size(), 2) << "Interleaving was not randomized.";
-  ASSERT_EQ("DONE", queue->Get());
-}
-
-}  // namespace
-}  // namespace internal
-}  // namespace benchmark

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

@@ -1,157 +0,0 @@
-#include <atomic>
-#include <cassert>
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <limits>
-#include <string>
-
-#include "benchmark/benchmark.h"
-
-// Test that Setup() and Teardown() are called exactly once
-// for each benchmark run (single-threaded).
-namespace singlethreaded {
-static int setup_call = 0;
-static int teardown_call = 0;
-}  // namespace singlethreaded
-static void DoSetup1(const benchmark::State& state) {
-  ++singlethreaded::setup_call;
-
-  // Setup/Teardown should never be called with any thread_idx != 0.
-  assert(state.thread_index() == 0);
-}
-
-static void DoTeardown1(const benchmark::State& state) {
-  ++singlethreaded::teardown_call;
-  assert(state.thread_index() == 0);
-}
-
-static void BM_with_setup(benchmark::State& state) {
-  for (auto s : state) {
-  }
-}
-BENCHMARK(BM_with_setup)
-    ->Arg(1)
-    ->Arg(3)
-    ->Arg(5)
-    ->Arg(7)
-    ->Iterations(100)
-    ->Setup(DoSetup1)
-    ->Teardown(DoTeardown1);
-
-// Test that Setup() and Teardown() are called once for each group of threads.
-namespace concurrent {
-static std::atomic<int> setup_call(0);
-static std::atomic<int> teardown_call(0);
-static std::atomic<int> func_call(0);
-}  // namespace concurrent
-
-static void DoSetup2(const benchmark::State& state) {
-  concurrent::setup_call.fetch_add(1, std::memory_order_acquire);
-  assert(state.thread_index() == 0);
-}
-
-static void DoTeardown2(const benchmark::State& state) {
-  concurrent::teardown_call.fetch_add(1, std::memory_order_acquire);
-  assert(state.thread_index() == 0);
-}
-
-static void BM_concurrent(benchmark::State& state) {
-  for (auto s : state) {
-  }
-  concurrent::func_call.fetch_add(1, std::memory_order_acquire);
-}
-
-BENCHMARK(BM_concurrent)
-    ->Setup(DoSetup2)
-    ->Teardown(DoTeardown2)
-    ->Iterations(100)
-    ->Threads(5)
-    ->Threads(10)
-    ->Threads(15);
-
-// Testing interaction with Fixture::Setup/Teardown
-namespace fixture_interaction {
-int setup = 0;
-int fixture_setup = 0;
-}  // namespace fixture_interaction
-
-#define FIXTURE_BECHMARK_NAME MyFixture
-
-class FIXTURE_BECHMARK_NAME : public ::benchmark::Fixture {
- public:
-  void SetUp(const ::benchmark::State&) override {
-    fixture_interaction::fixture_setup++;
-  }
-
-  ~FIXTURE_BECHMARK_NAME() override {}
-};
-
-BENCHMARK_F(FIXTURE_BECHMARK_NAME, BM_WithFixture)(benchmark::State& st) {
-  for (auto _ : st) {
-  }
-}
-
-static void DoSetupWithFixture(const benchmark::State&) {
-  fixture_interaction::setup++;
-}
-
-BENCHMARK_REGISTER_F(FIXTURE_BECHMARK_NAME, BM_WithFixture)
-    ->Arg(1)
-    ->Arg(3)
-    ->Arg(5)
-    ->Arg(7)
-    ->Setup(DoSetupWithFixture)
-    ->Repetitions(1)
-    ->Iterations(100);
-
-// Testing repetitions.
-namespace repetitions {
-int setup = 0;
-}
-
-static void DoSetupWithRepetitions(const benchmark::State&) {
-  repetitions::setup++;
-}
-static void BM_WithRep(benchmark::State& state) {
-  for (auto _ : state) {
-  }
-}
-
-BENCHMARK(BM_WithRep)
-    ->Arg(1)
-    ->Arg(3)
-    ->Arg(5)
-    ->Arg(7)
-    ->Setup(DoSetupWithRepetitions)
-    ->Iterations(100)
-    ->Repetitions(4);
-
-int main(int argc, char** argv) {
-  benchmark::Initialize(&argc, argv);
-
-  size_t ret = benchmark::RunSpecifiedBenchmarks(".");
-  assert(ret > 0);
-
-  // Setup/Teardown is called once for each arg group (1,3,5,7).
-  assert(singlethreaded::setup_call == 4);
-  assert(singlethreaded::teardown_call == 4);
-
-  // 3 group of threads calling this function (3,5,10).
-  assert(concurrent::setup_call.load(std::memory_order_relaxed) == 3);
-  assert(concurrent::teardown_call.load(std::memory_order_relaxed) == 3);
-  assert((5 + 10 + 15) ==
-         concurrent::func_call.load(std::memory_order_relaxed));
-
-  // Setup is called 4 times, once for each arg group (1,3,5,7)
-  assert(fixture_interaction::setup == 4);
-  // Fixture::Setup is called every time the bm routine is run.
-  // The exact number is indeterministic, so we just assert that
-  // it's more than setup.
-  assert(fixture_interaction::fixture_setup > fixture_interaction::setup);
-
-  // Setup is call once for each repetition * num_arg =  4 * 4 = 16.
-  assert(repetitions::setup == 16);
-
-  return 0;
-}