data-structure-typed 2.4.1 → 2.4.3

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

@@ -1,228 +0,0 @@
-#undef NDEBUG
-#include <algorithm>
-#include <cassert>
-#include <cmath>
-#include <cstdlib>
-#include <vector>
-
-#include "benchmark/benchmark.h"
-#include "output_test.h"
-
-namespace {
-
-#define ADD_COMPLEXITY_CASES(...) \
-  int CONCAT(dummy, __LINE__) = AddComplexityTest(__VA_ARGS__)
-
-int AddComplexityTest(const std::string &test_name,
-                      const std::string &big_o_test_name,
-                      const std::string &rms_test_name,
-                      const std::string &big_o, int family_index) {
-  SetSubstitutions({{"%name", test_name},
-                    {"%bigo_name", big_o_test_name},
-                    {"%rms_name", rms_test_name},
-                    {"%bigo_str", "[ ]* %float " + big_o},
-                    {"%bigo", big_o},
-                    {"%rms", "[ ]*[0-9]+ %"}});
-  AddCases(
-      TC_ConsoleOut,
-      {{"^%bigo_name %bigo_str %bigo_str[ ]*$"},
-       {"^%bigo_name", MR_Not},  // Assert we we didn't only matched a name.
-       {"^%rms_name %rms %rms[ ]*$", MR_Next}});
-  AddCases(
-      TC_JSONOut,
-      {{"\"name\": \"%bigo_name\",$"},
-       {"\"family_index\": " + std::to_string(family_index) + ",$", MR_Next},
-       {"\"per_family_instance_index\": 0,$", MR_Next},
-       {"\"run_name\": \"%name\",$", MR_Next},
-       {"\"run_type\": \"aggregate\",$", MR_Next},
-       {"\"repetitions\": %int,$", MR_Next},
-       {"\"threads\": 1,$", MR_Next},
-       {"\"aggregate_name\": \"BigO\",$", MR_Next},
-       {"\"aggregate_unit\": \"time\",$", MR_Next},
-       {"\"cpu_coefficient\": %float,$", MR_Next},
-       {"\"real_coefficient\": %float,$", MR_Next},
-       {"\"big_o\": \"%bigo\",$", MR_Next},
-       {"\"time_unit\": \"ns\"$", MR_Next},
-       {"}", MR_Next},
-       {"\"name\": \"%rms_name\",$"},
-       {"\"family_index\": " + std::to_string(family_index) + ",$", MR_Next},
-       {"\"per_family_instance_index\": 0,$", MR_Next},
-       {"\"run_name\": \"%name\",$", MR_Next},
-       {"\"run_type\": \"aggregate\",$", MR_Next},
-       {"\"repetitions\": %int,$", MR_Next},
-       {"\"threads\": 1,$", MR_Next},
-       {"\"aggregate_name\": \"RMS\",$", MR_Next},
-       {"\"aggregate_unit\": \"percentage\",$", MR_Next},
-       {"\"rms\": %float$", MR_Next},
-       {"}", MR_Next}});
-  AddCases(TC_CSVOut, {{"^\"%bigo_name\",,%float,%float,%bigo,,,,,$"},
-                       {"^\"%bigo_name\"", MR_Not},
-                       {"^\"%rms_name\",,%float,%float,,,,,,$", MR_Next}});
-  return 0;
-}
-
-}  // end namespace
-
-// ========================================================================= //
-// --------------------------- Testing BigO O(1) --------------------------- //
-// ========================================================================= //
-
-void BM_Complexity_O1(benchmark::State &state) {
-  for (auto _ : state) {
-    for (int i = 0; i < 1024; ++i) {
-      benchmark::DoNotOptimize(i);
-    }
-  }
-  state.SetComplexityN(state.range(0));
-}
-BENCHMARK(BM_Complexity_O1)->Range(1, 1 << 18)->Complexity(benchmark::o1);
-BENCHMARK(BM_Complexity_O1)->Range(1, 1 << 18)->Complexity();
-BENCHMARK(BM_Complexity_O1)
-    ->Range(1, 1 << 18)
-    ->Complexity([](benchmark::IterationCount) { return 1.0; });
-
-const char *one_test_name = "BM_Complexity_O1";
-const char *big_o_1_test_name = "BM_Complexity_O1_BigO";
-const char *rms_o_1_test_name = "BM_Complexity_O1_RMS";
-const char *enum_big_o_1 = "\\([0-9]+\\)";
-// FIXME: Tolerate both '(1)' and 'lgN' as output when the complexity is auto
-// deduced.
-// See https://github.com/google/benchmark/issues/272
-const char *auto_big_o_1 = "(\\([0-9]+\\))|(lgN)";
-const char *lambda_big_o_1 = "f\\(N\\)";
-
-// Add enum tests
-ADD_COMPLEXITY_CASES(one_test_name, big_o_1_test_name, rms_o_1_test_name,
-                     enum_big_o_1, /*family_index=*/0);
-
-// Add auto enum tests
-ADD_COMPLEXITY_CASES(one_test_name, big_o_1_test_name, rms_o_1_test_name,
-                     auto_big_o_1, /*family_index=*/1);
-
-// Add lambda tests
-ADD_COMPLEXITY_CASES(one_test_name, big_o_1_test_name, rms_o_1_test_name,
-                     lambda_big_o_1, /*family_index=*/2);
-
-// ========================================================================= //
-// --------------------------- Testing BigO O(N) --------------------------- //
-// ========================================================================= //
-
-std::vector<int> ConstructRandomVector(int64_t size) {
-  std::vector<int> v;
-  v.reserve(static_cast<size_t>(size));
-  for (int i = 0; i < size; ++i) {
-    v.push_back(static_cast<int>(std::rand() % size));
-  }
-  return v;
-}
-
-void BM_Complexity_O_N(benchmark::State &state) {
-  auto v = ConstructRandomVector(state.range(0));
-  // Test worst case scenario (item not in vector)
-  const int64_t item_not_in_vector = state.range(0) * 2;
-  for (auto _ : state) {
-    auto it = std::find(v.begin(), v.end(), item_not_in_vector);
-    benchmark::DoNotOptimize(it);
-  }
-  state.SetComplexityN(state.range(0));
-}
-BENCHMARK(BM_Complexity_O_N)
-    ->RangeMultiplier(2)
-    ->Range(1 << 10, 1 << 16)
-    ->Complexity(benchmark::oN);
-BENCHMARK(BM_Complexity_O_N)
-    ->RangeMultiplier(2)
-    ->Range(1 << 10, 1 << 16)
-    ->Complexity([](benchmark::IterationCount n) -> double {
-      return static_cast<double>(n);
-    });
-BENCHMARK(BM_Complexity_O_N)
-    ->RangeMultiplier(2)
-    ->Range(1 << 10, 1 << 16)
-    ->Complexity();
-
-const char *n_test_name = "BM_Complexity_O_N";
-const char *big_o_n_test_name = "BM_Complexity_O_N_BigO";
-const char *rms_o_n_test_name = "BM_Complexity_O_N_RMS";
-const char *enum_auto_big_o_n = "N";
-const char *lambda_big_o_n = "f\\(N\\)";
-
-// Add enum tests
-ADD_COMPLEXITY_CASES(n_test_name, big_o_n_test_name, rms_o_n_test_name,
-                     enum_auto_big_o_n, /*family_index=*/3);
-
-// Add lambda tests
-ADD_COMPLEXITY_CASES(n_test_name, big_o_n_test_name, rms_o_n_test_name,
-                     lambda_big_o_n, /*family_index=*/4);
-
-// ========================================================================= //
-// ------------------------- Testing BigO O(N*lgN) ------------------------- //
-// ========================================================================= //
-
-static void BM_Complexity_O_N_log_N(benchmark::State &state) {
-  auto v = ConstructRandomVector(state.range(0));
-  for (auto _ : state) {
-    std::sort(v.begin(), v.end());
-  }
-  state.SetComplexityN(state.range(0));
-}
-static const double kLog2E = 1.44269504088896340736;
-BENCHMARK(BM_Complexity_O_N_log_N)
-    ->RangeMultiplier(2)
-    ->Range(1 << 10, 1 << 16)
-    ->Complexity(benchmark::oNLogN);
-BENCHMARK(BM_Complexity_O_N_log_N)
-    ->RangeMultiplier(2)
-    ->Range(1 << 10, 1 << 16)
-    ->Complexity([](benchmark::IterationCount n) {
-      return kLog2E * static_cast<double>(n) * log(static_cast<double>(n));
-    });
-BENCHMARK(BM_Complexity_O_N_log_N)
-    ->RangeMultiplier(2)
-    ->Range(1 << 10, 1 << 16)
-    ->Complexity();
-
-const char *n_lg_n_test_name = "BM_Complexity_O_N_log_N";
-const char *big_o_n_lg_n_test_name = "BM_Complexity_O_N_log_N_BigO";
-const char *rms_o_n_lg_n_test_name = "BM_Complexity_O_N_log_N_RMS";
-const char *enum_auto_big_o_n_lg_n = "NlgN";
-const char *lambda_big_o_n_lg_n = "f\\(N\\)";
-
-// Add enum tests
-ADD_COMPLEXITY_CASES(n_lg_n_test_name, big_o_n_lg_n_test_name,
-                     rms_o_n_lg_n_test_name, enum_auto_big_o_n_lg_n,
-                     /*family_index=*/6);
-
-// Add lambda tests
-ADD_COMPLEXITY_CASES(n_lg_n_test_name, big_o_n_lg_n_test_name,
-                     rms_o_n_lg_n_test_name, lambda_big_o_n_lg_n,
-                     /*family_index=*/7);
-
-// ========================================================================= //
-// -------- Testing formatting of Complexity with captured args ------------ //
-// ========================================================================= //
-
-void BM_ComplexityCaptureArgs(benchmark::State &state, int n) {
-  for (auto _ : state) {
-    // This test requires a non-zero CPU time to avoid divide-by-zero
-    auto iterations = state.iterations();
-    benchmark::DoNotOptimize(iterations);
-  }
-  state.SetComplexityN(n);
-}
-
-BENCHMARK_CAPTURE(BM_ComplexityCaptureArgs, capture_test, 100)
-    ->Complexity(benchmark::oN)
-    ->Ranges({{1, 2}, {3, 4}});
-
-const std::string complexity_capture_name =
-    "BM_ComplexityCaptureArgs/capture_test";
-
-ADD_COMPLEXITY_CASES(complexity_capture_name, complexity_capture_name + "_BigO",
-                     complexity_capture_name + "_RMS", "N", /*family_index=*/9);
-
-// ========================================================================= //
-// --------------------------- TEST CASES END ------------------------------ //
-// ========================================================================= //
-
-int main(int argc, char *argv[]) { RunOutputTests(argc, argv); }

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

