data-structure-typed 2.4.1 → 2.4.3

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

@@ -1,117 +0,0 @@
-#include <algorithm>
-#include <cassert>
-#include <cmath>
-#include <cstdint>
-#include <cstdlib>
-#include <iostream>
-#include <limits>
-#include <sstream>
-#include <string>
-
-#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 {
-    ++count_;
-    max_family_index_ = std::max(max_family_index_, report[0].family_index);
-    ConsoleReporter::ReportRuns(report);
-  };
-
-  TestReporter() : count_(0), max_family_index_(0) {}
-
-  ~TestReporter() override {}
-
-  int GetCount() const { return count_; }
-
-  int64_t GetMaxFamilyIndex() const { return max_family_index_; }
-
- private:
-  mutable int count_;
-  mutable int64_t max_family_index_;
-};
-
-}  // end namespace
-
-static void NoPrefix(benchmark::State& state) {
-  for (auto _ : state) {
-  }
-}
-BENCHMARK(NoPrefix);
-
-static void BM_Foo(benchmark::State& state) {
-  for (auto _ : state) {
-  }
-}
-BENCHMARK(BM_Foo);
-
-static void BM_Bar(benchmark::State& state) {
-  for (auto _ : state) {
-  }
-}
-BENCHMARK(BM_Bar);
-
-static void BM_FooBar(benchmark::State& state) {
-  for (auto _ : state) {
-  }
-}
-BENCHMARK(BM_FooBar);
-
-static void BM_FooBa(benchmark::State& state) {
-  for (auto _ : state) {
-  }
-}
-BENCHMARK(BM_FooBa);
-
-int main(int argc, char** argv) {
-  bool list_only = false;
-  for (int i = 0; i < argc; ++i)
-    list_only |= std::string(argv[i]).find("--benchmark_list_tests") !=
-                 std::string::npos;
-
-  benchmark::Initialize(&argc, argv);
-
-  TestReporter test_reporter;
-  const int64_t returned_count =
-      static_cast<int64_t>(benchmark::RunSpecifiedBenchmarks(&test_reporter));
-
-  if (argc == 2) {
-    // Make sure we ran all of the tests
-    std::stringstream ss(argv[1]);
-    int64_t expected_return;
-    ss >> expected_return;
-
-    if (returned_count != expected_return) {
-      std::cerr << "ERROR: Expected " << expected_return
-                << " tests to match the filter but returned_count = "
-                << returned_count << std::endl;
-      return -1;
-    }
-
-    const int64_t expected_reports = list_only ? 0 : expected_return;
-    const int64_t reports_count = test_reporter.GetCount();
-    if (reports_count != expected_reports) {
-      std::cerr << "ERROR: Expected " << expected_reports
-                << " tests to be run but reported_count = " << reports_count
-                << std::endl;
-      return -1;
-    }
-
-    const int64_t max_family_index = test_reporter.GetMaxFamilyIndex();
-    const int64_t num_families = reports_count == 0 ? 0 : 1 + max_family_index;
-    if (num_families != expected_reports) {
-      std::cerr << "ERROR: Expected " << expected_reports
-                << " test families to be run but num_families = "
-                << num_families << std::endl;
-      return -1;
-    }
-  }
-
-  return 0;
-}

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

@@ -1,51 +0,0 @@
-
-#include <cassert>
-#include <memory>
-
-#include "benchmark/benchmark.h"
-
-#define FIXTURE_BECHMARK_NAME MyFixture
-
-class FIXTURE_BECHMARK_NAME : public ::benchmark::Fixture {
- public:
-  void SetUp(const ::benchmark::State& state) override {
-    if (state.thread_index() == 0) {
-      assert(data.get() == nullptr);
-      data.reset(new int(42));
-    }
-  }
-
-  void TearDown(const ::benchmark::State& state) override {
-    if (state.thread_index() == 0) {
-      assert(data.get() != nullptr);
-      data.reset();
-    }
-  }
-
-  ~FIXTURE_BECHMARK_NAME() override { assert(data == nullptr); }
-
-  std::unique_ptr<int> data;
-};
-
-BENCHMARK_F(FIXTURE_BECHMARK_NAME, Foo)(benchmark::State& st) {
-  assert(data.get() != nullptr);
-  assert(*data == 42);
-  for (auto _ : st) {
-  }
-}
-
-BENCHMARK_DEFINE_F(FIXTURE_BECHMARK_NAME, Bar)(benchmark::State& st) {
-  if (st.thread_index() == 0) {
-    assert(data.get() != nullptr);
-    assert(*data == 42);
-  }
-  for (auto _ : st) {
-    assert(data.get() != nullptr);
-    assert(*data == 42);
-  }
-  st.SetItemsProcessed(st.range(0));
-}
-BENCHMARK_REGISTER_F(FIXTURE_BECHMARK_NAME, Bar)->Arg(42);
-BENCHMARK_REGISTER_F(FIXTURE_BECHMARK_NAME, Bar)->Arg(42)->ThreadPerCpu();
-
-BENCHMARK_MAIN();

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