@@ -1,62 +0,0 @@
-#undef NDEBUG
-#include <cassert>
-#include <cstddef>
-
-#include "benchmark/benchmark.h"
-
-#if __cplusplus >= 201103L
-#error C++11 or greater detected. Should be C++03.
-#endif
-
-#ifdef BENCHMARK_HAS_CXX11
-#error C++11 or greater detected by the library. BENCHMARK_HAS_CXX11 is defined.
-#endif
-
-void BM_empty(benchmark::State& state) {
-  while (state.KeepRunning()) {
-    volatile benchmark::IterationCount x = state.iterations();
-    ((void)x);
-  }
-}
-BENCHMARK(BM_empty);
-
-// The new C++11 interface for args/ranges requires initializer list support.
-// Therefore we provide the old interface to support C++03.
-void BM_old_arg_range_interface(benchmark::State& state) {
-  assert((state.range(0) == 1 && state.range(1) == 2) ||
-         (state.range(0) == 5 && state.range(1) == 6));
-  while (state.KeepRunning()) {
-  }
-}
-BENCHMARK(BM_old_arg_range_interface)->ArgPair(1, 2)->RangePair(5, 5, 6, 6);
-
-template <class T, class U>
-void BM_template2(benchmark::State& state) {
-  BM_empty(state);
-}
-BENCHMARK_TEMPLATE2(BM_template2, int, long);
-
-template <class T>
-void BM_template1(benchmark::State& state) {
-  BM_empty(state);
-}
-BENCHMARK_TEMPLATE(BM_template1, long);
-BENCHMARK_TEMPLATE1(BM_template1, int);
-
-template <class T>
-struct BM_Fixture : public ::benchmark::Fixture {};
-
-BENCHMARK_TEMPLATE_F(BM_Fixture, BM_template1, long)(benchmark::State& state) {
-  BM_empty(state);
-}
-BENCHMARK_TEMPLATE1_F(BM_Fixture, BM_template2, int)(benchmark::State& state) {
-  BM_empty(state);
-}
-
-void BM_counters(benchmark::State& state) {
-  BM_empty(state);
-  state.counters["Foo"] = 2;
-}
-BENCHMARK(BM_counters);
-
-BENCHMARK_MAIN();

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