@@ -1,185 +0,0 @@
-
-#undef NDEBUG
-
-#include <chrono>
-#include <thread>
-
-#include "../src/timers.h"
-#include "benchmark/benchmark.h"
-#include "output_test.h"
-
-static const std::chrono::duration<double, std::milli> time_frame(50);
-static const double time_frame_in_sec(
-    std::chrono::duration_cast<std::chrono::duration<double, std::ratio<1, 1>>>(
-        time_frame)
-        .count());
-
-void MyBusySpinwait() {
-  const auto start = benchmark::ChronoClockNow();
-
-  while (true) {
-    const auto now = benchmark::ChronoClockNow();
-    const auto elapsed = now - start;
-
-    if (std::chrono::duration<double, std::chrono::seconds::period>(elapsed) >=
-        time_frame)
-      return;
-  }
-}
-
-// ========================================================================= //
-// --------------------------- TEST CASES BEGIN ---------------------------- //
-// ========================================================================= //
-
-// ========================================================================= //
-// BM_MainThread
-
-void BM_MainThread(benchmark::State& state) {
-  for (auto _ : state) {
-    MyBusySpinwait();
-    state.SetIterationTime(time_frame_in_sec);
-  }
-  state.counters["invtime"] =
-      benchmark::Counter{1, benchmark::Counter::kIsRate};
-}
-
-BENCHMARK(BM_MainThread)->Iterations(1)->Threads(1);
-BENCHMARK(BM_MainThread)->Iterations(1)->Threads(1)->UseRealTime();
-BENCHMARK(BM_MainThread)->Iterations(1)->Threads(1)->UseManualTime();
-BENCHMARK(BM_MainThread)->Iterations(1)->Threads(1)->MeasureProcessCPUTime();
-BENCHMARK(BM_MainThread)
-    ->Iterations(1)
-    ->Threads(1)
-    ->MeasureProcessCPUTime()
-    ->UseRealTime();
-BENCHMARK(BM_MainThread)
-    ->Iterations(1)
-    ->Threads(1)
-    ->MeasureProcessCPUTime()
-    ->UseManualTime();
-
-BENCHMARK(BM_MainThread)->Iterations(1)->Threads(2);
-BENCHMARK(BM_MainThread)->Iterations(1)->Threads(2)->UseRealTime();
-BENCHMARK(BM_MainThread)->Iterations(1)->Threads(2)->UseManualTime();
-BENCHMARK(BM_MainThread)->Iterations(1)->Threads(2)->MeasureProcessCPUTime();
-BENCHMARK(BM_MainThread)
-    ->Iterations(1)
-    ->Threads(2)
-    ->MeasureProcessCPUTime()
-    ->UseRealTime();
-BENCHMARK(BM_MainThread)
-    ->Iterations(1)
-    ->Threads(2)
-    ->MeasureProcessCPUTime()
-    ->UseManualTime();
-
-// ========================================================================= //
-// BM_WorkerThread
-
-void BM_WorkerThread(benchmark::State& state) {
-  for (auto _ : state) {
-    std::thread Worker(&MyBusySpinwait);
-    Worker.join();
-    state.SetIterationTime(time_frame_in_sec);
-  }
-  state.counters["invtime"] =
-      benchmark::Counter{1, benchmark::Counter::kIsRate};
-}
-
-BENCHMARK(BM_WorkerThread)->Iterations(1)->Threads(1);
-BENCHMARK(BM_WorkerThread)->Iterations(1)->Threads(1)->UseRealTime();
-BENCHMARK(BM_WorkerThread)->Iterations(1)->Threads(1)->UseManualTime();
-BENCHMARK(BM_WorkerThread)->Iterations(1)->Threads(1)->MeasureProcessCPUTime();
-BENCHMARK(BM_WorkerThread)
-    ->Iterations(1)
-    ->Threads(1)
-    ->MeasureProcessCPUTime()
-    ->UseRealTime();
-BENCHMARK(BM_WorkerThread)
-    ->Iterations(1)
-    ->Threads(1)
-    ->MeasureProcessCPUTime()
-    ->UseManualTime();
-
-BENCHMARK(BM_WorkerThread)->Iterations(1)->Threads(2);
-BENCHMARK(BM_WorkerThread)->Iterations(1)->Threads(2)->UseRealTime();
-BENCHMARK(BM_WorkerThread)->Iterations(1)->Threads(2)->UseManualTime();
-BENCHMARK(BM_WorkerThread)->Iterations(1)->Threads(2)->MeasureProcessCPUTime();
-BENCHMARK(BM_WorkerThread)
-    ->Iterations(1)
-    ->Threads(2)
-    ->MeasureProcessCPUTime()
-    ->UseRealTime();
-BENCHMARK(BM_WorkerThread)
-    ->Iterations(1)
-    ->Threads(2)
-    ->MeasureProcessCPUTime()
-    ->UseManualTime();
-
-// ========================================================================= //
-// BM_MainThreadAndWorkerThread
-
-void BM_MainThreadAndWorkerThread(benchmark::State& state) {
-  for (auto _ : state) {
-    std::thread Worker(&MyBusySpinwait);
-    MyBusySpinwait();
-    Worker.join();
-    state.SetIterationTime(time_frame_in_sec);
-  }
-  state.counters["invtime"] =
-      benchmark::Counter{1, benchmark::Counter::kIsRate};
-}
-
-BENCHMARK(BM_MainThreadAndWorkerThread)->Iterations(1)->Threads(1);
-BENCHMARK(BM_MainThreadAndWorkerThread)
-    ->Iterations(1)
-    ->Threads(1)
-    ->UseRealTime();
-BENCHMARK(BM_MainThreadAndWorkerThread)
-    ->Iterations(1)
-    ->Threads(1)
-    ->UseManualTime();
-BENCHMARK(BM_MainThreadAndWorkerThread)
-    ->Iterations(1)
-    ->Threads(1)
-    ->MeasureProcessCPUTime();
-BENCHMARK(BM_MainThreadAndWorkerThread)
-    ->Iterations(1)
-    ->Threads(1)
-    ->MeasureProcessCPUTime()
-    ->UseRealTime();
-BENCHMARK(BM_MainThreadAndWorkerThread)
-    ->Iterations(1)
-    ->Threads(1)
-    ->MeasureProcessCPUTime()
-    ->UseManualTime();
-
-BENCHMARK(BM_MainThreadAndWorkerThread)->Iterations(1)->Threads(2);
-BENCHMARK(BM_MainThreadAndWorkerThread)
-    ->Iterations(1)
-    ->Threads(2)
-    ->UseRealTime();
-BENCHMARK(BM_MainThreadAndWorkerThread)
-    ->Iterations(1)
-    ->Threads(2)
-    ->UseManualTime();
-BENCHMARK(BM_MainThreadAndWorkerThread)
-    ->Iterations(1)
-    ->Threads(2)
-    ->MeasureProcessCPUTime();
-BENCHMARK(BM_MainThreadAndWorkerThread)
-    ->Iterations(1)
-    ->Threads(2)
-    ->MeasureProcessCPUTime()
-    ->UseRealTime();
-BENCHMARK(BM_MainThreadAndWorkerThread)
-    ->Iterations(1)
-    ->Threads(2)
-    ->MeasureProcessCPUTime()
-    ->UseManualTime();
-
-// ========================================================================= //
-// ---------------------------- TEST CASES END ----------------------------- //
-// ========================================================================= //
-
-int main(int argc, char* argv[]) { RunOutputTests(argc, argv); }

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

@@ -1,9 +0,0 @@
-#include "benchmark/benchmark.h"
-
-void BM_empty(benchmark::State& state) {
-  for (auto _ : state) {
-    auto iterations = state.iterations();
-    benchmark::DoNotOptimize(iterations);
-  }
-}
-BENCHMARK(BM_empty);

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

@@ -1,59 +0,0 @@
-#include <cstdlib>
-#include <map>
-
-#include "benchmark/benchmark.h"
-
-namespace {
-
-std::map<int, int> ConstructRandomMap(int size) {
-  std::map<int, int> m;
-  for (int i = 0; i < size; ++i) {
-    m.insert(std::make_pair(std::rand() % size, std::rand() % size));
-  }
-  return m;
-}
-
-}  // namespace
-
-// Basic version.
-static void BM_MapLookup(benchmark::State& state) {
-  const int size = static_cast<int>(state.range(0));
-  std::map<int, int> m;
-  for (auto _ : state) {
-    state.PauseTiming();
-    m = ConstructRandomMap(size);
-    state.ResumeTiming();
-    for (int i = 0; i < size; ++i) {
-      auto it = m.find(std::rand() % size);
-      benchmark::DoNotOptimize(it);
-    }
-  }
-  state.SetItemsProcessed(state.iterations() * size);
-}
-BENCHMARK(BM_MapLookup)->Range(1 << 3, 1 << 12);
-
-// Using fixtures.
-class MapFixture : public ::benchmark::Fixture {
- public:
-  void SetUp(const ::benchmark::State& st) override {
-    m = ConstructRandomMap(static_cast<int>(st.range(0)));
-  }
-
-  void TearDown(const ::benchmark::State&) override { m.clear(); }
-
-  std::map<int, int> m;
-};
-
-BENCHMARK_DEFINE_F(MapFixture, Lookup)(benchmark::State& state) {
-  const int size = static_cast<int>(state.range(0));
-  for (auto _ : state) {
-    for (int i = 0; i < size; ++i) {
-      auto it = m.find(std::rand() % size);
-      benchmark::DoNotOptimize(it);
-    }
-  }
-  state.SetItemsProcessed(state.iterations() * size);
-}
-BENCHMARK_REGISTER_F(MapFixture, Lookup)->Range(1 << 3, 1 << 12);
-
-BENCHMARK_MAIN();

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