@@ -1,91 +0,0 @@
-// Testing:
-//   State::PauseTiming()
-//   State::ResumeTiming()
-// Test that CHECK's within these function diagnose when they are called
-// outside of the KeepRunning() loop.
-//
-// NOTE: Users should NOT include or use src/check.h. This is only done in
-// order to test library internals.
-
-#include <cstdlib>
-#include <stdexcept>
-
-#include "../src/check.h"
-#include "benchmark/benchmark.h"
-
-#if defined(__GNUC__) && !defined(__EXCEPTIONS)
-#define TEST_HAS_NO_EXCEPTIONS
-#endif
-
-void TestHandler() {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-  throw std::logic_error("");
-#else
-  std::abort();
-#endif
-}
-
-void try_invalid_pause_resume(benchmark::State& state) {
-#if !defined(TEST_BENCHMARK_LIBRARY_HAS_NO_ASSERTIONS) && \
-    !defined(TEST_HAS_NO_EXCEPTIONS)
-  try {
-    state.PauseTiming();
-    std::abort();
-  } catch (std::logic_error const&) {
-  }
-  try {
-    state.ResumeTiming();
-    std::abort();
-  } catch (std::logic_error const&) {
-  }
-#else
-  (void)state;  // avoid unused warning
-#endif
-}
-
-void BM_diagnostic_test(benchmark::State& state) {
-  static bool called_once = false;
-
-  if (called_once == false) try_invalid_pause_resume(state);
-
-  for (auto _ : state) {
-    auto iterations = state.iterations();
-    benchmark::DoNotOptimize(iterations);
-  }
-
-  if (called_once == false) try_invalid_pause_resume(state);
-
-  called_once = true;
-}
-BENCHMARK(BM_diagnostic_test);
-
-void BM_diagnostic_test_keep_running(benchmark::State& state) {
-  static bool called_once = false;
-
-  if (called_once == false) try_invalid_pause_resume(state);
-
-  while (state.KeepRunning()) {
-    auto iterations = state.iterations();
-    benchmark::DoNotOptimize(iterations);
-  }
-
-  if (called_once == false) try_invalid_pause_resume(state);
-
-  called_once = true;
-}
-BENCHMARK(BM_diagnostic_test_keep_running);
-
-int main(int argc, char* argv[]) {
-#ifdef NDEBUG
-  // This test is exercising functionality for debug builds, which are not
-  // available in release builds. Skip the test if we are in that environment
-  // to avoid a test failure.
-  std::cout << "Diagnostic test disabled in release build" << std::endl;
-  (void)argc;
-  (void)argv;
-#else
-  benchmark::internal::GetAbortHandler() = &TestHandler;
-  benchmark::Initialize(&argc, argv);
-  benchmark::RunSpecifiedBenchmarks();
-#endif
-}

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