@@ -1,47 +0,0 @@
-#include <memory>
-
-#include "../src/check.h"
-#include "benchmark/benchmark.h"
-#include "output_test.h"
-
-class TestMemoryManager : public benchmark::MemoryManager {
-  void Start() override {}
-  void Stop(Result& result) override {
-    result.num_allocs = 42;
-    result.max_bytes_used = 42000;
-  }
-};
-
-void BM_empty(benchmark::State& state) {
-  for (auto _ : state) {
-    auto iterations = state.iterations();
-    benchmark::DoNotOptimize(iterations);
-  }
-}
-BENCHMARK(BM_empty);
-
-ADD_CASES(TC_ConsoleOut, {{"^BM_empty %console_report$"}});
-ADD_CASES(TC_JSONOut, {{"\"name\": \"BM_empty\",$"},
-                       {"\"family_index\": 0,$", MR_Next},
-                       {"\"per_family_instance_index\": 0,$", MR_Next},
-                       {"\"run_name\": \"BM_empty\",$", MR_Next},
-                       {"\"run_type\": \"iteration\",$", MR_Next},
-                       {"\"repetitions\": 1,$", MR_Next},
-                       {"\"repetition_index\": 0,$", MR_Next},
-                       {"\"threads\": 1,$", MR_Next},
-                       {"\"iterations\": %int,$", MR_Next},
-                       {"\"real_time\": %float,$", MR_Next},
-                       {"\"cpu_time\": %float,$", MR_Next},
-                       {"\"time_unit\": \"ns\",$", MR_Next},
-                       {"\"allocs_per_iter\": %float,$", MR_Next},
-                       {"\"max_bytes_used\": 42000$", MR_Next},
-                       {"}", MR_Next}});
-ADD_CASES(TC_CSVOut, {{"^\"BM_empty\",%csv_report$"}});
-
-int main(int argc, char* argv[]) {
-  std::unique_ptr<benchmark::MemoryManager> mm(new TestMemoryManager());
-
-  benchmark::RegisterMemoryManager(mm.get());
-  RunOutputTests(argc, argv);
-  benchmark::RegisterMemoryManager(nullptr);
-}

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

@@ -1,30 +0,0 @@
-#include "../src/benchmark_runner.h"
-#include "gtest/gtest.h"
-
-namespace {
-
-TEST(ParseMinTimeTest, InvalidInput) {
-#if GTEST_HAS_DEATH_TEST
-  // Tests only runnable in debug mode (when BM_CHECK is enabled).
-#ifndef NDEBUG
-#ifndef TEST_BENCHMARK_LIBRARY_HAS_NO_ASSERTIONS
-  ASSERT_DEATH_IF_SUPPORTED(
-      { benchmark::internal::ParseBenchMinTime("abc"); },
-      "Malformed seconds value passed to --benchmark_min_time: `abc`");
-
-  ASSERT_DEATH_IF_SUPPORTED(
-      { benchmark::internal::ParseBenchMinTime("123ms"); },
-      "Malformed seconds value passed to --benchmark_min_time: `123ms`");
-
-  ASSERT_DEATH_IF_SUPPORTED(
-      { benchmark::internal::ParseBenchMinTime("1z"); },
-      "Malformed seconds value passed to --benchmark_min_time: `1z`");
-
-  ASSERT_DEATH_IF_SUPPORTED(
-      { benchmark::internal::ParseBenchMinTime("1hs"); },
-      "Malformed seconds value passed to --benchmark_min_time: `1hs`");
-#endif
-#endif
-#endif
-}
-}  // namespace

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

@@ -1,96 +0,0 @@
-#include <cassert>
-#include <iostream>
-#include <set>
-#include <vector>
-
-#include "benchmark/benchmark.h"
-
-class MultipleRangesFixture : public ::benchmark::Fixture {
- public:
-  MultipleRangesFixture()
-      : expectedValues({{1, 3, 5},
-                        {1, 3, 8},
-                        {1, 3, 15},
-                        {2, 3, 5},
-                        {2, 3, 8},
-                        {2, 3, 15},
-                        {1, 4, 5},
-                        {1, 4, 8},
-                        {1, 4, 15},
-                        {2, 4, 5},
-                        {2, 4, 8},
-                        {2, 4, 15},
-                        {1, 7, 5},
-                        {1, 7, 8},
-                        {1, 7, 15},
-                        {2, 7, 5},
-                        {2, 7, 8},
-                        {2, 7, 15},
-                        {7, 6, 3}}) {}
-
-  void SetUp(const ::benchmark::State& state) override {
-    std::vector<int64_t> ranges = {state.range(0), state.range(1),
-                                   state.range(2)};
-
-    assert(expectedValues.find(ranges) != expectedValues.end());
-
-    actualValues.insert(ranges);
-  }
-
-  // NOTE: This is not TearDown as we want to check after _all_ runs are
-  // complete.
-  ~MultipleRangesFixture() override {
-    if (actualValues != expectedValues) {
-      std::cout << "EXPECTED\n";
-      for (const auto& v : expectedValues) {
-        std::cout << "{";
-        for (int64_t iv : v) {
-          std::cout << iv << ", ";
-        }
-        std::cout << "}\n";
-      }
-      std::cout << "ACTUAL\n";
-      for (const auto& v : actualValues) {
-        std::cout << "{";
-        for (int64_t iv : v) {
-          std::cout << iv << ", ";
-        }
-        std::cout << "}\n";
-      }
-    }
-  }
-
-  std::set<std::vector<int64_t>> expectedValues;
-  std::set<std::vector<int64_t>> actualValues;
-};
-
-BENCHMARK_DEFINE_F(MultipleRangesFixture, Empty)(benchmark::State& state) {
-  for (auto _ : state) {
-    int64_t product = state.range(0) * state.range(1) * state.range(2);
-    for (int64_t x = 0; x < product; x++) {
-      benchmark::DoNotOptimize(x);
-    }
-  }
-}
-
-BENCHMARK_REGISTER_F(MultipleRangesFixture, Empty)
-    ->RangeMultiplier(2)
-    ->Ranges({{1, 2}, {3, 7}, {5, 15}})
-    ->Args({7, 6, 3});
-
-void BM_CheckDefaultArgument(benchmark::State& state) {
-  // Test that the 'range()' without an argument is the same as 'range(0)'.
-  assert(state.range() == state.range(0));
-  assert(state.range() != state.range(1));
-  for (auto _ : state) {
-  }
-}
-BENCHMARK(BM_CheckDefaultArgument)->Ranges({{1, 5}, {6, 10}});
-
-static void BM_MultipleRanges(benchmark::State& st) {
-  for (auto _ : st) {
-  }
-}
-BENCHMARK(BM_MultipleRanges)->Ranges({{5, 5}, {6, 6}});
-
-BENCHMARK_MAIN();

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