@@ -1,45 +0,0 @@
-
-#undef NDEBUG
-#include <cstdio>
-#include <string>
-
-#include "benchmark/benchmark.h"
-#include "output_test.h"
-
-// Ok this test is super ugly. We want to check what happens with the file
-// reporter in the presence of DisplayAggregatesOnly().
-// We do not care about console output, the normal tests check that already.
-
-void BM_SummaryRepeat(benchmark::State& state) {
-  for (auto _ : state) {
-  }
-}
-BENCHMARK(BM_SummaryRepeat)->Repetitions(3)->DisplayAggregatesOnly();
-
-int main(int argc, char* argv[]) {
-  const std::string output = GetFileReporterOutput(argc, argv);
-
-  if (SubstrCnt(output, "\"name\": \"BM_SummaryRepeat/repeats:3") != 7 ||
-      SubstrCnt(output, "\"name\": \"BM_SummaryRepeat/repeats:3\"") != 3 ||
-      SubstrCnt(output, "\"name\": \"BM_SummaryRepeat/repeats:3_mean\"") != 1 ||
-      SubstrCnt(output, "\"name\": \"BM_SummaryRepeat/repeats:3_median\"") !=
-          1 ||
-      SubstrCnt(output, "\"name\": \"BM_SummaryRepeat/repeats:3_stddev\"") !=
-          1 ||
-      SubstrCnt(output, "\"name\": \"BM_SummaryRepeat/repeats:3_cv\"") != 1) {
-    std::cout << "Precondition mismatch. Expected to only find 8 "
-                 "occurrences of \"BM_SummaryRepeat/repeats:3\" substring:\n"
-                 "\"name\": \"BM_SummaryRepeat/repeats:3\", "
-                 "\"name\": \"BM_SummaryRepeat/repeats:3\", "
-                 "\"name\": \"BM_SummaryRepeat/repeats:3\", "
-                 "\"name\": \"BM_SummaryRepeat/repeats:3_mean\", "
-                 "\"name\": \"BM_SummaryRepeat/repeats:3_median\", "
-                 "\"name\": \"BM_SummaryRepeat/repeats:3_stddev\", "
-                 "\"name\": \"BM_SummaryRepeat/repeats:3_cv\"\nThe entire "
-                 "output:\n";
-    std::cout << output;
-    return 1;
-  }
-
-  return 0;
-}

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

@@ -1,201 +0,0 @@
-#include <benchmark/benchmark.h>
-
-#ifdef __clang__
-#pragma clang diagnostic ignored "-Wreturn-type"
-#endif
-BENCHMARK_DISABLE_DEPRECATED_WARNING
-
-extern "C" {
-
-extern int ExternInt;
-extern int ExternInt2;
-extern int ExternInt3;
-extern int BigArray[2049];
-
-const int ConstBigArray[2049]{};
-
-inline int Add42(int x) { return x + 42; }
-
-struct NotTriviallyCopyable {
-  NotTriviallyCopyable();
-  explicit NotTriviallyCopyable(int x) : value(x) {}
-  NotTriviallyCopyable(NotTriviallyCopyable const &);
-  int value;
-};
-
-struct Large {
-  int value;
-  int data[2];
-};
-
-struct ExtraLarge {
-  int arr[2049];
-};
-}
-
-extern ExtraLarge ExtraLargeObj;
-const ExtraLarge ConstExtraLargeObj{};
-
-// CHECK-LABEL: test_with_rvalue:
-extern "C" void test_with_rvalue() {
-  benchmark::DoNotOptimize(Add42(0));
-  // CHECK: movl $42, %eax
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_with_large_rvalue:
-extern "C" void test_with_large_rvalue() {
-  benchmark::DoNotOptimize(Large{ExternInt, {ExternInt, ExternInt}});
-  // CHECK: ExternInt(%rip)
-  // CHECK: movl %eax, -{{[0-9]+}}(%[[REG:[a-z]+]]
-  // CHECK: movl %eax, -{{[0-9]+}}(%[[REG]])
-  // CHECK: movl %eax, -{{[0-9]+}}(%[[REG]])
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_with_non_trivial_rvalue:
-extern "C" void test_with_non_trivial_rvalue() {
-  benchmark::DoNotOptimize(NotTriviallyCopyable(ExternInt));
-  // CHECK: mov{{l|q}} ExternInt(%rip)
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_with_lvalue:
-extern "C" void test_with_lvalue() {
-  int x = 101;
-  benchmark::DoNotOptimize(x);
-  // CHECK-GNU: movl $101, %eax
-  // CHECK-CLANG: movl $101, -{{[0-9]+}}(%[[REG:[a-z]+]])
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_with_large_lvalue:
-extern "C" void test_with_large_lvalue() {
-  Large L{ExternInt, {ExternInt, ExternInt}};
-  benchmark::DoNotOptimize(L);
-  // CHECK: ExternInt(%rip)
-  // CHECK: movl %eax, -{{[0-9]+}}(%[[REG:[a-z]+]])
-  // CHECK: movl %eax, -{{[0-9]+}}(%[[REG]])
-  // CHECK: movl %eax, -{{[0-9]+}}(%[[REG]])
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_with_extra_large_lvalue_with_op:
-extern "C" void test_with_extra_large_lvalue_with_op() {
-  ExtraLargeObj.arr[16] = 42;
-  benchmark::DoNotOptimize(ExtraLargeObj);
-  // CHECK: movl $42, ExtraLargeObj+64(%rip)
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_with_big_array_with_op
-extern "C" void test_with_big_array_with_op() {
-  BigArray[16] = 42;
-  benchmark::DoNotOptimize(BigArray);
-  // CHECK: movl $42, BigArray+64(%rip)
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_with_non_trivial_lvalue:
-extern "C" void test_with_non_trivial_lvalue() {
-  NotTriviallyCopyable NTC(ExternInt);
-  benchmark::DoNotOptimize(NTC);
-  // CHECK: ExternInt(%rip)
-  // CHECK: movl %eax, -{{[0-9]+}}(%[[REG:[a-z]+]])
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_with_const_lvalue:
-extern "C" void test_with_const_lvalue() {
-  const int x = 123;
-  benchmark::DoNotOptimize(x);
-  // CHECK: movl $123, %eax
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_with_large_const_lvalue:
-extern "C" void test_with_large_const_lvalue() {
-  const Large L{ExternInt, {ExternInt, ExternInt}};
-  benchmark::DoNotOptimize(L);
-  // CHECK: ExternInt(%rip)
-  // CHECK: movl %eax, -{{[0-9]+}}(%[[REG:[a-z]+]])
-  // CHECK: movl %eax, -{{[0-9]+}}(%[[REG]])
-  // CHECK: movl %eax, -{{[0-9]+}}(%[[REG]])
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_with_const_extra_large_obj:
-extern "C" void test_with_const_extra_large_obj() {
-  benchmark::DoNotOptimize(ConstExtraLargeObj);
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_with_const_big_array
-extern "C" void test_with_const_big_array() {
-  benchmark::DoNotOptimize(ConstBigArray);
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_with_non_trivial_const_lvalue:
-extern "C" void test_with_non_trivial_const_lvalue() {
-  const NotTriviallyCopyable Obj(ExternInt);
-  benchmark::DoNotOptimize(Obj);
-  // CHECK: mov{{q|l}} ExternInt(%rip)
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_div_by_two:
-extern "C" int test_div_by_two(int input) {
-  int divisor = 2;
-  benchmark::DoNotOptimize(divisor);
-  return input / divisor;
-  // CHECK: movl $2, [[DEST:.*]]
-  // CHECK: idivl [[DEST]]
-  // CHECK: ret
-}
-
-// CHECK-LABEL: test_inc_integer:
-extern "C" int test_inc_integer() {
-  int x = 0;
-  for (int i = 0; i < 5; ++i) benchmark::DoNotOptimize(++x);
-  // CHECK: movl $1, [[DEST:.*]]
-  // CHECK: {{(addl \$1,|incl)}} [[DEST]]
-  // CHECK: {{(addl \$1,|incl)}} [[DEST]]
-  // CHECK: {{(addl \$1,|incl)}} [[DEST]]
-  // CHECK: {{(addl \$1,|incl)}} [[DEST]]
-  // CHECK-CLANG: movl [[DEST]], %eax
-  // CHECK: ret
-  return x;
-}
-
-// CHECK-LABEL: test_pointer_rvalue
-extern "C" void test_pointer_rvalue() {
-  // CHECK: movl $42, [[DEST:.*]]
-  // CHECK: leaq [[DEST]], %rax
-  // CHECK-CLANG: movq %rax, -{{[0-9]+}}(%[[REG:[a-z]+]])
-  // CHECK: ret
-  int x = 42;
-  benchmark::DoNotOptimize(&x);
-}
-
-// CHECK-LABEL: test_pointer_const_lvalue:
-extern "C" void test_pointer_const_lvalue() {
-  // CHECK: movl $42, [[DEST:.*]]
-  // CHECK: leaq [[DEST]], %rax
-  // CHECK-CLANG: movq %rax, -{{[0-9]+}}(%[[REG:[a-z]+]])
-  // CHECK: ret
-  int x = 42;
-  int *const xp = &x;
-  benchmark::DoNotOptimize(xp);
-}
-
-// CHECK-LABEL: test_pointer_lvalue:
-extern "C" void test_pointer_lvalue() {
-  // CHECK: movl $42, [[DEST:.*]]
-  // CHECK: leaq [[DEST]], %rax
-  // CHECK-CLANG: movq %rax, -{{[0-9]+}}(%[[REG:[a-z+]+]])
-  // CHECK: ret
-  int x = 42;
-  int *xp = &x;
-  benchmark::DoNotOptimize(xp);
-}

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

@@ -1,69 +0,0 @@
-#include <cstdint>
-
-#include "benchmark/benchmark.h"
-
-namespace {
-#if defined(__GNUC__)
-std::int64_t double_up(const std::int64_t x) __attribute__((const));
-#endif
-std::int64_t double_up(const std::int64_t x) { return x * 2; }
-}  // namespace
-
-// Using DoNotOptimize on types like BitRef seem to cause a lot of problems
-// with the inline assembly on both GCC and Clang.
-struct BitRef {
-  int index;
-  unsigned char& byte;
-
- public:
-  static BitRef Make() {
-    static unsigned char arr[2] = {};
-    BitRef b(1, arr[0]);
-    return b;
-  }
-
- private:
-  BitRef(int i, unsigned char& b) : index(i), byte(b) {}
-};
-
-int main(int, char*[]) {
-  // this test verifies compilation of DoNotOptimize() for some types
-
-  char buffer1[1] = "";
-  benchmark::DoNotOptimize(buffer1);
-
-  char buffer2[2] = "";
-  benchmark::DoNotOptimize(buffer2);
-
-  char buffer3[3] = "";
-  benchmark::DoNotOptimize(buffer3);
-
-  char buffer8[8] = "";
-  benchmark::DoNotOptimize(buffer8);
-
-  char buffer20[20] = "";
-  benchmark::DoNotOptimize(buffer20);
-
-  char buffer1024[1024] = "";
-  benchmark::DoNotOptimize(buffer1024);
-  char* bptr = &buffer1024[0];
-  benchmark::DoNotOptimize(bptr);
-
-  int x = 123;
-  benchmark::DoNotOptimize(x);
-  int* xp = &x;
-  benchmark::DoNotOptimize(xp);
-  benchmark::DoNotOptimize(x += 42);
-
-  std::int64_t y = double_up(x);
-  benchmark::DoNotOptimize(y);
-
-  // These tests are to e
-  BitRef lval = BitRef::Make();
-  benchmark::DoNotOptimize(lval);
-
-#ifdef BENCHMARK_HAS_CXX11
-  // Check that accept rvalue.
-  benchmark::DoNotOptimize(BitRef::Make());
-#endif
-}