@@ -1,77 +0,0 @@
-#include <chrono>
-#include <thread>
-
-#include "benchmark/benchmark.h"
-
-#if defined(NDEBUG)
-#undef NDEBUG
-#endif
-#include <cassert>
-
-void BM_basic(benchmark::State& state) {
-  for (auto _ : state) {
-  }
-}
-
-void BM_basic_slow(benchmark::State& state) {
-  std::chrono::milliseconds sleep_duration(state.range(0));
-  for (auto _ : state) {
-    std::this_thread::sleep_for(
-        std::chrono::duration_cast<std::chrono::nanoseconds>(sleep_duration));
-  }
-}
-
-BENCHMARK(BM_basic);
-BENCHMARK(BM_basic)->Arg(42);
-BENCHMARK(BM_basic_slow)->Arg(10)->Unit(benchmark::kNanosecond);
-BENCHMARK(BM_basic_slow)->Arg(100)->Unit(benchmark::kMicrosecond);
-BENCHMARK(BM_basic_slow)->Arg(1000)->Unit(benchmark::kMillisecond);
-BENCHMARK(BM_basic_slow)->Arg(1000)->Unit(benchmark::kSecond);
-BENCHMARK(BM_basic)->Range(1, 8);
-BENCHMARK(BM_basic)->RangeMultiplier(2)->Range(1, 8);
-BENCHMARK(BM_basic)->DenseRange(10, 15);
-BENCHMARK(BM_basic)->Args({42, 42});
-BENCHMARK(BM_basic)->Ranges({{64, 512}, {64, 512}});
-BENCHMARK(BM_basic)->MinTime(0.7);
-BENCHMARK(BM_basic)->MinWarmUpTime(0.8);
-BENCHMARK(BM_basic)->MinTime(0.1)->MinWarmUpTime(0.2);
-BENCHMARK(BM_basic)->UseRealTime();
-BENCHMARK(BM_basic)->ThreadRange(2, 4);
-BENCHMARK(BM_basic)->ThreadPerCpu();
-BENCHMARK(BM_basic)->Repetitions(3);
-BENCHMARK(BM_basic)
-    ->RangeMultiplier(std::numeric_limits<int>::max())
-    ->Range(std::numeric_limits<int64_t>::min(),
-            std::numeric_limits<int64_t>::max());
-
-// Negative ranges
-BENCHMARK(BM_basic)->Range(-64, -1);
-BENCHMARK(BM_basic)->RangeMultiplier(4)->Range(-8, 8);
-BENCHMARK(BM_basic)->DenseRange(-2, 2, 1);
-BENCHMARK(BM_basic)->Ranges({{-64, 1}, {-8, -1}});
-
-void CustomArgs(benchmark::internal::Benchmark* b) {
-  for (int i = 0; i < 10; ++i) {
-    b->Arg(i);
-  }
-}
-
-BENCHMARK(BM_basic)->Apply(CustomArgs);
-
-void BM_explicit_iteration_count(benchmark::State& state) {
-  // Test that benchmarks specified with an explicit iteration count are
-  // only run once.
-  static bool invoked_before = false;
-  assert(!invoked_before);
-  invoked_before = true;
-
-  // Test that the requested iteration count is respected.
-  assert(state.max_iterations == 42);
-  for (auto _ : state) {
-  }
-  assert(state.iterations() == state.max_iterations);
-  assert(state.iterations() == 42);
-}
-BENCHMARK(BM_explicit_iteration_count)->Iterations(42);
-
-BENCHMARK_MAIN();