Showing preview only (5,046K chars total). Download the full file or copy to clipboard to get everything.
Repository: ichenq/timerqueue-benchmark
Branch: master
Commit: feca5753e606
Files: 445
Total size: 4.7 MB
Directory structure:
gitextract_2jb94fdk/
├── .dockerignore
├── .editorconfig
├── .gitignore
├── 3rd/
│ ├── benchmark-1.8.2/
│ │ ├── .clang-format
│ │ ├── .clang-tidy
│ │ ├── .github/
│ │ │ ├── ISSUE_TEMPLATE/
│ │ │ │ ├── bug_report.md
│ │ │ │ └── feature_request.md
│ │ │ ├── install_bazel.sh
│ │ │ ├── libcxx-setup.sh
│ │ │ └── workflows/
│ │ │ ├── bazel.yml
│ │ │ ├── build-and-test-min-cmake.yml
│ │ │ ├── build-and-test-perfcounters.yml
│ │ │ ├── build-and-test.yml
│ │ │ ├── clang-format-lint.yml
│ │ │ ├── clang-tidy.yml
│ │ │ ├── doxygen.yml
│ │ │ ├── pylint.yml
│ │ │ ├── sanitizer.yml
│ │ │ ├── test_bindings.yml
│ │ │ └── wheels.yml
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── .ycm_extra_conf.py
│ │ ├── AUTHORS
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── CONTRIBUTING.md
│ │ ├── CONTRIBUTORS
│ │ ├── LICENSE
│ │ ├── MODULE.bazel
│ │ ├── README.md
│ │ ├── WORKSPACE
│ │ ├── WORKSPACE.bzlmod
│ │ ├── _config.yml
│ │ ├── appveyor.yml
│ │ ├── bazel/
│ │ │ └── benchmark_deps.bzl
│ │ ├── bindings/
│ │ │ └── python/
│ │ │ ├── BUILD
│ │ │ ├── build_defs.bzl
│ │ │ ├── google_benchmark/
│ │ │ │ ├── BUILD
│ │ │ │ ├── __init__.py
│ │ │ │ ├── benchmark.cc
│ │ │ │ └── example.py
│ │ │ ├── nanobind.BUILD
│ │ │ ├── python_headers.BUILD
│ │ │ └── requirements.txt
│ │ ├── cmake/
│ │ │ ├── Config.cmake.in
│ │ │ ├── GoogleTest.cmake.in
│ │ │ ├── benchmark.pc.in
│ │ │ ├── gnu_posix_regex.cpp
│ │ │ ├── posix_regex.cpp
│ │ │ ├── pthread_affinity.cpp
│ │ │ ├── std_regex.cpp
│ │ │ ├── steady_clock.cpp
│ │ │ └── thread_safety_attributes.cpp
│ │ ├── docs/
│ │ │ ├── AssemblyTests.md
│ │ │ ├── _config.yml
│ │ │ ├── dependencies.md
│ │ │ ├── index.md
│ │ │ ├── perf_counters.md
│ │ │ ├── platform_specific_build_instructions.md
│ │ │ ├── python_bindings.md
│ │ │ ├── random_interleaving.md
│ │ │ ├── reducing_variance.md
│ │ │ ├── releasing.md
│ │ │ ├── tools.md
│ │ │ └── user_guide.md
│ │ ├── include/
│ │ │ └── benchmark/
│ │ │ ├── benchmark.h
│ │ │ └── export.h
│ │ ├── setup.py
│ │ ├── src/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── arraysize.h
│ │ │ ├── benchmark.cc
│ │ │ ├── benchmark_api_internal.cc
│ │ │ ├── benchmark_api_internal.h
│ │ │ ├── benchmark_main.cc
│ │ │ ├── benchmark_name.cc
│ │ │ ├── benchmark_register.cc
│ │ │ ├── benchmark_register.h
│ │ │ ├── benchmark_runner.cc
│ │ │ ├── benchmark_runner.h
│ │ │ ├── check.cc
│ │ │ ├── check.h
│ │ │ ├── colorprint.cc
│ │ │ ├── colorprint.h
│ │ │ ├── commandlineflags.cc
│ │ │ ├── commandlineflags.h
│ │ │ ├── complexity.cc
│ │ │ ├── complexity.h
│ │ │ ├── console_reporter.cc
│ │ │ ├── counter.cc
│ │ │ ├── counter.h
│ │ │ ├── csv_reporter.cc
│ │ │ ├── cycleclock.h
│ │ │ ├── internal_macros.h
│ │ │ ├── json_reporter.cc
│ │ │ ├── log.h
│ │ │ ├── mutex.h
│ │ │ ├── perf_counters.cc
│ │ │ ├── perf_counters.h
│ │ │ ├── re.h
│ │ │ ├── reporter.cc
│ │ │ ├── statistics.cc
│ │ │ ├── statistics.h
│ │ │ ├── string_util.cc
│ │ │ ├── string_util.h
│ │ │ ├── sysinfo.cc
│ │ │ ├── thread_manager.h
│ │ │ ├── thread_timer.h
│ │ │ ├── timers.cc
│ │ │ └── timers.h
│ │ ├── test/
│ │ │ ├── BUILD
│ │ │ ├── CMakeLists.txt
│ │ │ ├── args_product_test.cc
│ │ │ ├── basic_test.cc
│ │ │ ├── benchmark_gtest.cc
│ │ │ ├── benchmark_min_time_flag_iters_test.cc
│ │ │ ├── benchmark_min_time_flag_time_test.cc
│ │ │ ├── benchmark_name_gtest.cc
│ │ │ ├── benchmark_random_interleaving_gtest.cc
│ │ │ ├── benchmark_setup_teardown_test.cc
│ │ │ ├── benchmark_test.cc
│ │ │ ├── clobber_memory_assembly_test.cc
│ │ │ ├── commandlineflags_gtest.cc
│ │ │ ├── complexity_test.cc
│ │ │ ├── cxx03_test.cc
│ │ │ ├── diagnostics_test.cc
│ │ │ ├── display_aggregates_only_test.cc
│ │ │ ├── donotoptimize_assembly_test.cc
│ │ │ ├── donotoptimize_test.cc
│ │ │ ├── filter_test.cc
│ │ │ ├── fixture_test.cc
│ │ │ ├── internal_threading_test.cc
│ │ │ ├── link_main_test.cc
│ │ │ ├── map_test.cc
│ │ │ ├── memory_manager_test.cc
│ │ │ ├── min_time_parse_gtest.cc
│ │ │ ├── multiple_ranges_test.cc
│ │ │ ├── options_test.cc
│ │ │ ├── output_test.h
│ │ │ ├── output_test_helper.cc
│ │ │ ├── perf_counters_gtest.cc
│ │ │ ├── perf_counters_test.cc
│ │ │ ├── register_benchmark_test.cc
│ │ │ ├── repetitions_test.cc
│ │ │ ├── report_aggregates_only_test.cc
│ │ │ ├── reporter_output_test.cc
│ │ │ ├── skip_with_error_test.cc
│ │ │ ├── spec_arg_test.cc
│ │ │ ├── spec_arg_verbosity_test.cc
│ │ │ ├── state_assembly_test.cc
│ │ │ ├── statistics_gtest.cc
│ │ │ ├── string_util_gtest.cc
│ │ │ ├── templated_fixture_test.cc
│ │ │ ├── time_unit_gtest.cc
│ │ │ ├── user_counters_tabular_test.cc
│ │ │ ├── user_counters_test.cc
│ │ │ └── user_counters_thousands_test.cc
│ │ └── tools/
│ │ ├── BUILD.bazel
│ │ ├── compare.py
│ │ ├── gbench/
│ │ │ ├── Inputs/
│ │ │ │ ├── test1_run1.json
│ │ │ │ ├── test1_run2.json
│ │ │ │ ├── test2_run.json
│ │ │ │ ├── test3_run0.json
│ │ │ │ ├── test3_run1.json
│ │ │ │ ├── test4_run.json
│ │ │ │ ├── test4_run0.json
│ │ │ │ └── test4_run1.json
│ │ │ ├── __init__.py
│ │ │ ├── report.py
│ │ │ └── util.py
│ │ ├── libpfm.BUILD.bazel
│ │ ├── requirements.txt
│ │ └── strip_asm.py
│ └── googletest-1.12.1/
│ ├── .clang-format
│ ├── .github/
│ │ ├── ISSUE_TEMPLATE/
│ │ │ ├── 00-bug_report.md
│ │ │ ├── 10-feature_request.md
│ │ │ └── config.yml
│ │ └── workflows/
│ │ └── gtest-ci.yml
│ ├── .gitignore
│ ├── BUILD.bazel
│ ├── CMakeLists.txt
│ ├── CONTRIBUTING.md
│ ├── CONTRIBUTORS
│ ├── LICENSE
│ ├── README.md
│ ├── WORKSPACE
│ ├── ci/
│ │ ├── linux-presubmit.sh
│ │ └── macos-presubmit.sh
│ ├── docs/
│ │ ├── _config.yml
│ │ ├── _data/
│ │ │ └── navigation.yml
│ │ ├── _layouts/
│ │ │ └── default.html
│ │ ├── _sass/
│ │ │ └── main.scss
│ │ ├── advanced.md
│ │ ├── assets/
│ │ │ └── css/
│ │ │ └── style.scss
│ │ ├── community_created_documentation.md
│ │ ├── faq.md
│ │ ├── gmock_cheat_sheet.md
│ │ ├── gmock_cook_book.md
│ │ ├── gmock_faq.md
│ │ ├── gmock_for_dummies.md
│ │ ├── index.md
│ │ ├── pkgconfig.md
│ │ ├── platforms.md
│ │ ├── primer.md
│ │ ├── quickstart-bazel.md
│ │ ├── quickstart-cmake.md
│ │ ├── reference/
│ │ │ ├── actions.md
│ │ │ ├── assertions.md
│ │ │ ├── matchers.md
│ │ │ ├── mocking.md
│ │ │ └── testing.md
│ │ └── samples.md
│ ├── googlemock/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── cmake/
│ │ │ ├── gmock.pc.in
│ │ │ └── gmock_main.pc.in
│ │ ├── docs/
│ │ │ └── README.md
│ │ ├── include/
│ │ │ └── gmock/
│ │ │ ├── gmock-actions.h
│ │ │ ├── gmock-cardinalities.h
│ │ │ ├── gmock-function-mocker.h
│ │ │ ├── gmock-matchers.h
│ │ │ ├── gmock-more-actions.h
│ │ │ ├── gmock-more-matchers.h
│ │ │ ├── gmock-nice-strict.h
│ │ │ ├── gmock-spec-builders.h
│ │ │ ├── gmock.h
│ │ │ └── internal/
│ │ │ ├── custom/
│ │ │ │ ├── README.md
│ │ │ │ ├── gmock-generated-actions.h
│ │ │ │ ├── gmock-matchers.h
│ │ │ │ └── gmock-port.h
│ │ │ ├── gmock-internal-utils.h
│ │ │ ├── gmock-port.h
│ │ │ └── gmock-pp.h
│ │ ├── src/
│ │ │ ├── gmock-all.cc
│ │ │ ├── gmock-cardinalities.cc
│ │ │ ├── gmock-internal-utils.cc
│ │ │ ├── gmock-matchers.cc
│ │ │ ├── gmock-spec-builders.cc
│ │ │ ├── gmock.cc
│ │ │ └── gmock_main.cc
│ │ └── test/
│ │ ├── BUILD.bazel
│ │ ├── gmock-actions_test.cc
│ │ ├── gmock-cardinalities_test.cc
│ │ ├── gmock-function-mocker_test.cc
│ │ ├── gmock-internal-utils_test.cc
│ │ ├── gmock-matchers-arithmetic_test.cc
│ │ ├── gmock-matchers-comparisons_test.cc
│ │ ├── gmock-matchers-containers_test.cc
│ │ ├── gmock-matchers-misc_test.cc
│ │ ├── gmock-matchers_test.h
│ │ ├── gmock-more-actions_test.cc
│ │ ├── gmock-nice-strict_test.cc
│ │ ├── gmock-port_test.cc
│ │ ├── gmock-pp-string_test.cc
│ │ ├── gmock-pp_test.cc
│ │ ├── gmock-spec-builders_test.cc
│ │ ├── gmock_all_test.cc
│ │ ├── gmock_ex_test.cc
│ │ ├── gmock_leak_test.py
│ │ ├── gmock_leak_test_.cc
│ │ ├── gmock_link2_test.cc
│ │ ├── gmock_link_test.cc
│ │ ├── gmock_link_test.h
│ │ ├── gmock_output_test.py
│ │ ├── gmock_output_test_.cc
│ │ ├── gmock_output_test_golden.txt
│ │ ├── gmock_stress_test.cc
│ │ ├── gmock_test.cc
│ │ └── gmock_test_utils.py
│ └── googletest/
│ ├── CMakeLists.txt
│ ├── README.md
│ ├── cmake/
│ │ ├── Config.cmake.in
│ │ ├── gtest.pc.in
│ │ ├── gtest_main.pc.in
│ │ ├── internal_utils.cmake
│ │ └── libgtest.la.in
│ ├── docs/
│ │ └── README.md
│ ├── include/
│ │ └── gtest/
│ │ ├── gtest-assertion-result.h
│ │ ├── gtest-death-test.h
│ │ ├── gtest-matchers.h
│ │ ├── gtest-message.h
│ │ ├── gtest-param-test.h
│ │ ├── gtest-printers.h
│ │ ├── gtest-spi.h
│ │ ├── gtest-test-part.h
│ │ ├── gtest-typed-test.h
│ │ ├── gtest.h
│ │ ├── gtest_pred_impl.h
│ │ ├── gtest_prod.h
│ │ └── internal/
│ │ ├── custom/
│ │ │ ├── README.md
│ │ │ ├── gtest-port.h
│ │ │ ├── gtest-printers.h
│ │ │ └── gtest.h
│ │ ├── gtest-death-test-internal.h
│ │ ├── gtest-filepath.h
│ │ ├── gtest-internal.h
│ │ ├── gtest-param-util.h
│ │ ├── gtest-port-arch.h
│ │ ├── gtest-port.h
│ │ ├── gtest-string.h
│ │ └── gtest-type-util.h
│ ├── samples/
│ │ ├── prime_tables.h
│ │ ├── sample1.cc
│ │ ├── sample1.h
│ │ ├── sample10_unittest.cc
│ │ ├── sample1_unittest.cc
│ │ ├── sample2.cc
│ │ ├── sample2.h
│ │ ├── sample2_unittest.cc
│ │ ├── sample3-inl.h
│ │ ├── sample3_unittest.cc
│ │ ├── sample4.cc
│ │ ├── sample4.h
│ │ ├── sample4_unittest.cc
│ │ ├── sample5_unittest.cc
│ │ ├── sample6_unittest.cc
│ │ ├── sample7_unittest.cc
│ │ ├── sample8_unittest.cc
│ │ └── sample9_unittest.cc
│ ├── src/
│ │ ├── gtest-all.cc
│ │ ├── gtest-assertion-result.cc
│ │ ├── gtest-death-test.cc
│ │ ├── gtest-filepath.cc
│ │ ├── gtest-internal-inl.h
│ │ ├── gtest-matchers.cc
│ │ ├── gtest-port.cc
│ │ ├── gtest-printers.cc
│ │ ├── gtest-test-part.cc
│ │ ├── gtest-typed-test.cc
│ │ ├── gtest.cc
│ │ └── gtest_main.cc
│ └── test/
│ ├── BUILD.bazel
│ ├── googletest-break-on-failure-unittest.py
│ ├── googletest-break-on-failure-unittest_.cc
│ ├── googletest-catch-exceptions-test.py
│ ├── googletest-catch-exceptions-test_.cc
│ ├── googletest-color-test.py
│ ├── googletest-color-test_.cc
│ ├── googletest-death-test-test.cc
│ ├── googletest-death-test_ex_test.cc
│ ├── googletest-env-var-test.py
│ ├── googletest-env-var-test_.cc
│ ├── googletest-failfast-unittest.py
│ ├── googletest-failfast-unittest_.cc
│ ├── googletest-filepath-test.cc
│ ├── googletest-filter-unittest.py
│ ├── googletest-filter-unittest_.cc
│ ├── googletest-global-environment-unittest.py
│ ├── googletest-global-environment-unittest_.cc
│ ├── googletest-json-outfiles-test.py
│ ├── googletest-json-output-unittest.py
│ ├── googletest-list-tests-unittest.py
│ ├── googletest-list-tests-unittest_.cc
│ ├── googletest-listener-test.cc
│ ├── googletest-message-test.cc
│ ├── googletest-options-test.cc
│ ├── googletest-output-test-golden-lin.txt
│ ├── googletest-output-test.py
│ ├── googletest-output-test_.cc
│ ├── googletest-param-test-invalid-name1-test.py
│ ├── googletest-param-test-invalid-name1-test_.cc
│ ├── googletest-param-test-invalid-name2-test.py
│ ├── googletest-param-test-invalid-name2-test_.cc
│ ├── googletest-param-test-test.cc
│ ├── googletest-param-test-test.h
│ ├── googletest-param-test2-test.cc
│ ├── googletest-port-test.cc
│ ├── googletest-printers-test.cc
│ ├── googletest-setuptestsuite-test.py
│ ├── googletest-setuptestsuite-test_.cc
│ ├── googletest-shuffle-test.py
│ ├── googletest-shuffle-test_.cc
│ ├── googletest-test-part-test.cc
│ ├── googletest-throw-on-failure-test.py
│ ├── googletest-throw-on-failure-test_.cc
│ ├── googletest-uninitialized-test.py
│ ├── googletest-uninitialized-test_.cc
│ ├── gtest-typed-test2_test.cc
│ ├── gtest-typed-test_test.cc
│ ├── gtest-typed-test_test.h
│ ├── gtest-unittest-api_test.cc
│ ├── gtest_all_test.cc
│ ├── gtest_assert_by_exception_test.cc
│ ├── gtest_environment_test.cc
│ ├── gtest_help_test.py
│ ├── gtest_help_test_.cc
│ ├── gtest_json_test_utils.py
│ ├── gtest_list_output_unittest.py
│ ├── gtest_list_output_unittest_.cc
│ ├── gtest_main_unittest.cc
│ ├── gtest_no_test_unittest.cc
│ ├── gtest_pred_impl_unittest.cc
│ ├── gtest_premature_exit_test.cc
│ ├── gtest_prod_test.cc
│ ├── gtest_repeat_test.cc
│ ├── gtest_skip_check_output_test.py
│ ├── gtest_skip_environment_check_output_test.py
│ ├── gtest_skip_in_environment_setup_test.cc
│ ├── gtest_skip_test.cc
│ ├── gtest_sole_header_test.cc
│ ├── gtest_stress_test.cc
│ ├── gtest_test_macro_stack_footprint_test.cc
│ ├── gtest_test_utils.py
│ ├── gtest_testbridge_test.py
│ ├── gtest_testbridge_test_.cc
│ ├── gtest_throw_on_failure_ex_test.cc
│ ├── gtest_unittest.cc
│ ├── gtest_xml_outfile1_test_.cc
│ ├── gtest_xml_outfile2_test_.cc
│ ├── gtest_xml_outfiles_test.py
│ ├── gtest_xml_output_unittest.py
│ ├── gtest_xml_output_unittest_.cc
│ ├── gtest_xml_test_utils.py
│ ├── production.cc
│ └── production.h
├── CMakeLists.txt
├── Dockerfile
├── LICENSE
├── README.md
├── src/
│ ├── Clock.cpp
│ ├── Clock.h
│ ├── CmdFlag.h
│ ├── HHWheelTimer.cpp
│ ├── HHWheelTimer.h
│ ├── HashedWheelBucket.cpp
│ ├── HashedWheelBucket.h
│ ├── HashedWheelTimer.cpp
│ ├── HashedWheelTimer.h
│ ├── Logging.cpp
│ ├── Logging.h
│ ├── Preprocessor.h
│ ├── PriorityQueueTimer.cpp
│ ├── PriorityQueueTimer.h
│ ├── QuadHeapTimer.cpp
│ ├── QuadHeapTimer.h
│ ├── RBTreeTimer.cpp
│ ├── RBTreeTimer.h
│ ├── TimerBase.cpp
│ ├── TimerBase.h
│ ├── list_impl.h
│ ├── timer_list.cpp
│ └── timer_list.h
└── test/
├── BenchTimer.cpp
├── TestTimer.cpp
└── main.cpp
================================================
FILE CONTENTS
================================================
================================================
FILE: .dockerignore
================================================
# IDE
.vscode/
.idea/
.DS_Store
/bin
/cmake*/
================================================
FILE: .editorconfig
================================================
# EditorConfig is awesome: https://EditorConfig.org
root = true
[*]
charset = utf-8
end_of_line = lf
trim_trailing_whitespace = true
insert_final_newline = true
indent_style = space
indent_size = 4
================================================
FILE: .gitignore
================================================
.vs/
.idea/
.vscode/
/cmake-build*
# Prerequisites
*.d
# Compiled Object files
*.slo
*.lo
*.o
*.obj
# Precompiled Headers
*.gch
*.pch
# Compiled Dynamic libraries
*.so
*.dylib
*.dll
# Fortran module files
*.mod
*.smod
# Compiled Static libraries
*.lai
*.la
*.a
*.lib
# Executables
*.exe
*.out
*.app
================================================
FILE: 3rd/benchmark-1.8.2/.clang-format
================================================
---
Language: Cpp
BasedOnStyle: Google
PointerAlignment: Left
...
================================================
FILE: 3rd/benchmark-1.8.2/.clang-tidy
================================================
---
Checks: 'clang-analyzer-*,readability-redundant-*,performance-*'
WarningsAsErrors: 'clang-analyzer-*,readability-redundant-*,performance-*'
HeaderFilterRegex: '.*'
AnalyzeTemporaryDtors: false
FormatStyle: none
User: user
================================================
FILE: 3rd/benchmark-1.8.2/.github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug report
about: Create a report to help us improve
title: "[BUG]"
labels: ''
assignees: ''
---
**Describe the bug**
A clear and concise description of what the bug is.
**System**
Which OS, compiler, and compiler version are you using:
- OS:
- Compiler and version:
**To reproduce**
Steps to reproduce the behavior:
1. sync to commit ...
2. cmake/bazel...
3. make ...
4. See error
**Expected behavior**
A clear and concise description of what you expected to happen.
**Screenshots**
If applicable, add screenshots to help explain your problem.
**Additional context**
Add any other context about the problem here.
================================================
FILE: 3rd/benchmark-1.8.2/.github/ISSUE_TEMPLATE/feature_request.md
================================================
---
name: Feature request
about: Suggest an idea for this project
title: "[FR]"
labels: ''
assignees: ''
---
**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
**Describe the solution you'd like**
A clear and concise description of what you want to happen.
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.
**Additional context**
Add any other context or screenshots about the feature request here.
================================================
FILE: 3rd/benchmark-1.8.2/.github/install_bazel.sh
================================================
if ! bazel version; then
arch=$(uname -m)
if [ "$arch" == "aarch64" ]; then
arch="arm64"
fi
echo "Installing wget and downloading $arch Bazel binary from GitHub releases."
yum install -y wget
wget "https://github.com/bazelbuild/bazel/releases/download/6.0.0/bazel-6.0.0-linux-$arch" -O /usr/local/bin/bazel
chmod +x /usr/local/bin/bazel
else
# bazel is installed for the correct architecture
exit 0
fi
================================================
FILE: 3rd/benchmark-1.8.2/.github/libcxx-setup.sh
================================================
#!/usr/bin/env bash
set -e
# Checkout LLVM sources
git clone --depth=1 https://github.com/llvm/llvm-project.git llvm-project
## Setup libc++ options
if [ -z "$BUILD_32_BITS" ]; then
export BUILD_32_BITS=OFF && echo disabling 32 bit build
fi
## Build and install libc++ (Use unstable ABI for better sanitizer coverage)
mkdir llvm-build && cd llvm-build
cmake -DCMAKE_C_COMPILER=${CC} \
-DCMAKE_CXX_COMPILER=${CXX} \
-DCMAKE_BUILD_TYPE=RelWithDebInfo \
-DCMAKE_INSTALL_PREFIX=/usr \
-DLIBCXX_ABI_UNSTABLE=OFF \
-DLLVM_USE_SANITIZER=${LIBCXX_SANITIZER} \
-DLLVM_BUILD_32_BITS=${BUILD_32_BITS} \
-DLLVM_ENABLE_RUNTIMES='libcxx;libcxxabi;libunwind' \
-G "Unix Makefiles" \
../llvm-project/runtimes/
make -j cxx cxxabi unwind
cd ..
================================================
FILE: 3rd/benchmark-1.8.2/.github/workflows/bazel.yml
================================================
name: bazel
on:
push: {}
pull_request: {}
jobs:
build_and_test_default:
name: bazel.${{ matrix.os }}.${{ matrix.bzlmod && 'bzlmod' || 'no_bzlmod' }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [ubuntu-latest, macos-latest, windows-2022]
bzlmod: [false, true]
steps:
- uses: actions/checkout@v3
- name: mount bazel cache
uses: actions/cache@v3
env:
cache-name: bazel-cache
with:
path: "~/.cache/bazel"
key: ${{ env.cache-name }}-${{ matrix.os }}-${{ github.ref }}
restore-keys: |
${{ env.cache-name }}-${{ matrix.os }}-main
- name: build
run: |
bazel build ${{ matrix.bzlmod && '--enable_bzlmod' || '--noenable_bzlmod' }} //:benchmark //:benchmark_main //test/...
- name: test
run: |
bazel test ${{ matrix.bzlmod && '--enable_bzlmod' || '--noenable_bzlmod' }} --test_output=all //test/...
================================================
FILE: 3rd/benchmark-1.8.2/.github/workflows/build-and-test-min-cmake.yml
================================================
name: build-and-test-min-cmake
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
job:
name: ${{ matrix.os }}.min-cmake
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [ubuntu-latest, macos-latest]
steps:
- uses: actions/checkout@v3
- uses: lukka/get-cmake@latest
with:
cmakeVersion: 3.10.0
- name: create build environment
run: cmake -E make_directory ${{ runner.workspace }}/_build
- name: setup cmake initial cache
run: touch compiler-cache.cmake
- name: configure cmake
env:
CXX: ${{ matrix.compiler }}
shell: bash
working-directory: ${{ runner.workspace }}/_build
run: >
cmake -C ${{ github.workspace }}/compiler-cache.cmake
$GITHUB_WORKSPACE
-DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
-DCMAKE_CXX_VISIBILITY_PRESET=hidden
-DCMAKE_VISIBILITY_INLINES_HIDDEN=ON
- name: build
shell: bash
working-directory: ${{ runner.workspace }}/_build
run: cmake --build .
================================================
FILE: 3rd/benchmark-1.8.2/.github/workflows/build-and-test-perfcounters.yml
================================================
name: build-and-test-perfcounters
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
job:
# TODO(dominic): Extend this to include compiler and set through env: CC/CXX.
name: ${{ matrix.os }}.${{ matrix.build_type }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [ubuntu-22.04, ubuntu-20.04]
build_type: ['Release', 'Debug']
steps:
- uses: actions/checkout@v3
- name: install libpfm
run: |
sudo apt update
sudo apt -y install libpfm4-dev
- name: create build environment
run: cmake -E make_directory ${{ runner.workspace }}/_build
- name: configure cmake
shell: bash
working-directory: ${{ runner.workspace }}/_build
run: >
cmake $GITHUB_WORKSPACE
-DBENCHMARK_ENABLE_LIBPFM=1
-DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
-DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
- name: build
shell: bash
working-directory: ${{ runner.workspace }}/_build
run: cmake --build . --config ${{ matrix.build_type }}
# Skip testing, for now. It seems perf_event_open does not succeed on the
# hosting machine, very likely a permissions issue.
# TODO(mtrofin): Enable test.
# - name: test
# shell: bash
# working-directory: ${{ runner.workspace }}/_build
# run: ctest -C ${{ matrix.build_type }} --rerun-failed --output-on-failure
================================================
FILE: 3rd/benchmark-1.8.2/.github/workflows/build-and-test.yml
================================================
name: build-and-test
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
# TODO: add 32-bit builds (g++ and clang++) for ubuntu
# (requires g++-multilib and libc6:i386)
# TODO: add coverage build (requires lcov)
# TODO: add clang + libc++ builds for ubuntu
job:
name: ${{ matrix.os }}.${{ matrix.build_type }}.${{ matrix.lib }}.${{ matrix.compiler }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [ubuntu-22.04, ubuntu-20.04, macos-latest]
build_type: ['Release', 'Debug']
compiler: ['g++', 'clang++']
lib: ['shared', 'static']
steps:
- uses: actions/checkout@v3
- uses: lukka/get-cmake@latest
- name: create build environment
run: cmake -E make_directory ${{ runner.workspace }}/_build
- name: setup cmake initial cache
run: touch compiler-cache.cmake
- name: configure cmake
env:
CXX: ${{ matrix.compiler }}
shell: bash
working-directory: ${{ runner.workspace }}/_build
run: >
cmake -C ${{ github.workspace }}/compiler-cache.cmake
$GITHUB_WORKSPACE
-DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
-DBUILD_SHARED_LIBS=${{ matrix.lib == 'shared' }}
-DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
-DCMAKE_CXX_COMPILER=${{ env.CXX }}
-DCMAKE_CXX_VISIBILITY_PRESET=hidden
-DCMAKE_VISIBILITY_INLINES_HIDDEN=ON
- name: build
shell: bash
working-directory: ${{ runner.workspace }}/_build
run: cmake --build . --config ${{ matrix.build_type }}
- name: test
shell: bash
working-directory: ${{ runner.workspace }}/_build
run: ctest -C ${{ matrix.build_type }} -VV
msvc:
name: ${{ matrix.os }}.${{ matrix.build_type }}.${{ matrix.lib }}.${{ matrix.msvc }}
runs-on: ${{ matrix.os }}
defaults:
run:
shell: powershell
strategy:
fail-fast: false
matrix:
msvc:
- VS-16-2019
- VS-17-2022
arch:
- x64
build_type:
- Debug
- Release
lib:
- shared
- static
include:
- msvc: VS-16-2019
os: windows-2019
generator: 'Visual Studio 16 2019'
- msvc: VS-17-2022
os: windows-2022
generator: 'Visual Studio 17 2022'
steps:
- uses: actions/checkout@v2
- uses: lukka/get-cmake@latest
- name: configure cmake
run: >
cmake -S . -B _build/
-A ${{ matrix.arch }}
-G "${{ matrix.generator }}"
-DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
-DBUILD_SHARED_LIBS=${{ matrix.lib == 'shared' }}
- name: build
run: cmake --build _build/ --config ${{ matrix.build_type }}
- name: setup test environment
# Make sure gmock and benchmark DLLs can be found
run: >
echo "$((Get-Item .).FullName)/_build/bin/${{ matrix.build_type }}" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append;
echo "$((Get-Item .).FullName)/_build/src/${{ matrix.build_type }}" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append;
- name: test
run: ctest --test-dir _build/ -C ${{ matrix.build_type }} -VV
================================================
FILE: 3rd/benchmark-1.8.2/.github/workflows/clang-format-lint.yml
================================================
name: clang-format-lint
on:
push: {}
pull_request: {}
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: DoozyX/clang-format-lint-action@v0.13
with:
source: './include/benchmark ./src ./test'
extensions: 'h,cc'
clangFormatVersion: 12
style: Google
================================================
FILE: 3rd/benchmark-1.8.2/.github/workflows/clang-tidy.yml
================================================
name: clang-tidy
on:
push: {}
pull_request: {}
jobs:
job:
name: run-clang-tidy
runs-on: ubuntu-latest
strategy:
fail-fast: false
steps:
- uses: actions/checkout@v3
- name: install clang-tidy
run: sudo apt update && sudo apt -y install clang-tidy
- name: create build environment
run: cmake -E make_directory ${{ runner.workspace }}/_build
- name: configure cmake
shell: bash
working-directory: ${{ runner.workspace }}/_build
run: >
cmake $GITHUB_WORKSPACE
-DBENCHMARK_ENABLE_ASSEMBLY_TESTS=OFF
-DBENCHMARK_ENABLE_LIBPFM=OFF
-DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
-DCMAKE_C_COMPILER=clang
-DCMAKE_CXX_COMPILER=clang++
-DCMAKE_EXPORT_COMPILE_COMMANDS=ON
-DGTEST_COMPILE_COMMANDS=OFF
- name: run
shell: bash
working-directory: ${{ runner.workspace }}/_build
run: run-clang-tidy
================================================
FILE: 3rd/benchmark-1.8.2/.github/workflows/doxygen.yml
================================================
name: doxygen
on:
push:
branches: [main]
pull_request:
branches: [main]
jobs:
build-and-deploy:
name: Build HTML documentation
runs-on: ubuntu-latest
steps:
- name: Fetching sources
uses: actions/checkout@v3
- name: Installing build dependencies
run: |
sudo apt update
sudo apt install doxygen gcc git
- name: Creating build directory
run: mkdir build
- name: Building HTML documentation with Doxygen
run: |
cmake -S . -B build -DBENCHMARK_ENABLE_TESTING:BOOL=OFF -DBENCHMARK_ENABLE_DOXYGEN:BOOL=ON -DBENCHMARK_INSTALL_DOCS:BOOL=ON
cmake --build build --target benchmark_doxygen
================================================
FILE: 3rd/benchmark-1.8.2/.github/workflows/pylint.yml
================================================
name: pylint
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
pylint:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set up Python 3.8
uses: actions/setup-python@v1
with:
python-version: 3.8
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install pylint pylint-exit conan
- name: Run pylint
run: |
pylint `find . -name '*.py'|xargs` || pylint-exit $?
================================================
FILE: 3rd/benchmark-1.8.2/.github/workflows/sanitizer.yml
================================================
name: sanitizer
on:
push: {}
pull_request: {}
env:
UBSAN_OPTIONS: "print_stacktrace=1"
jobs:
job:
name: ${{ matrix.sanitizer }}.${{ matrix.build_type }}
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
build_type: ['Debug', 'RelWithDebInfo']
sanitizer: ['asan', 'ubsan', 'tsan', 'msan']
steps:
- uses: actions/checkout@v3
- name: configure msan env
if: matrix.sanitizer == 'msan'
run: |
echo "EXTRA_FLAGS=-g -O2 -fno-omit-frame-pointer -fsanitize=memory -fsanitize-memory-track-origins" >> $GITHUB_ENV
echo "LIBCXX_SANITIZER=MemoryWithOrigins" >> $GITHUB_ENV
- name: configure ubsan env
if: matrix.sanitizer == 'ubsan'
run: |
echo "EXTRA_FLAGS=-g -O2 -fno-omit-frame-pointer -fsanitize=undefined -fno-sanitize-recover=all" >> $GITHUB_ENV
echo "LIBCXX_SANITIZER=Undefined" >> $GITHUB_ENV
- name: configure asan env
if: matrix.sanitizer == 'asan'
run: |
echo "EXTRA_FLAGS=-g -O2 -fno-omit-frame-pointer -fsanitize=address -fno-sanitize-recover=all" >> $GITHUB_ENV
echo "LIBCXX_SANITIZER=Address" >> $GITHUB_ENV
- name: configure tsan env
if: matrix.sanitizer == 'tsan'
run: |
echo "EXTRA_FLAGS=-g -O2 -fno-omit-frame-pointer -fsanitize=thread -fno-sanitize-recover=all" >> $GITHUB_ENV
echo "LIBCXX_SANITIZER=Thread" >> $GITHUB_ENV
- name: fine-tune asan options
# in asan we get an error from std::regex. ignore it.
if: matrix.sanitizer == 'asan'
run: |
echo "ASAN_OPTIONS=alloc_dealloc_mismatch=0" >> $GITHUB_ENV
- name: setup clang
uses: egor-tensin/setup-clang@v1
with:
version: latest
platform: x64
- name: configure clang
run: |
echo "CC=cc" >> $GITHUB_ENV
echo "CXX=c++" >> $GITHUB_ENV
- name: build libc++ (non-asan)
if: matrix.sanitizer != 'asan'
run: |
"${GITHUB_WORKSPACE}/.github/libcxx-setup.sh"
echo "EXTRA_CXX_FLAGS=-stdlib=libc++ -L ${GITHUB_WORKSPACE}/llvm-build/lib -lc++abi -Isystem${GITHUB_WORKSPACE}/llvm-build/include -Isystem${GITHUB_WORKSPACE}/llvm-build/include/c++/v1 -Wl,-rpath,${GITHUB_WORKSPACE}/llvm-build/lib" >> $GITHUB_ENV
- name: create build environment
run: cmake -E make_directory ${{ runner.workspace }}/_build
- name: configure cmake
shell: bash
working-directory: ${{ runner.workspace }}/_build
run: >
VERBOSE=1
cmake $GITHUB_WORKSPACE
-DBENCHMARK_ENABLE_ASSEMBLY_TESTS=OFF
-DBENCHMARK_ENABLE_LIBPFM=OFF
-DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON
-DCMAKE_C_COMPILER=${{ env.CC }}
-DCMAKE_CXX_COMPILER=${{ env.CXX }}
-DCMAKE_C_FLAGS="${{ env.EXTRA_FLAGS }}"
-DCMAKE_CXX_FLAGS="${{ env.EXTRA_FLAGS }} ${{ env.EXTRA_CXX_FLAGS }}"
-DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
- name: build
shell: bash
working-directory: ${{ runner.workspace }}/_build
run: cmake --build . --config ${{ matrix.build_type }}
- name: test
shell: bash
working-directory: ${{ runner.workspace }}/_build
run: ctest -C ${{ matrix.build_type }} -VV
================================================
FILE: 3rd/benchmark-1.8.2/.github/workflows/test_bindings.yml
================================================
name: test-bindings
on:
push:
branches: [main]
pull_request:
branches: [main]
jobs:
python_bindings:
name: Test GBM Python bindings on ${{ matrix.os }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [ ubuntu-latest, macos-latest, windows-latest ]
steps:
- uses: actions/checkout@v3
- name: Set up Python
uses: actions/setup-python@v4
with:
python-version: 3.11
- name: Install GBM Python bindings on ${{ matrix.os}}
run:
python -m pip install wheel .
- name: Run bindings example on ${{ matrix.os }}
run:
python bindings/python/google_benchmark/example.py
================================================
FILE: 3rd/benchmark-1.8.2/.github/workflows/wheels.yml
================================================
name: Build and upload Python wheels
on:
workflow_dispatch:
release:
types:
- published
jobs:
build_sdist:
name: Build source distribution
runs-on: ubuntu-latest
steps:
- name: Check out repo
uses: actions/checkout@v3
- name: Install Python 3.11
uses: actions/setup-python@v4
with:
python-version: 3.11
- name: Build and check sdist
run: |
python setup.py sdist
- name: Upload sdist
uses: actions/upload-artifact@v3
with:
name: dist
path: dist/*.tar.gz
build_wheels:
name: Build Google Benchmark wheels on ${{ matrix.os }}
runs-on: ${{ matrix.os }}
strategy:
matrix:
os: [ubuntu-latest, macos-latest, windows-latest]
steps:
- name: Check out Google Benchmark
uses: actions/checkout@v3
- name: Set up QEMU
if: runner.os == 'Linux'
uses: docker/setup-qemu-action@v2
with:
platforms: all
- name: Build wheels on ${{ matrix.os }} using cibuildwheel
uses: pypa/cibuildwheel@v2.12.0
env:
CIBW_BUILD: 'cp38-* cp39-* cp310-* cp311-*'
CIBW_SKIP: "*-musllinux_*"
CIBW_TEST_SKIP: "*-macosx_arm64"
CIBW_ARCHS_LINUX: x86_64 aarch64
CIBW_ARCHS_MACOS: x86_64 arm64
CIBW_ARCHS_WINDOWS: AMD64
CIBW_BEFORE_ALL_LINUX: bash .github/install_bazel.sh
CIBW_TEST_COMMAND: python {project}/bindings/python/google_benchmark/example.py
- name: Upload Google Benchmark ${{ matrix.os }} wheels
uses: actions/upload-artifact@v3
with:
name: dist
path: ./wheelhouse/*.whl
pypi_upload:
name: Publish google-benchmark wheels to PyPI
needs: [build_sdist, build_wheels]
runs-on: ubuntu-latest
steps:
- uses: actions/download-artifact@v3
with:
name: dist
path: dist
- uses: pypa/gh-action-pypi-publish@v1.6.4
with:
user: __token__
password: ${{ secrets.PYPI_PASSWORD }}
================================================
FILE: 3rd/benchmark-1.8.2/.gitignore
================================================
*.a
*.so
*.so.?*
*.dll
*.exe
*.dylib
*.cmake
!/cmake/*.cmake
!/test/AssemblyTests.cmake
*~
*.swp
*.pyc
__pycache__
.DS_Store
# lcov
*.lcov
/lcov
# cmake files.
/Testing
CMakeCache.txt
CMakeFiles/
cmake_install.cmake
# makefiles.
Makefile
# in-source build.
bin/
lib/
/test/*_test
# exuberant ctags.
tags
# YouCompleteMe configuration.
.ycm_extra_conf.pyc
# ninja generated files.
.ninja_deps
.ninja_log
build.ninja
install_manifest.txt
rules.ninja
# bazel output symlinks.
bazel-*
# out-of-source build top-level folders.
build/
_build/
build*/
# in-source dependencies
/googletest/
# Visual Studio 2015/2017 cache/options directory
.vs/
CMakeSettings.json
# Visual Studio Code cache/options directory
.vscode/
# Python build stuff
dist/
*.egg-info*
================================================
FILE: 3rd/benchmark-1.8.2/.travis.yml
================================================
sudo: required
dist: trusty
language: cpp
matrix:
include:
- compiler: gcc
addons:
apt:
packages:
- lcov
env: COMPILER=g++ C_COMPILER=gcc BUILD_TYPE=Coverage
- compiler: gcc
addons:
apt:
packages:
- g++-multilib
- libc6:i386
env:
- COMPILER=g++
- C_COMPILER=gcc
- BUILD_TYPE=Debug
- BUILD_32_BITS=ON
- EXTRA_FLAGS="-m32"
- compiler: gcc
addons:
apt:
packages:
- g++-multilib
- libc6:i386
env:
- COMPILER=g++
- C_COMPILER=gcc
- BUILD_TYPE=Release
- BUILD_32_BITS=ON
- EXTRA_FLAGS="-m32"
- compiler: gcc
env:
- INSTALL_GCC6_FROM_PPA=1
- COMPILER=g++-6 C_COMPILER=gcc-6 BUILD_TYPE=Debug
- ENABLE_SANITIZER=1
- EXTRA_FLAGS="-fno-omit-frame-pointer -g -O2 -fsanitize=undefined,address -fuse-ld=gold"
# Clang w/ libc++
- compiler: clang
dist: xenial
addons:
apt:
packages:
clang-3.8
env:
- INSTALL_GCC6_FROM_PPA=1
- COMPILER=clang++-3.8 C_COMPILER=clang-3.8 BUILD_TYPE=Debug
- LIBCXX_BUILD=1
- EXTRA_CXX_FLAGS="-stdlib=libc++"
- compiler: clang
dist: xenial
addons:
apt:
packages:
clang-3.8
env:
- INSTALL_GCC6_FROM_PPA=1
- COMPILER=clang++-3.8 C_COMPILER=clang-3.8 BUILD_TYPE=Release
- LIBCXX_BUILD=1
- EXTRA_CXX_FLAGS="-stdlib=libc++"
# Clang w/ 32bit libc++
- compiler: clang
dist: xenial
addons:
apt:
packages:
- clang-3.8
- g++-multilib
- libc6:i386
env:
- INSTALL_GCC6_FROM_PPA=1
- COMPILER=clang++-3.8 C_COMPILER=clang-3.8 BUILD_TYPE=Debug
- LIBCXX_BUILD=1
- BUILD_32_BITS=ON
- EXTRA_FLAGS="-m32"
- EXTRA_CXX_FLAGS="-stdlib=libc++"
# Clang w/ 32bit libc++
- compiler: clang
dist: xenial
addons:
apt:
packages:
- clang-3.8
- g++-multilib
- libc6:i386
env:
- INSTALL_GCC6_FROM_PPA=1
- COMPILER=clang++-3.8 C_COMPILER=clang-3.8 BUILD_TYPE=Release
- LIBCXX_BUILD=1
- BUILD_32_BITS=ON
- EXTRA_FLAGS="-m32"
- EXTRA_CXX_FLAGS="-stdlib=libc++"
# Clang w/ libc++, ASAN, UBSAN
- compiler: clang
dist: xenial
addons:
apt:
packages:
clang-3.8
env:
- INSTALL_GCC6_FROM_PPA=1
- COMPILER=clang++-3.8 C_COMPILER=clang-3.8 BUILD_TYPE=Debug
- LIBCXX_BUILD=1 LIBCXX_SANITIZER="Undefined;Address"
- ENABLE_SANITIZER=1
- EXTRA_FLAGS="-g -O2 -fno-omit-frame-pointer -fsanitize=undefined,address -fno-sanitize-recover=all"
- EXTRA_CXX_FLAGS="-stdlib=libc++"
- UBSAN_OPTIONS=print_stacktrace=1
# Clang w/ libc++ and MSAN
- compiler: clang
dist: xenial
addons:
apt:
packages:
clang-3.8
env:
- INSTALL_GCC6_FROM_PPA=1
- COMPILER=clang++-3.8 C_COMPILER=clang-3.8 BUILD_TYPE=Debug
- LIBCXX_BUILD=1 LIBCXX_SANITIZER=MemoryWithOrigins
- ENABLE_SANITIZER=1
- EXTRA_FLAGS="-g -O2 -fno-omit-frame-pointer -fsanitize=memory -fsanitize-memory-track-origins"
- EXTRA_CXX_FLAGS="-stdlib=libc++"
# Clang w/ libc++ and MSAN
- compiler: clang
dist: xenial
addons:
apt:
packages:
clang-3.8
env:
- INSTALL_GCC6_FROM_PPA=1
- COMPILER=clang++-3.8 C_COMPILER=clang-3.8 BUILD_TYPE=RelWithDebInfo
- LIBCXX_BUILD=1 LIBCXX_SANITIZER=Thread
- ENABLE_SANITIZER=1
- EXTRA_FLAGS="-g -O2 -fno-omit-frame-pointer -fsanitize=thread -fno-sanitize-recover=all"
- EXTRA_CXX_FLAGS="-stdlib=libc++"
- os: osx
osx_image: xcode8.3
compiler: clang
env:
- COMPILER=clang++
- BUILD_TYPE=Release
- BUILD_32_BITS=ON
- EXTRA_FLAGS="-m32"
before_script:
- if [ -n "${LIBCXX_BUILD}" ]; then
source .libcxx-setup.sh;
fi
- if [ -n "${ENABLE_SANITIZER}" ]; then
export EXTRA_OPTIONS="-DBENCHMARK_ENABLE_ASSEMBLY_TESTS=OFF";
else
export EXTRA_OPTIONS="";
fi
- mkdir -p build && cd build
before_install:
- if [ -z "$BUILD_32_BITS" ]; then
export BUILD_32_BITS=OFF && echo disabling 32 bit build;
fi
- if [ -n "${INSTALL_GCC6_FROM_PPA}" ]; then
sudo add-apt-repository -y "ppa:ubuntu-toolchain-r/test";
sudo apt-get update --option Acquire::Retries=100 --option Acquire::http::Timeout="60";
fi
install:
- if [ -n "${INSTALL_GCC6_FROM_PPA}" ]; then
travis_wait sudo -E apt-get -yq --no-install-suggests --no-install-recommends install g++-6;
fi
- if [ "${TRAVIS_OS_NAME}" == "linux" -a "${BUILD_32_BITS}" == "OFF" ]; then
travis_wait sudo -E apt-get -y --no-install-suggests --no-install-recommends install llvm-3.9-tools;
sudo cp /usr/lib/llvm-3.9/bin/FileCheck /usr/local/bin/;
fi
- if [ "${BUILD_TYPE}" == "Coverage" -a "${TRAVIS_OS_NAME}" == "linux" ]; then
PATH=~/.local/bin:${PATH};
pip install --user --upgrade pip;
travis_wait pip install --user cpp-coveralls;
fi
- if [ "${C_COMPILER}" == "gcc-7" -a "${TRAVIS_OS_NAME}" == "osx" ]; then
rm -f /usr/local/include/c++;
brew update;
travis_wait brew install gcc@7;
fi
- if [ "${TRAVIS_OS_NAME}" == "linux" ]; then
sudo apt-get update -qq;
sudo apt-get install -qq unzip cmake3;
wget https://github.com/bazelbuild/bazel/releases/download/3.2.0/bazel-3.2.0-installer-linux-x86_64.sh --output-document bazel-installer.sh;
travis_wait sudo bash bazel-installer.sh;
fi
- if [ "${TRAVIS_OS_NAME}" == "osx" ]; then
curl -L -o bazel-installer.sh https://github.com/bazelbuild/bazel/releases/download/3.2.0/bazel-3.2.0-installer-darwin-x86_64.sh;
travis_wait sudo bash bazel-installer.sh;
fi
script:
- cmake -DCMAKE_C_COMPILER=${C_COMPILER} -DCMAKE_CXX_COMPILER=${COMPILER} -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DCMAKE_C_FLAGS="${EXTRA_FLAGS}" -DCMAKE_CXX_FLAGS="${EXTRA_FLAGS} ${EXTRA_CXX_FLAGS}" -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON -DBENCHMARK_BUILD_32_BITS=${BUILD_32_BITS} ${EXTRA_OPTIONS} ..
- make
- ctest -C ${BUILD_TYPE} --output-on-failure
- bazel test -c dbg --define google_benchmark.have_regex=posix --announce_rc --verbose_failures --test_output=errors --keep_going //test/...
after_success:
- if [ "${BUILD_TYPE}" == "Coverage" -a "${TRAVIS_OS_NAME}" == "linux" ]; then
coveralls --include src --include include --gcov-options '\-lp' --root .. --build-root .;
fi
================================================
FILE: 3rd/benchmark-1.8.2/.ycm_extra_conf.py
================================================
import os
import ycm_core
# These are the compilation flags that will be used in case there's no
# compilation database set (by default, one is not set).
# CHANGE THIS LIST OF FLAGS. YES, THIS IS THE DROID YOU HAVE BEEN LOOKING FOR.
flags = [
'-Wall',
'-Werror',
'-pedantic-errors',
'-std=c++0x',
'-fno-strict-aliasing',
'-O3',
'-DNDEBUG',
# ...and the same thing goes for the magic -x option which specifies the
# language that the files to be compiled are written in. This is mostly
# relevant for c++ headers.
# For a C project, you would set this to 'c' instead of 'c++'.
'-x', 'c++',
'-I', 'include',
'-isystem', '/usr/include',
'-isystem', '/usr/local/include',
]
# Set this to the absolute path to the folder (NOT the file!) containing the
# compile_commands.json file to use that instead of 'flags'. See here for
# more details: http://clang.llvm.org/docs/JSONCompilationDatabase.html
#
# Most projects will NOT need to set this to anything; you can just change the
# 'flags' list of compilation flags. Notice that YCM itself uses that approach.
compilation_database_folder = ''
if os.path.exists( compilation_database_folder ):
database = ycm_core.CompilationDatabase( compilation_database_folder )
else:
database = None
SOURCE_EXTENSIONS = [ '.cc' ]
def DirectoryOfThisScript():
return os.path.dirname( os.path.abspath( __file__ ) )
def MakeRelativePathsInFlagsAbsolute( flags, working_directory ):
if not working_directory:
return list( flags )
new_flags = []
make_next_absolute = False
path_flags = [ '-isystem', '-I', '-iquote', '--sysroot=' ]
for flag in flags:
new_flag = flag
if make_next_absolute:
make_next_absolute = False
if not flag.startswith( '/' ):
new_flag = os.path.join( working_directory, flag )
for path_flag in path_flags:
if flag == path_flag:
make_next_absolute = True
break
if flag.startswith( path_flag ):
path = flag[ len( path_flag ): ]
new_flag = path_flag + os.path.join( working_directory, path )
break
if new_flag:
new_flags.append( new_flag )
return new_flags
def IsHeaderFile( filename ):
extension = os.path.splitext( filename )[ 1 ]
return extension in [ '.h', '.hxx', '.hpp', '.hh' ]
def GetCompilationInfoForFile( filename ):
# The compilation_commands.json file generated by CMake does not have entries
# for header files. So we do our best by asking the db for flags for a
# corresponding source file, if any. If one exists, the flags for that file
# should be good enough.
if IsHeaderFile( filename ):
basename = os.path.splitext( filename )[ 0 ]
for extension in SOURCE_EXTENSIONS:
replacement_file = basename + extension
if os.path.exists( replacement_file ):
compilation_info = database.GetCompilationInfoForFile(
replacement_file )
if compilation_info.compiler_flags_:
return compilation_info
return None
return database.GetCompilationInfoForFile( filename )
def FlagsForFile( filename, **kwargs ):
if database:
# Bear in mind that compilation_info.compiler_flags_ does NOT return a
# python list, but a "list-like" StringVec object
compilation_info = GetCompilationInfoForFile( filename )
if not compilation_info:
return None
final_flags = MakeRelativePathsInFlagsAbsolute(
compilation_info.compiler_flags_,
compilation_info.compiler_working_dir_ )
else:
relative_to = DirectoryOfThisScript()
final_flags = MakeRelativePathsInFlagsAbsolute( flags, relative_to )
return {
'flags': final_flags,
'do_cache': True
}
================================================
FILE: 3rd/benchmark-1.8.2/AUTHORS
================================================
# This is the official list of benchmark authors for copyright purposes.
# This file is distinct from the CONTRIBUTORS files.
# See the latter for an explanation.
#
# Names should be added to this file as:
# Name or Organization <email address>
# The email address is not required for organizations.
#
# Please keep the list sorted.
Albert Pretorius <pretoalb@gmail.com>
Alex Steele <steeleal123@gmail.com>
Andriy Berestovskyy <berestovskyy@gmail.com>
Arne Beer <arne@twobeer.de>
Carto
Cezary Skrzyński <czars1988@gmail.com>
Christian Wassermann <christian_wassermann@web.de>
Christopher Seymour <chris.j.seymour@hotmail.com>
Colin Braley <braley.colin@gmail.com>
Daniel Harvey <danielharvey458@gmail.com>
David Coeurjolly <david.coeurjolly@liris.cnrs.fr>
Deniz Evrenci <denizevrenci@gmail.com>
Dirac Research
Dominik Czarnota <dominik.b.czarnota@gmail.com>
Dominik Korman <kormandominik@gmail.com>
Donald Aingworth <donalds_junk_mail@yahoo.com>
Eric Backus <eric_backus@alum.mit.edu>
Eric Fiselier <eric@efcs.ca>
Eugene Zhuk <eugene.zhuk@gmail.com>
Evgeny Safronov <division494@gmail.com>
Federico Ficarelli <federico.ficarelli@gmail.com>
Felix Homann <linuxaudio@showlabor.de>
Gergő Szitár <szitar.gergo@gmail.com>
Google Inc.
Henrique Bucher <hbucher@gmail.com>
International Business Machines Corporation
Ismael Jimenez Martinez <ismael.jimenez.martinez@gmail.com>
Jern-Kuan Leong <jernkuan@gmail.com>
JianXiong Zhou <zhoujianxiong2@gmail.com>
Joao Paulo Magalhaes <joaoppmagalhaes@gmail.com>
Jordan Williams <jwillikers@protonmail.com>
Jussi Knuuttila <jussi.knuuttila@gmail.com>
Kaito Udagawa <umireon@gmail.com>
Kishan Kumar <kumar.kishan@outlook.com>
Lei Xu <eddyxu@gmail.com>
Marcel Jacobse <mjacobse@uni-bremen.de>
Matt Clarkson <mattyclarkson@gmail.com>
Maxim Vafin <maxvafin@gmail.com>
Mike Apodaca <gatorfax@gmail.com>
MongoDB Inc.
Nick Hutchinson <nshutchinson@gmail.com>
Norman Heino <norman.heino@gmail.com>
Oleksandr Sochka <sasha.sochka@gmail.com>
Ori Livneh <ori.livneh@gmail.com>
Paul Redmond <paul.redmond@gmail.com>
Raghu Raja <raghu@enfabrica.net>
Radoslav Yovchev <radoslav.tm@gmail.com>
Rainer Orth <ro@cebitec.uni-bielefeld.de>
Roman Lebedev <lebedev.ri@gmail.com>
Sayan Bhattacharjee <aero.sayan@gmail.com>
Shapr3D <google-contributors@shapr3d.com>
Shuo Chen <chenshuo@chenshuo.com>
Staffan Tjernstrom <staffantj@gmail.com>
Steinar H. Gunderson <sgunderson@bigfoot.com>
Stripe, Inc.
Tobias Schmidt <tobias.schmidt@in.tum.de>
Yixuan Qiu <yixuanq@gmail.com>
Yusuke Suzuki <utatane.tea@gmail.com>
Zbigniew Skowron <zbychs@gmail.com>
Min-Yih Hsu <yihshyng223@gmail.com>
================================================
FILE: 3rd/benchmark-1.8.2/BUILD.bazel
================================================
licenses(["notice"])
config_setting(
name = "qnx",
constraint_values = ["@platforms//os:qnx"],
values = {
"cpu": "x64_qnx",
},
visibility = [":__subpackages__"],
)
config_setting(
name = "windows",
constraint_values = ["@platforms//os:windows"],
values = {
"cpu": "x64_windows",
},
visibility = [":__subpackages__"],
)
config_setting(
name = "macos",
constraint_values = ["@platforms//os:macos"],
visibility = ["//visibility:public"],
)
config_setting(
name = "perfcounters",
define_values = {
"pfm": "1",
},
visibility = [":__subpackages__"],
)
cc_library(
name = "benchmark",
srcs = glob(
[
"src/*.cc",
"src/*.h",
],
exclude = ["src/benchmark_main.cc"],
),
hdrs = [
"include/benchmark/benchmark.h",
"include/benchmark/export.h",
],
linkopts = select({
":windows": ["-DEFAULTLIB:shlwapi.lib"],
"//conditions:default": ["-pthread"],
}),
copts = select({
":windows": [],
"//conditions:default": ["-Werror=old-style-cast"],
}),
strip_include_prefix = "include",
visibility = ["//visibility:public"],
# Only static linking is allowed; no .so will be produced.
# Using `defines` (i.e. not `local_defines`) means that no
# dependent rules need to bother about defining the macro.
linkstatic = True,
defines = [
"BENCHMARK_STATIC_DEFINE",
] + select({
":perfcounters": ["HAVE_LIBPFM"],
"//conditions:default": [],
}),
deps = select({
":perfcounters": ["@libpfm//:libpfm"],
"//conditions:default": [],
}),
)
cc_library(
name = "benchmark_main",
srcs = ["src/benchmark_main.cc"],
hdrs = ["include/benchmark/benchmark.h", "include/benchmark/export.h"],
strip_include_prefix = "include",
visibility = ["//visibility:public"],
deps = [":benchmark"],
)
cc_library(
name = "benchmark_internal_headers",
hdrs = glob(["src/*.h"]),
visibility = ["//test:__pkg__"],
)
================================================
FILE: 3rd/benchmark-1.8.2/CMakeLists.txt
================================================
# Require CMake 3.10. If available, use the policies up to CMake 3.22.
cmake_minimum_required (VERSION 3.10...3.22)
project (benchmark VERSION 1.8.2 LANGUAGES CXX)
option(BENCHMARK_ENABLE_TESTING "Enable testing of the benchmark library." OFF)
option(BENCHMARK_ENABLE_EXCEPTIONS "Enable the use of exceptions in the benchmark library." ON)
option(BENCHMARK_ENABLE_LTO "Enable link time optimisation of the benchmark library." OFF)
option(BENCHMARK_USE_LIBCXX "Build and test using libc++ as the standard library." OFF)
option(BENCHMARK_ENABLE_WERROR "Build Release candidates with -Werror." ON)
option(BENCHMARK_FORCE_WERROR "Build Release candidates with -Werror regardless of compiler issues." OFF)
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "PGI")
# PGC++ maybe reporting false positives.
set(BENCHMARK_ENABLE_WERROR OFF)
endif()
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "NVHPC")
set(BENCHMARK_ENABLE_WERROR OFF)
endif()
if(BENCHMARK_FORCE_WERROR)
set(BENCHMARK_ENABLE_WERROR ON)
endif(BENCHMARK_FORCE_WERROR)
if(NOT MSVC)
option(BENCHMARK_BUILD_32_BITS "Build a 32 bit version of the library." OFF)
else()
set(BENCHMARK_BUILD_32_BITS OFF CACHE BOOL "Build a 32 bit version of the library - unsupported when using MSVC)" FORCE)
endif()
option(BENCHMARK_ENABLE_INSTALL "Enable installation of benchmark. (Projects embedding benchmark may want to turn this OFF.)" ON)
option(BENCHMARK_ENABLE_DOXYGEN "Build documentation with Doxygen." OFF)
option(BENCHMARK_INSTALL_DOCS "Enable installation of documentation." ON)
# Allow unmet dependencies to be met using CMake's ExternalProject mechanics, which
# may require downloading the source code.
option(BENCHMARK_DOWNLOAD_DEPENDENCIES "Allow the downloading and in-tree building of unmet dependencies" OFF)
# This option can be used to disable building and running unit tests which depend on gtest
# in cases where it is not possible to build or find a valid version of gtest.
option(BENCHMARK_ENABLE_GTEST_TESTS "Enable building the unit tests which depend on gtest" OFF)
option(BENCHMARK_USE_BUNDLED_GTEST "Use bundled GoogleTest. If disabled, the find_package(GTest) will be used." OFF)
option(BENCHMARK_ENABLE_LIBPFM "Enable performance counters provided by libpfm" OFF)
# Export only public symbols
set(CMAKE_CXX_VISIBILITY_PRESET hidden)
set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
if(MSVC)
# As of CMake 3.18, CMAKE_SYSTEM_PROCESSOR is not set properly for MSVC and
# cross-compilation (e.g. Host=x86_64, target=aarch64) requires using the
# undocumented, but working variable.
# See https://gitlab.kitware.com/cmake/cmake/-/issues/15170
set(CMAKE_SYSTEM_PROCESSOR ${MSVC_CXX_ARCHITECTURE_ID})
if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "ARM")
set(CMAKE_CROSSCOMPILING TRUE)
endif()
endif()
set(ENABLE_ASSEMBLY_TESTS_DEFAULT OFF)
function(should_enable_assembly_tests)
if(CMAKE_BUILD_TYPE)
string(TOLOWER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_LOWER)
if (${CMAKE_BUILD_TYPE_LOWER} MATCHES "coverage")
# FIXME: The --coverage flag needs to be removed when building assembly
# tests for this to work.
return()
endif()
endif()
if (MSVC)
return()
elseif(NOT CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
return()
elseif(NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
# FIXME: Make these work on 32 bit builds
return()
elseif(BENCHMARK_BUILD_32_BITS)
# FIXME: Make these work on 32 bit builds
return()
endif()
find_program(LLVM_FILECHECK_EXE FileCheck)
if (LLVM_FILECHECK_EXE)
set(LLVM_FILECHECK_EXE "${LLVM_FILECHECK_EXE}" CACHE PATH "llvm filecheck" FORCE)
message(STATUS "LLVM FileCheck Found: ${LLVM_FILECHECK_EXE}")
else()
message(STATUS "Failed to find LLVM FileCheck")
return()
endif()
set(ENABLE_ASSEMBLY_TESTS_DEFAULT ON PARENT_SCOPE)
endfunction()
should_enable_assembly_tests()
# This option disables the building and running of the assembly verification tests
option(BENCHMARK_ENABLE_ASSEMBLY_TESTS "Enable building and running the assembly tests"
${ENABLE_ASSEMBLY_TESTS_DEFAULT})
# Make sure we can import out CMake functions
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules")
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
# Read the git tags to determine the project version
include(GetGitVersion)
get_git_version(GIT_VERSION)
# If no git version can be determined, use the version
# from the project() command
if ("${GIT_VERSION}" STREQUAL "0.0.0")
set(VERSION "${benchmark_VERSION}")
else()
set(VERSION "${GIT_VERSION}")
endif()
# Tell the user what versions we are using
message(STATUS "Google Benchmark version: ${VERSION}")
# The version of the libraries
set(GENERIC_LIB_VERSION ${VERSION})
string(SUBSTRING ${VERSION} 0 1 GENERIC_LIB_SOVERSION)
# Import our CMake modules
include(AddCXXCompilerFlag)
include(CheckCXXCompilerFlag)
include(CheckLibraryExists)
include(CXXFeatureCheck)
check_library_exists(rt shm_open "" HAVE_LIB_RT)
if (BENCHMARK_BUILD_32_BITS)
add_required_cxx_compiler_flag(-m32)
endif()
if (MSVC)
set(BENCHMARK_CXX_STANDARD 14)
else()
set(BENCHMARK_CXX_STANDARD 11)
endif()
set(CMAKE_CXX_STANDARD ${BENCHMARK_CXX_STANDARD})
set(CMAKE_CXX_STANDARD_REQUIRED YES)
set(CMAKE_CXX_EXTENSIONS OFF)
if (MSVC)
# Turn compiler warnings up to 11
string(REGEX REPLACE "[-/]W[1-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
add_definitions(-D_CRT_SECURE_NO_WARNINGS)
if (NOT BENCHMARK_ENABLE_EXCEPTIONS)
add_cxx_compiler_flag(-EHs-)
add_cxx_compiler_flag(-EHa-)
add_definitions(-D_HAS_EXCEPTIONS=0)
endif()
# Link time optimisation
if (BENCHMARK_ENABLE_LTO)
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GL")
set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "${CMAKE_STATIC_LINKER_FLAGS_RELEASE} /LTCG")
set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /LTCG")
set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LTCG")
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /GL")
string(REGEX REPLACE "[-/]INCREMENTAL" "/INCREMENTAL:NO" CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO}")
set(CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO} /LTCG")
string(REGEX REPLACE "[-/]INCREMENTAL" "/INCREMENTAL:NO" CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO}")
set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} /LTCG")
string(REGEX REPLACE "[-/]INCREMENTAL" "/INCREMENTAL:NO" CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO}")
set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} /LTCG")
set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} /GL")
set(CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL "${CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL} /LTCG")
set(CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL "${CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL} /LTCG")
set(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL} /LTCG")
endif()
else()
# Turn compiler warnings up to 11
add_cxx_compiler_flag(-Wall)
add_cxx_compiler_flag(-Wextra)
add_cxx_compiler_flag(-Wshadow)
add_cxx_compiler_flag(-Wfloat-equal)
add_cxx_compiler_flag(-Wold-style-cast)
if(BENCHMARK_ENABLE_WERROR)
add_cxx_compiler_flag(-Werror)
endif()
if (NOT BENCHMARK_ENABLE_TESTING)
# Disable warning when compiling tests as gtest does not use 'override'.
add_cxx_compiler_flag(-Wsuggest-override)
endif()
add_cxx_compiler_flag(-pedantic)
add_cxx_compiler_flag(-pedantic-errors)
add_cxx_compiler_flag(-Wshorten-64-to-32)
add_cxx_compiler_flag(-fstrict-aliasing)
# Disable warnings regarding deprecated parts of the library while building
# and testing those parts of the library.
add_cxx_compiler_flag(-Wno-deprecated-declarations)
if (CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
# Intel silently ignores '-Wno-deprecated-declarations',
# warning no. 1786 must be explicitly disabled.
# See #631 for rationale.
add_cxx_compiler_flag(-wd1786)
endif()
# Disable deprecation warnings for release builds (when -Werror is enabled).
if(BENCHMARK_ENABLE_WERROR)
add_cxx_compiler_flag(-Wno-deprecated)
endif()
if (NOT BENCHMARK_ENABLE_EXCEPTIONS)
add_cxx_compiler_flag(-fno-exceptions)
endif()
if (HAVE_CXX_FLAG_FSTRICT_ALIASING)
if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "Intel") #ICC17u2: Many false positives for Wstrict-aliasing
add_cxx_compiler_flag(-Wstrict-aliasing)
endif()
endif()
# ICC17u2: overloaded virtual function "benchmark::Fixture::SetUp" is only partially overridden
# (because of deprecated overload)
add_cxx_compiler_flag(-wd654)
add_cxx_compiler_flag(-Wthread-safety)
if (HAVE_CXX_FLAG_WTHREAD_SAFETY)
cxx_feature_check(THREAD_SAFETY_ATTRIBUTES "-DINCLUDE_DIRECTORIES=${PROJECT_SOURCE_DIR}/include")
endif()
# On most UNIX like platforms g++ and clang++ define _GNU_SOURCE as a
# predefined macro, which turns on all of the wonderful libc extensions.
# However g++ doesn't do this in Cygwin so we have to define it ourselves
# since we depend on GNU/POSIX/BSD extensions.
if (CYGWIN)
add_definitions(-D_GNU_SOURCE=1)
endif()
if (QNXNTO)
add_definitions(-D_QNX_SOURCE)
endif()
# Link time optimisation
if (BENCHMARK_ENABLE_LTO)
add_cxx_compiler_flag(-flto)
add_cxx_compiler_flag(-Wno-lto-type-mismatch)
if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
find_program(GCC_AR gcc-ar)
if (GCC_AR)
set(CMAKE_AR ${GCC_AR})
endif()
find_program(GCC_RANLIB gcc-ranlib)
if (GCC_RANLIB)
set(CMAKE_RANLIB ${GCC_RANLIB})
endif()
elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
include(llvm-toolchain)
endif()
endif()
# Coverage build type
set(BENCHMARK_CXX_FLAGS_COVERAGE "${CMAKE_CXX_FLAGS_DEBUG}"
CACHE STRING "Flags used by the C++ compiler during coverage builds."
FORCE)
set(BENCHMARK_EXE_LINKER_FLAGS_COVERAGE "${CMAKE_EXE_LINKER_FLAGS_DEBUG}"
CACHE STRING "Flags used for linking binaries during coverage builds."
FORCE)
set(BENCHMARK_SHARED_LINKER_FLAGS_COVERAGE "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}"
CACHE STRING "Flags used by the shared libraries linker during coverage builds."
FORCE)
mark_as_advanced(
BENCHMARK_CXX_FLAGS_COVERAGE
BENCHMARK_EXE_LINKER_FLAGS_COVERAGE
BENCHMARK_SHARED_LINKER_FLAGS_COVERAGE)
set(CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING
"Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel Coverage.")
add_cxx_compiler_flag(--coverage COVERAGE)
endif()
if (BENCHMARK_USE_LIBCXX)
if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
add_cxx_compiler_flag(-stdlib=libc++)
elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR
"${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
add_cxx_compiler_flag(-nostdinc++)
message(WARNING "libc++ header path must be manually specified using CMAKE_CXX_FLAGS")
# Adding -nodefaultlibs directly to CMAKE_<TYPE>_LINKER_FLAGS will break
# configuration checks such as 'find_package(Threads)'
list(APPEND BENCHMARK_CXX_LINKER_FLAGS -nodefaultlibs)
# -lc++ cannot be added directly to CMAKE_<TYPE>_LINKER_FLAGS because
# linker flags appear before all linker inputs and -lc++ must appear after.
list(APPEND BENCHMARK_CXX_LIBRARIES c++)
else()
message(FATAL_ERROR "-DBENCHMARK_USE_LIBCXX:BOOL=ON is not supported for compiler")
endif()
endif(BENCHMARK_USE_LIBCXX)
set(EXTRA_CXX_FLAGS "")
if (WIN32 AND "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
# Clang on Windows fails to compile the regex feature check under C++11
set(EXTRA_CXX_FLAGS "-DCMAKE_CXX_STANDARD=14")
endif()
# C++ feature checks
# Determine the correct regular expression engine to use
cxx_feature_check(STD_REGEX ${EXTRA_CXX_FLAGS})
cxx_feature_check(GNU_POSIX_REGEX ${EXTRA_CXX_FLAGS})
cxx_feature_check(POSIX_REGEX ${EXTRA_CXX_FLAGS})
if(NOT HAVE_STD_REGEX AND NOT HAVE_GNU_POSIX_REGEX AND NOT HAVE_POSIX_REGEX)
message(FATAL_ERROR "Failed to determine the source files for the regular expression backend")
endif()
if (NOT BENCHMARK_ENABLE_EXCEPTIONS AND HAVE_STD_REGEX
AND NOT HAVE_GNU_POSIX_REGEX AND NOT HAVE_POSIX_REGEX)
message(WARNING "Using std::regex with exceptions disabled is not fully supported")
endif()
cxx_feature_check(STEADY_CLOCK)
# Ensure we have pthreads
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
cxx_feature_check(PTHREAD_AFFINITY)
if (BENCHMARK_ENABLE_LIBPFM)
find_package(PFM)
endif()
# Set up directories
include_directories(${PROJECT_SOURCE_DIR}/include)
# Build the targets
add_subdirectory(src)
if (BENCHMARK_ENABLE_TESTING)
enable_testing()
if (BENCHMARK_ENABLE_GTEST_TESTS AND
NOT (TARGET gtest AND TARGET gtest_main AND
TARGET gmock AND TARGET gmock_main))
if (BENCHMARK_USE_BUNDLED_GTEST)
include(GoogleTest)
else()
find_package(GTest CONFIG REQUIRED)
add_library(gtest ALIAS GTest::gtest)
add_library(gtest_main ALIAS GTest::gtest_main)
add_library(gmock ALIAS GTest::gmock)
add_library(gmock_main ALIAS GTest::gmock_main)
endif()
endif()
add_subdirectory(test)
endif()
================================================
FILE: 3rd/benchmark-1.8.2/CONTRIBUTING.md
================================================
# How to contribute #
We'd love to accept your patches and contributions to this project. There are
a just a few small guidelines you need to follow.
## Contributor License Agreement ##
Contributions to any Google project must be accompanied by a Contributor
License Agreement. This is not a copyright **assignment**, it simply gives
Google permission to use and redistribute your contributions as part of the
project.
* If you are an individual writing original source code and you're sure you
own the intellectual property, then you'll need to sign an [individual
CLA][].
* If you work for a company that wants to allow you to contribute your work,
then you'll need to sign a [corporate CLA][].
You generally only need to submit a CLA once, so if you've already submitted
one (even if it was for a different project), you probably don't need to do it
again.
[individual CLA]: https://developers.google.com/open-source/cla/individual
[corporate CLA]: https://developers.google.com/open-source/cla/corporate
Once your CLA is submitted (or if you already submitted one for
another Google project), make a commit adding yourself to the
[AUTHORS][] and [CONTRIBUTORS][] files. This commit can be part
of your first [pull request][].
[AUTHORS]: AUTHORS
[CONTRIBUTORS]: CONTRIBUTORS
## Submitting a patch ##
1. It's generally best to start by opening a new issue describing the bug or
feature you're intending to fix. Even if you think it's relatively minor,
it's helpful to know what people are working on. Mention in the initial
issue that you are planning to work on that bug or feature so that it can
be assigned to you.
1. Follow the normal process of [forking][] the project, and setup a new
branch to work in. It's important that each group of changes be done in
separate branches in order to ensure that a pull request only includes the
commits related to that bug or feature.
1. Do your best to have [well-formed commit messages][] for each change.
This provides consistency throughout the project, and ensures that commit
messages are able to be formatted properly by various git tools.
1. Finally, push the commits to your fork and submit a [pull request][].
[forking]: https://help.github.com/articles/fork-a-repo
[well-formed commit messages]: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html
[pull request]: https://help.github.com/articles/creating-a-pull-request
================================================
FILE: 3rd/benchmark-1.8.2/CONTRIBUTORS
================================================
# People who have agreed to one of the CLAs and can contribute patches.
# The AUTHORS file lists the copyright holders; this file
# lists people. For example, Google employees are listed here
# but not in AUTHORS, because Google holds the copyright.
#
# Names should be added to this file only after verifying that
# the individual or the individual's organization has agreed to
# the appropriate Contributor License Agreement, found here:
#
# https://developers.google.com/open-source/cla/individual
# https://developers.google.com/open-source/cla/corporate
#
# The agreement for individuals can be filled out on the web.
#
# When adding J Random Contributor's name to this file,
# either J's name or J's organization's name should be
# added to the AUTHORS file, depending on whether the
# individual or corporate CLA was used.
#
# Names should be added to this file as:
# Name <email address>
#
# Please keep the list sorted.
Abhina Sreeskantharajan <abhina.sreeskantharajan@ibm.com>
Albert Pretorius <pretoalb@gmail.com>
Alex Steele <steelal123@gmail.com>
Andriy Berestovskyy <berestovskyy@gmail.com>
Arne Beer <arne@twobeer.de>
Bátor Tallér <bator.taller@shapr3d.com>
Billy Robert O'Neal III <billy.oneal@gmail.com> <bion@microsoft.com>
Cezary Skrzyński <czars1988@gmail.com>
Chris Kennelly <ckennelly@google.com> <ckennelly@ckennelly.com>
Christian Wassermann <christian_wassermann@web.de>
Christopher Seymour <chris.j.seymour@hotmail.com>
Colin Braley <braley.colin@gmail.com>
Cyrille Faucheux <cyrille.faucheux@gmail.com>
Daniel Harvey <danielharvey458@gmail.com>
David Coeurjolly <david.coeurjolly@liris.cnrs.fr>
Deniz Evrenci <denizevrenci@gmail.com>
Dominic Hamon <dma@stripysock.com> <dominic@google.com>
Dominik Czarnota <dominik.b.czarnota@gmail.com>
Dominik Korman <kormandominik@gmail.com>
Donald Aingworth <donalds_junk_mail@yahoo.com>
Eric Backus <eric_backus@alum.mit.edu>
Eric Fiselier <eric@efcs.ca>
Eugene Zhuk <eugene.zhuk@gmail.com>
Evgeny Safronov <division494@gmail.com>
Fanbo Meng <fanbo.meng@ibm.com>
Federico Ficarelli <federico.ficarelli@gmail.com>
Felix Homann <linuxaudio@showlabor.de>
Geoffrey Martin-Noble <gcmn@google.com> <gmngeoffrey@gmail.com>
Gergő Szitár <szitar.gergo@gmail.com>
Hannes Hauswedell <h2@fsfe.org>
Henrique Bucher <hbucher@gmail.com>
Ismael Jimenez Martinez <ismael.jimenez.martinez@gmail.com>
Jern-Kuan Leong <jernkuan@gmail.com>
JianXiong Zhou <zhoujianxiong2@gmail.com>
Joao Paulo Magalhaes <joaoppmagalhaes@gmail.com>
John Millikin <jmillikin@stripe.com>
Jordan Williams <jwillikers@protonmail.com>
Jussi Knuuttila <jussi.knuuttila@gmail.com>
Kai Wolf <kai.wolf@gmail.com>
Kaito Udagawa <umireon@gmail.com>
Kishan Kumar <kumar.kishan@outlook.com>
Lei Xu <eddyxu@gmail.com>
Marcel Jacobse <mjacobse@uni-bremen.de>
Matt Clarkson <mattyclarkson@gmail.com>
Maxim Vafin <maxvafin@gmail.com>
Mike Apodaca <gatorfax@gmail.com>
Nick Hutchinson <nshutchinson@gmail.com>
Norman Heino <norman.heino@gmail.com>
Oleksandr Sochka <sasha.sochka@gmail.com>
Ori Livneh <ori.livneh@gmail.com>
Pascal Leroy <phl@google.com>
Paul Redmond <paul.redmond@gmail.com>
Pierre Phaneuf <pphaneuf@google.com>
Radoslav Yovchev <radoslav.tm@gmail.com>
Rainer Orth <ro@cebitec.uni-bielefeld.de>
Raghu Raja <raghu@enfabrica.net>
Raul Marin <rmrodriguez@cartodb.com>
Ray Glover <ray.glover@uk.ibm.com>
Robert Guo <robert.guo@mongodb.com>
Roman Lebedev <lebedev.ri@gmail.com>
Sayan Bhattacharjee <aero.sayan@gmail.com>
Shuo Chen <chenshuo@chenshuo.com>
Steven Wan <wan.yu@ibm.com>
Tobias Schmidt <tobias.schmidt@in.tum.de>
Tobias Ulvgård <tobias.ulvgard@dirac.se>
Tom Madams <tom.ej.madams@gmail.com> <tmadams@google.com>
Yixuan Qiu <yixuanq@gmail.com>
Yusuke Suzuki <utatane.tea@gmail.com>
Zbigniew Skowron <zbychs@gmail.com>
Min-Yih Hsu <yihshyng223@gmail.com>
================================================
FILE: 3rd/benchmark-1.8.2/LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: 3rd/benchmark-1.8.2/MODULE.bazel
================================================
module(name = "com_github_google_benchmark", version="1.8.2")
bazel_dep(name = "bazel_skylib", version = "1.4.1")
bazel_dep(name = "platforms", version = "0.0.6")
bazel_dep(name = "rules_foreign_cc", version = "0.9.0")
bazel_dep(name = "rules_cc", version = "0.0.6")
bazel_dep(name = "rules_python", version = "0.23.1")
bazel_dep(name = "googletest", version = "1.12.1", repo_name = "com_google_googletest")
bazel_dep(name = "libpfm", version = "4.11.0")
# Register a toolchain for Python 3.9 to be able to build numpy. Python
# versions >=3.10 are problematic.
# A second reason for this is to be able to build Python hermetically instead
# of relying on the changing default version from rules_python.
python = use_extension("@rules_python//python/extensions:python.bzl", "python")
python.toolchain(python_version = "3.9")
# Extract the interpreter from the hermetic toolchain above, so we can use that
# instead of the system interpreter for the pip compiplation step below.
interpreter = use_extension("@rules_python//python/extensions:interpreter.bzl", "interpreter")
interpreter.install(
name = "interpreter",
python_name = "python_3_9",
)
use_repo(interpreter, "interpreter")
pip = use_extension("@rules_python//python/extensions:pip.bzl", "pip")
pip.parse(
name="tools_pip_deps",
incompatible_generate_aliases = True,
python_interpreter_target="@interpreter//:python",
requirements_lock="//tools:requirements.txt")
use_repo(pip, "tools_pip_deps")
================================================
FILE: 3rd/benchmark-1.8.2/README.md
================================================
# Benchmark
[](https://github.com/google/benchmark/actions?query=workflow%3Abuild-and-test)
[](https://github.com/google/benchmark/actions/workflows/bazel.yml)
[](https://github.com/google/benchmark/actions?query=workflow%3Apylint)
[](https://github.com/google/benchmark/actions?query=workflow%3Atest-bindings)
[](https://coveralls.io/r/google/benchmark)
[](https://discord.gg/cz7UX7wKC2)
A library to benchmark code snippets, similar to unit tests. Example:
```c++
#include <benchmark/benchmark.h>
static void BM_SomeFunction(benchmark::State& state) {
// Perform setup here
for (auto _ : state) {
// This code gets timed
SomeFunction();
}
}
// Register the function as a benchmark
BENCHMARK(BM_SomeFunction);
// Run the benchmark
BENCHMARK_MAIN();
```
## Getting Started
To get started, see [Requirements](#requirements) and
[Installation](#installation). See [Usage](#usage) for a full example and the
[User Guide](docs/user_guide.md) for a more comprehensive feature overview.
It may also help to read the [Google Test documentation](https://github.com/google/googletest/blob/main/docs/primer.md)
as some of the structural aspects of the APIs are similar.
## Resources
[Discussion group](https://groups.google.com/d/forum/benchmark-discuss)
IRC channels:
* [libera](https://libera.chat) #benchmark
[Additional Tooling Documentation](docs/tools.md)
[Assembly Testing Documentation](docs/AssemblyTests.md)
[Building and installing Python bindings](docs/python_bindings.md)
## Requirements
The library can be used with C++03. However, it requires C++11 to build,
including compiler and standard library support.
The following minimum versions are required to build the library:
* GCC 4.8
* Clang 3.4
* Visual Studio 14 2015
* Intel 2015 Update 1
See [Platform-Specific Build Instructions](docs/platform_specific_build_instructions.md).
## Installation
This describes the installation process using cmake. As pre-requisites, you'll
need git and cmake installed.
_See [dependencies.md](docs/dependencies.md) for more details regarding supported
versions of build tools._
```bash
# Check out the library.
$ git clone https://github.com/google/benchmark.git
# Go to the library root directory
$ cd benchmark
# Make a build directory to place the build output.
$ cmake -E make_directory "build"
# Generate build system files with cmake, and download any dependencies.
$ cmake -E chdir "build" cmake -DBENCHMARK_DOWNLOAD_DEPENDENCIES=on -DCMAKE_BUILD_TYPE=Release ../
# or, starting with CMake 3.13, use a simpler form:
# cmake -DCMAKE_BUILD_TYPE=Release -S . -B "build"
# Build the library.
$ cmake --build "build" --config Release
```
This builds the `benchmark` and `benchmark_main` libraries and tests.
On a unix system, the build directory should now look something like this:
```
/benchmark
/build
/src
/libbenchmark.a
/libbenchmark_main.a
/test
...
```
Next, you can run the tests to check the build.
```bash
$ cmake -E chdir "build" ctest --build-config Release
```
If you want to install the library globally, also run:
```
sudo cmake --build "build" --config Release --target install
```
Note that Google Benchmark requires Google Test to build and run the tests. This
dependency can be provided two ways:
* Checkout the Google Test sources into `benchmark/googletest`.
* Otherwise, if `-DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON` is specified during
configuration as above, the library will automatically download and build
any required dependencies.
If you do not wish to build and run the tests, add `-DBENCHMARK_ENABLE_GTEST_TESTS=OFF`
to `CMAKE_ARGS`.
### Debug vs Release
By default, benchmark builds as a debug library. You will see a warning in the
output when this is the case. To build it as a release library instead, add
`-DCMAKE_BUILD_TYPE=Release` when generating the build system files, as shown
above. The use of `--config Release` in build commands is needed to properly
support multi-configuration tools (like Visual Studio for example) and can be
skipped for other build systems (like Makefile).
To enable link-time optimisation, also add `-DBENCHMARK_ENABLE_LTO=true` when
generating the build system files.
If you are using gcc, you might need to set `GCC_AR` and `GCC_RANLIB` cmake
cache variables, if autodetection fails.
If you are using clang, you may need to set `LLVMAR_EXECUTABLE`,
`LLVMNM_EXECUTABLE` and `LLVMRANLIB_EXECUTABLE` cmake cache variables.
To enable sanitizer checks (eg., `asan` and `tsan`), add:
```
-DCMAKE_C_FLAGS="-g -O2 -fno-omit-frame-pointer -fsanitize=address -fsanitize=thread -fno-sanitize-recover=all"
-DCMAKE_CXX_FLAGS="-g -O2 -fno-omit-frame-pointer -fsanitize=address -fsanitize=thread -fno-sanitize-recover=all "
```
### Stable and Experimental Library Versions
The main branch contains the latest stable version of the benchmarking library;
the API of which can be considered largely stable, with source breaking changes
being made only upon the release of a new major version.
Newer, experimental, features are implemented and tested on the
[`v2` branch](https://github.com/google/benchmark/tree/v2). Users who wish
to use, test, and provide feedback on the new features are encouraged to try
this branch. However, this branch provides no stability guarantees and reserves
the right to change and break the API at any time.
## Usage
### Basic usage
Define a function that executes the code to measure, register it as a benchmark
function using the `BENCHMARK` macro, and ensure an appropriate `main` function
is available:
```c++
#include <benchmark/benchmark.h>
static void BM_StringCreation(benchmark::State& state) {
for (auto _ : state)
std::string empty_string;
}
// Register the function as a benchmark
BENCHMARK(BM_StringCreation);
// Define another benchmark
static void BM_StringCopy(benchmark::State& state) {
std::string x = "hello";
for (auto _ : state)
std::string copy(x);
}
BENCHMARK(BM_StringCopy);
BENCHMARK_MAIN();
```
To run the benchmark, compile and link against the `benchmark` library
(libbenchmark.a/.so). If you followed the build steps above, this library will
be under the build directory you created.
```bash
# Example on linux after running the build steps above. Assumes the
# `benchmark` and `build` directories are under the current directory.
$ g++ mybenchmark.cc -std=c++11 -isystem benchmark/include \
-Lbenchmark/build/src -lbenchmark -lpthread -o mybenchmark
```
Alternatively, link against the `benchmark_main` library and remove
`BENCHMARK_MAIN();` above to get the same behavior.
The compiled executable will run all benchmarks by default. Pass the `--help`
flag for option information or see the [User Guide](docs/user_guide.md).
### Usage with CMake
If using CMake, it is recommended to link against the project-provided
`benchmark::benchmark` and `benchmark::benchmark_main` targets using
`target_link_libraries`.
It is possible to use ```find_package``` to import an installed version of the
library.
```cmake
find_package(benchmark REQUIRED)
```
Alternatively, ```add_subdirectory``` will incorporate the library directly in
to one's CMake project.
```cmake
add_subdirectory(benchmark)
```
Either way, link to the library as follows.
```cmake
target_link_libraries(MyTarget benchmark::benchmark)
```
================================================
FILE: 3rd/benchmark-1.8.2/WORKSPACE
================================================
workspace(name = "com_github_google_benchmark")
load("//:bazel/benchmark_deps.bzl", "benchmark_deps")
benchmark_deps()
load("@rules_foreign_cc//foreign_cc:repositories.bzl", "rules_foreign_cc_dependencies")
rules_foreign_cc_dependencies()
load("@rules_python//python:pip.bzl", pip3_install="pip_install")
pip3_install(
name = "tools_pip_deps",
requirements = "//tools:requirements.txt",
)
new_local_repository(
name = "python_headers",
build_file = "@//bindings/python:python_headers.BUILD",
path = "<PYTHON_INCLUDE_PATH>", # May be overwritten by setup.py.
)
================================================
FILE: 3rd/benchmark-1.8.2/WORKSPACE.bzlmod
================================================
# This file marks the root of the Bazel workspace.
# See MODULE.bazel for dependencies and setup.
================================================
FILE: 3rd/benchmark-1.8.2/_config.yml
================================================
theme: jekyll-theme-midnight
markdown: GFM
================================================
FILE: 3rd/benchmark-1.8.2/appveyor.yml
================================================
version: '{build}'
image: Visual Studio 2017
configuration:
- Debug
- Release
environment:
matrix:
- compiler: msvc-15-seh
generator: "Visual Studio 15 2017"
- compiler: msvc-15-seh
generator: "Visual Studio 15 2017 Win64"
- compiler: msvc-14-seh
generator: "Visual Studio 14 2015"
- compiler: msvc-14-seh
generator: "Visual Studio 14 2015 Win64"
- compiler: gcc-5.3.0-posix
generator: "MinGW Makefiles"
cxx_path: 'C:\mingw-w64\i686-5.3.0-posix-dwarf-rt_v4-rev0\mingw32\bin'
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
matrix:
fast_finish: true
install:
# git bash conflicts with MinGW makefiles
- if "%generator%"=="MinGW Makefiles" (set "PATH=%PATH:C:\Program Files\Git\usr\bin;=%")
- if not "%cxx_path%"=="" (set "PATH=%PATH%;%cxx_path%")
build_script:
- md _build -Force
- cd _build
- echo %configuration%
- cmake -G "%generator%" "-DCMAKE_BUILD_TYPE=%configuration%" -DBENCHMARK_DOWNLOAD_DEPENDENCIES=ON ..
- cmake --build . --config %configuration%
test_script:
- ctest --build-config %configuration% --timeout 300 --output-on-failure
artifacts:
- path: '_build/CMakeFiles/*.log'
name: logs
- path: '_build/Testing/**/*.xml'
name: test_results
================================================
FILE: 3rd/benchmark-1.8.2/bazel/benchmark_deps.bzl
================================================
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")
def benchmark_deps():
"""Loads dependencies required to build Google Benchmark."""
if "bazel_skylib" not in native.existing_rules():
http_archive(
name = "bazel_skylib",
sha256 = "f7be3474d42aae265405a592bb7da8e171919d74c16f082a5457840f06054728",
urls = [
"https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.2.1/bazel-skylib-1.2.1.tar.gz",
"https://github.com/bazelbuild/bazel-skylib/releases/download/1.2.1/bazel-skylib-1.2.1.tar.gz",
],
)
if "rules_foreign_cc" not in native.existing_rules():
http_archive(
name = "rules_foreign_cc",
sha256 = "bcd0c5f46a49b85b384906daae41d277b3dc0ff27c7c752cc51e43048a58ec83",
strip_prefix = "rules_foreign_cc-0.7.1",
url = "https://github.com/bazelbuild/rules_foreign_cc/archive/0.7.1.tar.gz",
)
if "rules_python" not in native.existing_rules():
http_archive(
name = "rules_python",
url = "https://github.com/bazelbuild/rules_python/releases/download/0.1.0/rules_python-0.1.0.tar.gz",
sha256 = "b6d46438523a3ec0f3cead544190ee13223a52f6a6765a29eae7b7cc24cc83a0",
)
if "com_google_absl" not in native.existing_rules():
http_archive(
name = "com_google_absl",
sha256 = "f41868f7a938605c92936230081175d1eae87f6ea2c248f41077c8f88316f111",
strip_prefix = "abseil-cpp-20200225.2",
urls = ["https://github.com/abseil/abseil-cpp/archive/20200225.2.tar.gz"],
)
if "com_google_googletest" not in native.existing_rules():
new_git_repository(
name = "com_google_googletest",
remote = "https://github.com/google/googletest.git",
tag = "release-1.11.0",
)
if "nanobind" not in native.existing_rules():
new_git_repository(
name = "nanobind",
remote = "https://github.com/wjakob/nanobind.git",
commit = "1ffbfe836c9dac599496a170274ee0075094a607", # v0.2.0
shallow_since = "1677873085 +0100",
build_file = "@//bindings/python:nanobind.BUILD",
recursive_init_submodules = True,
)
if "libpfm" not in native.existing_rules():
# Downloaded from v4.9.0 tag at https://sourceforge.net/p/perfmon2/libpfm4/ref/master/tags/
http_archive(
name = "libpfm",
build_file = str(Label("//tools:libpfm.BUILD.bazel")),
sha256 = "5da5f8872bde14b3634c9688d980f68bda28b510268723cc12973eedbab9fecc",
type = "tar.gz",
strip_prefix = "libpfm-4.11.0",
urls = ["https://sourceforge.net/projects/perfmon2/files/libpfm4/libpfm-4.11.0.tar.gz/download"],
)
================================================
FILE: 3rd/benchmark-1.8.2/bindings/python/BUILD
================================================
exports_files(glob(["*.BUILD"]))
exports_files(["build_defs.bzl"])
================================================
FILE: 3rd/benchmark-1.8.2/bindings/python/build_defs.bzl
================================================
_SHARED_LIB_SUFFIX = {
"//conditions:default": ".so",
"//:windows": ".dll",
}
def py_extension(name, srcs, hdrs = [], copts = [], features = [], deps = []):
for shared_lib_suffix in _SHARED_LIB_SUFFIX.values():
shared_lib_name = name + shared_lib_suffix
native.cc_binary(
name = shared_lib_name,
linkshared = True,
linkstatic = True,
srcs = srcs + hdrs,
copts = copts,
features = features,
deps = deps,
)
return native.py_library(
name = name,
data = select({
platform: [name + shared_lib_suffix]
for platform, shared_lib_suffix in _SHARED_LIB_SUFFIX.items()
}),
)
================================================
FILE: 3rd/benchmark-1.8.2/bindings/python/google_benchmark/BUILD
================================================
load("//bindings/python:build_defs.bzl", "py_extension")
py_library(
name = "google_benchmark",
srcs = ["__init__.py"],
visibility = ["//visibility:public"],
deps = [
":_benchmark",
],
)
py_extension(
name = "_benchmark",
srcs = ["benchmark.cc"],
copts = [
"-fexceptions",
"-fno-strict-aliasing",
],
features = [
"-use_header_modules",
"-parse_headers",
],
deps = [
"//:benchmark",
"@nanobind",
"@python_headers",
],
)
py_test(
name = "example",
srcs = ["example.py"],
python_version = "PY3",
srcs_version = "PY3",
visibility = ["//visibility:public"],
deps = [
":google_benchmark",
],
)
================================================
FILE: 3rd/benchmark-1.8.2/bindings/python/google_benchmark/__init__.py
================================================
# Copyright 2020 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Python benchmarking utilities.
Example usage:
import google_benchmark as benchmark
@benchmark.register
def my_benchmark(state):
... # Code executed outside `while` loop is not timed.
while state:
... # Code executed within `while` loop is timed.
if __name__ == '__main__':
benchmark.main()
"""
import atexit
from absl import app
from google_benchmark import _benchmark
from google_benchmark._benchmark import (
Counter,
kNanosecond,
kMicrosecond,
kMillisecond,
kSecond,
oNone,
o1,
oN,
oNSquared,
oNCubed,
oLogN,
oNLogN,
oAuto,
oLambda,
State,
)
__all__ = [
"register",
"main",
"Counter",
"kNanosecond",
"kMicrosecond",
"kMillisecond",
"kSecond",
"oNone",
"o1",
"oN",
"oNSquared",
"oNCubed",
"oLogN",
"oNLogN",
"oAuto",
"oLambda",
"State",
]
__version__ = "1.8.2"
class __OptionMaker:
"""A stateless class to collect benchmark options.
Collect all decorator calls like @option.range(start=0, limit=1<<5).
"""
class Options:
"""Pure data class to store options calls, along with the benchmarked function."""
def __init__(self, func):
self.func = func
self.builder_calls = []
@classmethod
def make(cls, func_or_options):
"""Make Options from Options or the benchmarked function."""
if isinstance(func_or_options, cls.Options):
return func_or_options
return cls.Options(func_or_options)
def __getattr__(self, builder_name):
"""Append option call in the Options."""
# The function that get returned on @option.range(start=0, limit=1<<5).
def __builder_method(*args, **kwargs):
# The decorator that get called, either with the benchmared function
# or the previous Options
def __decorator(func_or_options):
options = self.make(func_or_options)
options.builder_calls.append((builder_name, args, kwargs))
# The decorator returns Options so it is not technically a decorator
# and needs a final call to @register
return options
return __decorator
return __builder_method
# Alias for nicer API.
# We have to instantiate an object, even if stateless, to be able to use __getattr__
# on option.range
option = __OptionMaker()
def register(undefined=None, *, name=None):
"""Register function for benchmarking."""
if undefined is None:
# Decorator is called without parenthesis so we return a decorator
return lambda f: register(f, name=name)
# We have either the function to benchmark (simple case) or an instance of Options
# (@option._ case).
options = __OptionMaker.make(undefined)
if name is None:
name = options.func.__name__
# We register the benchmark and reproduce all the @option._ calls onto the
# benchmark builder pattern
benchmark = _benchmark.RegisterBenchmark(name, options.func)
for name, args, kwargs in options.builder_calls[::-1]:
getattr(benchmark, name)(*args, **kwargs)
# return the benchmarked function because the decorator does not modify it
return options.func
def _flags_parser(argv):
argv = _benchmark.Initialize(argv)
return app.parse_flags_with_usage(argv)
def _run_benchmarks(argv):
if len(argv) > 1:
raise app.UsageError("Too many command-line arguments.")
return _benchmark.RunSpecifiedBenchmarks()
def main(argv=None):
return app.run(_run_benchmarks, argv=argv, flags_parser=_flags_parser)
# Methods for use with custom main function.
initialize = _benchmark.Initialize
run_benchmarks = _benchmark.RunSpecifiedBenchmarks
atexit.register(_benchmark.ClearRegisteredBenchmarks)
================================================
FILE: 3rd/benchmark-1.8.2/bindings/python/google_benchmark/benchmark.cc
================================================
// Benchmark for Python.
#include "benchmark/benchmark.h"
#include "nanobind/nanobind.h"
#include "nanobind/operators.h"
#include "nanobind/stl/bind_map.h"
#include "nanobind/stl/string.h"
#include "nanobind/stl/vector.h"
NB_MAKE_OPAQUE(benchmark::UserCounters);
namespace {
namespace nb = nanobind;
std::vector<std::string> Initialize(const std::vector<std::string>& argv) {
// The `argv` pointers here become invalid when this function returns, but
// benchmark holds the pointer to `argv[0]`. We create a static copy of it
// so it persists, and replace the pointer below.
static std::string executable_name(argv[0]);
std::vector<char*> ptrs;
ptrs.reserve(argv.size());
for (auto& arg : argv) {
ptrs.push_back(const_cast<char*>(arg.c_str()));
}
ptrs[0] = const_cast<char*>(executable_name.c_str());
int argc = static_cast<int>(argv.size());
benchmark::Initialize(&argc, ptrs.data());
std::vector<std::string> remaining_argv;
remaining_argv.reserve(argc);
for (int i = 0; i < argc; ++i) {
remaining_argv.emplace_back(ptrs[i]);
}
return remaining_argv;
}
benchmark::internal::Benchmark* RegisterBenchmark(const std::string& name,
nb::callable f) {
return benchmark::RegisterBenchmark(
name, [f](benchmark::State& state) { f(&state); });
}
NB_MODULE(_benchmark, m) {
using benchmark::TimeUnit;
nb::enum_<TimeUnit>(m, "TimeUnit")
.value("kNanosecond", TimeUnit::kNanosecond)
.value("kMicrosecond", TimeUnit::kMicrosecond)
.value("kMillisecond", TimeUnit::kMillisecond)
.value("kSecond", TimeUnit::kSecond)
.export_values();
using benchmark::BigO;
nb::enum_<BigO>(m, "BigO")
.value("oNone", BigO::oNone)
.value("o1", BigO::o1)
.value("oN", BigO::oN)
.value("oNSquared", BigO::oNSquared)
.value("oNCubed", BigO::oNCubed)
.value("oLogN", BigO::oLogN)
.value("oNLogN", BigO::oNLogN)
.value("oAuto", BigO::oAuto)
.value("oLambda", BigO::oLambda)
.export_values();
using benchmark::internal::Benchmark;
nb::class_<Benchmark>(m, "Benchmark")
// For methods returning a pointer to the current object, reference
// return policy is used to ask nanobind not to take ownership of the
// returned object and avoid calling delete on it.
// https://pybind11.readthedocs.io/en/stable/advanced/functions.html#return-value-policies
//
// For methods taking a const std::vector<...>&, a copy is created
// because a it is bound to a Python list.
// https://pybind11.readthedocs.io/en/stable/advanced/cast/stl.html
.def("unit", &Benchmark::Unit, nb::rv_policy::reference)
.def("arg", &Benchmark::Arg, nb::rv_policy::reference)
.def("args", &Benchmark::Args, nb::rv_policy::reference)
.def("range", &Benchmark::Range, nb::rv_policy::reference,
nb::arg("start"), nb::arg("limit"))
.def("dense_range", &Benchmark::DenseRange,
nb::rv_policy::reference, nb::arg("start"),
nb::arg("limit"), nb::arg("step") = 1)
.def("ranges", &Benchmark::Ranges, nb::rv_policy::reference)
.def("args_product", &Benchmark::ArgsProduct,
nb::rv_policy::reference)
.def("arg_name", &Benchmark::ArgName, nb::rv_policy::reference)
.def("arg_names", &Benchmark::ArgNames,
nb::rv_policy::reference)
.def("range_pair", &Benchmark::RangePair,
nb::rv_policy::reference, nb::arg("lo1"), nb::arg("hi1"),
nb::arg("lo2"), nb::arg("hi2"))
.def("range_multiplier", &Benchmark::RangeMultiplier,
nb::rv_policy::reference)
.def("min_time", &Benchmark::MinTime, nb::rv_policy::reference)
.def("min_warmup_time", &Benchmark::MinWarmUpTime,
nb::rv_policy::reference)
.def("iterations", &Benchmark::Iterations,
nb::rv_policy::reference)
.def("repetitions", &Benchmark::Repetitions,
nb::rv_policy::reference)
.def("report_aggregates_only", &Benchmark::ReportAggregatesOnly,
nb::rv_policy::reference, nb::arg("value") = true)
.def("display_aggregates_only", &Benchmark::DisplayAggregatesOnly,
nb::rv_policy::reference, nb::arg("value") = true)
.def("measure_process_cpu_time", &Benchmark::MeasureProcessCPUTime,
nb::rv_policy::reference)
.def("use_real_time", &Benchmark::UseRealTime,
nb::rv_policy::reference)
.def("use_manual_time", &Benchmark::UseManualTime,
nb::rv_policy::reference)
.def(
"complexity",
(Benchmark * (Benchmark::*)(benchmark::BigO)) & Benchmark::Complexity,
nb::rv_policy::reference,
nb::arg("complexity") = benchmark::oAuto);
using benchmark::Counter;
nb::class_<Counter> py_counter(m, "Counter");
nb::enum_<Counter::Flags>(py_counter, "Flags")
.value("kDefaults", Counter::Flags::kDefaults)
.value("kIsRate", Counter::Flags::kIsRate)
.value("kAvgThreads", Counter::Flags::kAvgThreads)
.value("kAvgThreadsRate", Counter::Flags::kAvgThreadsRate)
.value("kIsIterationInvariant", Counter::Flags::kIsIterationInvariant)
.value("kIsIterationInvariantRate",
Counter::Flags::kIsIterationInvariantRate)
.value("kAvgIterations", Counter::Flags::kAvgIterations)
.value("kAvgIterationsRate", Counter::Flags::kAvgIterationsRate)
.value("kInvert", Counter::Flags::kInvert)
.export_values()
.def(nb::self | nb::self);
nb::enum_<Counter::OneK>(py_counter, "OneK")
.value("kIs1000", Counter::OneK::kIs1000)
.value("kIs1024", Counter::OneK::kIs1024)
.export_values();
py_counter
.def(nb::init<double, Counter::Flags, Counter::OneK>(),
nb::arg("value") = 0., nb::arg("flags") = Counter::kDefaults,
nb::arg("k") = Counter::kIs1000)
.def("__init__", ([](Counter *c, double value) { new (c) Counter(value); }))
.def_rw("value", &Counter::value)
.def_rw("flags", &Counter::flags)
.def_rw("oneK", &Counter::oneK)
.def(nb::init_implicit<double>());
nb::implicitly_convertible<nb::int_, Counter>();
nb::bind_map<benchmark::UserCounters>(m, "UserCounters");
using benchmark::State;
nb::class_<State>(m, "State")
.def("__bool__", &State::KeepRunning)
.def_prop_ro("keep_running", &State::KeepRunning)
.def("pause_timing", &State::PauseTiming)
.def("resume_timing", &State::ResumeTiming)
.def("skip_with_error", &State::SkipWithError)
.def_prop_ro("error_occurred", &State::error_occurred)
.def("set_iteration_time", &State::SetIterationTime)
.def_prop_rw("bytes_processed", &State::bytes_processed,
&State::SetBytesProcessed)
.def_prop_rw("complexity_n", &State::complexity_length_n,
&State::SetComplexityN)
.def_prop_rw("items_processed", &State::items_processed,
&State::SetItemsProcessed)
.def("set_label", &State::SetLabel)
.def("range", &State::range, nb::arg("pos") = 0)
.def_prop_ro("iterations", &State::iterations)
.def_prop_ro("name", &State::name)
.def_rw("counters", &State::counters)
.def_prop_ro("thread_index", &State::thread_index)
.def_prop_ro("threads", &State::threads);
m.def("Initialize", Initialize);
m.def("RegisterBenchmark", RegisterBenchmark,
nb::rv_policy::reference);
m.def("RunSpecifiedBenchmarks",
[]() { benchmark::RunSpecifiedBenchmarks(); });
m.def("ClearRegisteredBenchmarks", benchmark::ClearRegisteredBenchmarks);
};
} // namespace
================================================
FILE: 3rd/benchmark-1.8.2/bindings/python/google_benchmark/example.py
================================================
# Copyright 2020 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Example of Python using C++ benchmark framework.
To run this example, you must first install the `google_benchmark` Python package.
To install using `setup.py`, download and extract the `google_benchmark` source.
In the extracted directory, execute:
python setup.py install
"""
import random
import time
import google_benchmark as benchmark
from google_benchmark import Counter
@benchmark.register
def empty(state):
while state:
pass
@benchmark.register
def sum_million(state):
while state:
sum(range(1_000_000))
@benchmark.register
def pause_timing(state):
"""Pause timing every iteration."""
while state:
# Construct a list of random ints every iteration without timing it
state.pause_timing()
random_list = [random.randint(0, 100) for _ in range(100)]
state.resume_timing()
# Time the in place sorting algorithm
random_list.sort()
@benchmark.register
def skipped(state):
if True: # Test some predicate here.
state.skip_with_error("some error")
return # NOTE: You must explicitly return, or benchmark will continue.
... # Benchmark code would be here.
@benchmark.register
def manual_timing(state):
while state:
# Manually count Python CPU time
start = time.perf_counter() # perf_counter_ns() in Python 3.7+
# Something to benchmark
time.sleep(0.01)
end = time.perf_counter()
state.set_iteration_time(end - start)
@benchmark.register
def custom_counters(state):
"""Collect custom metric using benchmark.Counter."""
num_foo = 0.0
while state:
# Benchmark some code here
pass
# Collect some custom metric named foo
num_foo += 0.13
# Automatic Counter from numbers.
state.counters["foo"] = num_foo
# Set a counter as a rate.
state.counters["foo_rate"] = Counter(num_foo, Counter.kIsRate)
# Set a counter as an inverse of rate.
state.counters["foo_inv_rate"] = Counter(num_foo, Counter.kIsRate | Counter.kInvert)
# Set a counter as a thread-average quantity.
state.counters["foo_avg"] = Counter(num_foo, Counter.kAvgThreads)
# There's also a combined flag:
state.counters["foo_avg_rate"] = Counter(num_foo, Counter.kAvgThreadsRate)
@benchmark.register
@benchmark.option.measure_process_cpu_time()
@benchmark.option.use_real_time()
def with_options(state):
while state:
sum(range(1_000_000))
@benchmark.register(name="sum_million_microseconds")
@benchmark.option.unit(benchmark.kMicrosecond)
def with_options2(state):
while state:
sum(range(1_000_000))
@benchmark.register
@benchmark.option.arg(100)
@benchmark.option.arg(1000)
def passing_argument(state):
while state:
sum(range(state.range(0)))
@benchmark.register
@benchmark.option.range(8, limit=8 << 10)
def using_range(state):
while state:
sum(range(state.range(0)))
@benchmark.register
@benchmark.option.range_multiplier(2)
@benchmark.option.range(1 << 10, 1 << 18)
@benchmark.option.complexity(benchmark.oN)
def computing_complexity(state):
while state:
sum(range(state.range(0)))
state.complexity_n = state.range(0)
if __name__ == "__main__":
benchmark.main()
================================================
FILE: 3rd/benchmark-1.8.2/bindings/python/nanobind.BUILD
================================================
config_setting(
name = "msvc_compiler",
flag_values = {"@bazel_tools//tools/cpp:compiler": "msvc-cl"},
)
cc_library(
name = "nanobind",
hdrs = glob(
include = [
"include/nanobind/*.h",
"include/nanobind/stl/*.h",
"include/nanobind/detail/*.h",
],
exclude = [],
),
srcs = [
"include/nanobind/stl/detail/nb_dict.h",
"include/nanobind/stl/detail/nb_list.h",
"include/nanobind/stl/detail/traits.h",
"ext/robin_map/include/tsl/robin_map.h",
"ext/robin_map/include/tsl/robin_hash.h",
"ext/robin_map/include/tsl/robin_growth_policy.h",
"ext/robin_map/include/tsl/robin_set.h",
"src/buffer.h",
"src/common.cpp",
"src/error.cpp",
"src/implicit.cpp",
"src/nb_enum.cpp",
"src/nb_func.cpp",
"src/nb_internals.cpp",
"src/nb_internals.h",
"src/nb_ndarray.cpp",
"src/nb_type.cpp",
"src/trampoline.cpp",
],
copts = select({
":msvc_compiler": [],
"//conditions:default": [
"-fexceptions",
"-Os", # size optimization
"-flto", # enable LTO
],
}),
linkopts = select({
"@com_github_google_benchmark//:macos": [
"-undefined dynamic_lookup",
"-Wl,-no_fixup_chains",
"-Wl,-dead_strip",
],
"//conditions:default": [],
}),
includes = ["include", "ext/robin_map/include"],
deps = ["@python_headers"],
visibility = ["//visibility:public"],
)
================================================
FILE: 3rd/benchmark-1.8.2/bindings/python/python_headers.BUILD
================================================
cc_library(
name = "python_headers",
hdrs = glob(["**/*.h"]),
includes = ["."],
visibility = ["//visibility:public"],
)
================================================
FILE: 3rd/benchmark-1.8.2/bindings/python/requirements.txt
================================================
absl-py>=0.7.1
================================================
FILE: 3rd/benchmark-1.8.2/cmake/Config.cmake.in
================================================
@PACKAGE_INIT@
include (CMakeFindDependencyMacro)
find_dependency (Threads)
include("${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake")
================================================
FILE: 3rd/benchmark-1.8.2/cmake/GoogleTest.cmake.in
================================================
cmake_minimum_required(VERSION 2.8.12)
project(googletest-download NONE)
# Enable ExternalProject CMake module
include(ExternalProject)
option(ALLOW_DOWNLOADING_GOOGLETEST "If googletest src tree is not found in location specified by GOOGLETEST_PATH, do fetch the archive from internet" OFF)
set(GOOGLETEST_PATH "/usr/src/googletest" CACHE PATH
"Path to the googletest root tree. Should contain googletest and googlemock subdirs. And CMakeLists.txt in root, and in both of these subdirs")
# Download and install GoogleTest
message(STATUS "Looking for Google Test sources")
message(STATUS "Looking for Google Test sources in ${GOOGLETEST_PATH}")
if(EXISTS "${GOOGLETEST_PATH}" AND IS_DIRECTORY "${GOOGLETEST_PATH}" AND EXISTS "${GOOGLETEST_PATH}/CMakeLists.txt" AND
EXISTS "${GOOGLETEST_PATH}/googletest" AND IS_DIRECTORY "${GOOGLETEST_PATH}/googletest" AND EXISTS "${GOOGLETEST_PATH}/googletest/CMakeLists.txt" AND
EXISTS "${GOOGLETEST_PATH}/googlemock" AND IS_DIRECTORY "${GOOGLETEST_PATH}/googlemock" AND EXISTS "${GOOGLETEST_PATH}/googlemock/CMakeLists.txt")
message(STATUS "Found Google Test in ${GOOGLETEST_PATH}")
ExternalProject_Add(
googletest
PREFIX "${CMAKE_BINARY_DIR}"
DOWNLOAD_DIR "${CMAKE_BINARY_DIR}/download"
SOURCE_DIR "${GOOGLETEST_PATH}" # use existing src dir.
BINARY_DIR "${CMAKE_BINARY_DIR}/build"
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ""
TEST_COMMAND ""
)
else()
if(NOT ALLOW_DOWNLOADING_GOOGLETEST)
message(SEND_ERROR "Did not find Google Test sources! Either pass correct path in GOOGLETEST_PATH, or enable BENCHMARK_DOWNLOAD_DEPENDENCIES, or disable BENCHMARK_USE_BUNDLED_GTEST, or disable BENCHMARK_ENABLE_GTEST_TESTS / BENCHMARK_ENABLE_TESTING.")
return()
else()
message(WARNING "Did not find Google Test sources! Fetching from web...")
ExternalProject_Add(
googletest
GIT_REPOSITORY https://github.com/google/googletest.git
GIT_TAG "release-1.11.0"
PREFIX "${CMAKE_BINARY_DIR}"
STAMP_DIR "${CMAKE_BINARY_DIR}/stamp"
DOWNLOAD_DIR "${CMAKE_BINARY_DIR}/download"
SOURCE_DIR "${CMAKE_BINARY_DIR}/src"
BINARY_DIR "${CMAKE_BINARY_DIR}/build"
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ""
TEST_COMMAND ""
)
endif()
endif()
ExternalProject_Get_Property(googletest SOURCE_DIR BINARY_DIR)
file(WRITE googletest-paths.cmake
"set(GOOGLETEST_SOURCE_DIR \"${SOURCE_DIR}\")
set(GOOGLETEST_BINARY_DIR \"${BINARY_DIR}\")
")
================================================
FILE: 3rd/benchmark-1.8.2/cmake/benchmark.pc.in
================================================
prefix=@CMAKE_INSTALL_PREFIX@
exec_prefix=${prefix}
libdir=@CMAKE_INSTALL_FULL_LIBDIR@
includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
Name: @PROJECT_NAME@
Description: Google microbenchmark framework
Version: @VERSION@
Libs: -L${libdir} -lbenchmark
Libs.private: -lpthread
Cflags: -I${includedir}
================================================
FILE: 3rd/benchmark-1.8.2/cmake/gnu_posix_regex.cpp
================================================
#include <gnuregex.h>
#include <string>
int main() {
std::string str = "test0159";
regex_t re;
int ec = regcomp(&re, "^[a-z]+[0-9]+$", REG_EXTENDED | REG_NOSUB);
if (ec != 0) {
return ec;
}
return regexec(&re, str.c_str(), 0, nullptr, 0) ? -1 : 0;
}
================================================
FILE: 3rd/benchmark-1.8.2/cmake/posix_regex.cpp
================================================
#include <regex.h>
#include <string>
int main() {
std::string str = "test0159";
regex_t re;
int ec = regcomp(&re, "^[a-z]+[0-9]+$", REG_EXTENDED | REG_NOSUB);
if (ec != 0) {
return ec;
}
int ret = regexec(&re, str.c_str(), 0, nullptr, 0) ? -1 : 0;
regfree(&re);
return ret;
}
================================================
FILE: 3rd/benchmark-1.8.2/cmake/pthread_affinity.cpp
================================================
#include <pthread.h>
int main() {
cpu_set_t set;
CPU_ZERO(&set);
for (int i = 0; i < CPU_SETSIZE; ++i) {
CPU_SET(i, &set);
CPU_CLR(i, &set);
}
pthread_t self = pthread_self();
int ret;
ret = pthread_getaffinity_np(self, sizeof(set), &set);
if (ret != 0) return ret;
ret = pthread_setaffinity_np(self, sizeof(set), &set);
if (ret != 0) return ret;
return 0;
}
================================================
FILE: 3rd/benchmark-1.8.2/cmake/std_regex.cpp
================================================
#include <regex>
#include <string>
int main() {
const std::string str = "test0159";
std::regex re;
re = std::regex("^[a-z]+[0-9]+$",
std::regex_constants::extended | std::regex_constants::nosubs);
return std::regex_search(str, re) ? 0 : -1;
}
================================================
FILE: 3rd/benchmark-1.8.2/cmake/steady_clock.cpp
================================================
#include <chrono>
int main() {
typedef std::chrono::steady_clock Clock;
Clock::time_point tp = Clock::now();
((void)tp);
}
================================================
FILE: 3rd/benchmark-1.8.2/cmake/thread_safety_attributes.cpp
================================================
#define HAVE_THREAD_SAFETY_ATTRIBUTES
#include "../src/mutex.h"
int main() {}
================================================
FILE: 3rd/benchmark-1.8.2/docs/AssemblyTests.md
================================================
# Assembly Tests
The Benchmark library provides a number of functions whose primary
purpose in to affect assembly generation, including `DoNotOptimize`
and `ClobberMemory`. In addition there are other functions,
such as `KeepRunning`, for which generating good assembly is paramount.
For these functions it's important to have tests that verify the
correctness and quality of the implementation. This requires testing
the code generated by the compiler.
This document describes how the Benchmark library tests compiler output,
as well as how to properly write new tests.
## Anatomy of a Test
Writing a test has two steps:
* Write the code you want to generate assembly for.
* Add `// CHECK` lines to match against the verified assembly.
Example:
```c++
// CHECK-LABEL: test_add:
extern "C" int test_add() {
extern int ExternInt;
return ExternInt + 1;
// CHECK: movl ExternInt(%rip), %eax
// CHECK: addl %eax
// CHECK: ret
}
```
#### LLVM Filecheck
[LLVM's Filecheck](https://llvm.org/docs/CommandGuide/FileCheck.html)
is used to test the generated assembly against the `// CHECK` lines
specified in the tests source file. Please see the documentation
linked above for information on how to write `CHECK` directives.
#### Tips and Tricks:
* Tests should match the minimal amount of output required to establish
correctness. `CHECK` directives don't have to match on the exact next line
after the previous match, so tests should omit checks for unimportant
bits of assembly. ([`CHECK-NEXT`](https://llvm.org/docs/CommandGuide/FileCheck.html#the-check-next-directive)
can be used to ensure a match occurs exactly after the previous match).
* The tests are compiled with `-O3 -g0`. So we're only testing the
optimized output.
* The assembly output is further cleaned up using `tools/strip_asm.py`.
This removes comments, assembler directives, and unused labels before
the test is run.
* The generated and stripped assembly file for a test is output under
`<build-directory>/test/<test-name>.s`
* Filecheck supports using [`CHECK` prefixes](https://llvm.org/docs/CommandGuide/FileCheck.html#cmdoption-check-prefixes)
to specify lines that should only match in certain situations.
The Benchmark tests use `CHECK-CLANG` and `CHECK-GNU` for lines that
are only expected to match Clang or GCC's output respectively. Normal
`CHECK` lines match against all compilers. (Note: `CHECK-NOT` and
`CHECK-LABEL` are NOT prefixes. They are versions of non-prefixed
`CHECK` lines)
* Use `extern "C"` to disable name mangling for specific functions. This
makes them easier to name in the `CHECK` lines.
## Problems Writing Portable Tests
Writing tests which check the code generated by a compiler are
inherently non-portable. Different compilers and even different compiler
versions may generate entirely different code. The Benchmark tests
must tolerate this.
LLVM Filecheck provides a number of mechanisms to help write
"more portable" tests; including [matching using regular expressions](https://llvm.org/docs/CommandGuide/FileCheck.html#filecheck-pattern-matching-syntax),
allowing the creation of [named variables](https://llvm.org/docs/CommandGuide/FileCheck.html#filecheck-variables)
for later matching, and [checking non-sequential matches](https://llvm.org/docs/CommandGuide/FileCheck.html#the-check-dag-directive).
#### Capturing Variables
For example, say GCC stores a variable in a register but Clang stores
it in memory. To write a test that tolerates both cases we "capture"
the destination of the store, and then use the captured expression
to write the remainder of the test.
```c++
// CHECK-LABEL: test_div_no_op_into_shr:
extern "C" void test_div_no_op_into_shr(int value) {
int divisor = 2;
benchmark::DoNotOptimize(divisor); // hide the value from the optimizer
return value / divisor;
// CHECK: movl $2, [[DEST:.*]]
// CHECK: idivl [[DEST]]
// CHECK: ret
}
```
#### Using Regular Expressions to Match Differing Output
Often tests require testing assembly lines which may subtly differ
between compilers or compiler versions. A common example of this
is matching stack frame addresses. In this case regular expressions
can be used to match the differing bits of output. For example:
<!-- {% raw %} -->
```c++
int ExternInt;
struct Point { int x, y, z; };
// CHECK-LABEL: test_store_point:
extern "C" void test_store_point() {
Point p{ExternInt, ExternInt, ExternInt};
benchmark::DoNotOptimize(p);
// CHECK: movl ExternInt(%rip), %eax
// CHECK: movl %eax, -{{[0-9]+}}(%rsp)
// CHECK: movl %eax, -{{[0-9]+}}(%rsp)
// CHECK: movl %eax, -{{[0-9]+}}(%rsp)
// CHECK: ret
}
```
<!-- {% endraw %} -->
## Current Requirements and Limitations
The tests require Filecheck to be installed along the `PATH` of the
build machine. Otherwise the tests will be disabled.
Additionally, as mentioned in the previous section, codegen tests are
inherently non-portable. Currently the tests are limited to:
* x86_64 targets.
* Compiled with GCC or Clang
Further work could be done, at least on a limited basis, to extend the
tests to other architectures and compilers (using `CHECK` prefixes).
Furthermore, the tests fail for builds which specify additional flags
that modify code generation, including `--coverage` or `-fsanitize=`.
================================================
FILE: 3rd/benchmark-1.8.2/docs/_config.yml
================================================
theme: jekyll-theme-minimal
================================================
FILE: 3rd/benchmark-1.8.2/docs/dependencies.md
================================================
# Build tool dependency policy
We follow the [Foundational C++ support policy](https://opensource.google/documentation/policies/cplusplus-support) for our build tools. In
particular the ["Build Systems" section](https://opensource.google/documentation/policies/cplusplus-support#build-systems).
## CMake
The current supported version is CMake 3.10 as of 2023-08-10. Most modern
distributions include newer versions, for example:
* Ubuntu 20.04 provides CMake 3.16.3
* Debian 11.4 provides CMake 3.18.4
* Ubuntu 22.04 provides CMake 3.22.1
================================================
FILE: 3rd/benchmark-1.8.2/docs/index.md
================================================
# Benchmark
* [Assembly Tests](AssemblyTests.md)
* [Dependencies](dependencies.md)
* [Perf Counters](perf_counters.md)
* [Platform Specific Build Instructions](platform_specific_build_instructions.md)
* [Python Bindings](python_bindings.md)
* [Random Interleaving](random_interleaving.md)
* [Reducing Variance](reducing_variance.md)
* [Releasing](releasing.md)
* [Tools](tools.md)
* [User Guide](user_guide.md)
================================================
FILE: 3rd/benchmark-1.8.2/docs/perf_counters.md
================================================
<a name="perf-counters" />
# User-Requested Performance Counters
When running benchmarks, the user may choose to request collection of
performance counters. This may be useful in investigation scenarios - narrowing
down the cause of a regression; or verifying that the underlying cause of a
performance improvement matches expectations.
This feature is available if:
* The benchmark is run on an architecture featuring a Performance Monitoring
Unit (PMU),
* The benchmark is compiled with support for collecting counters. Currently,
this requires [libpfm](http://perfmon2.sourceforge.net/), which is built as a
dependency via Bazel.
The feature does not require modifying benchmark code. Counter collection is
handled at the boundaries where timer collection is also handled.
To opt-in:
* If using a Bazel build, add `--define pfm=1` to your build flags
* If using CMake:
* Install `libpfm4-dev`, e.g. `apt-get install libpfm4-dev`.
* Enable the CMake flag `BENCHMARK_ENABLE_LIBPFM` in `CMakeLists.txt`.
To use, pass a comma-separated list of counter names through the
`--benchmark_perf_counters` flag. The names are decoded through libpfm - meaning,
they are platform specific, but some (e.g. `CYCLES` or `INSTRUCTIONS`) are
mapped by libpfm to platform-specifics - see libpfm
[documentation](http://perfmon2.sourceforge.net/docs.html) for more details.
The counter values are reported back through the [User Counters](../README.md#custom-counters)
mechanism, meaning, they are available in all the formats (e.g. JSON) supported
by User Counters.
================================================
FILE: 3rd/benchmark-1.8.2/docs/platform_specific_build_instructions.md
================================================
# Platform Specific Build Instructions
## Building with GCC
When the library is built using GCC it is necessary to link with the pthread
library due to how GCC implements `std::thread`. Failing to link to pthread will
lead to runtime exceptions (unless you're using libc++), not linker errors. See
[issue #67](https://github.com/google/benchmark/issues/67) for more details. You
can link to pthread by adding `-pthread` to your linker command. Note, you can
also use `-lpthread`, but there are potential issues with ordering of command
line parameters if you use that.
On QNX, the pthread library is part of libc and usually included automatically
(see
[`pthread_create()`](https://www.qnx.com/developers/docs/7.1/index.html#com.qnx.doc.neutrino.lib_ref/topic/p/pthread_create.html)).
There's no separate pthread library to link.
## Building with Visual Studio 2015 or 2017
The `shlwapi` library (`-lshlwapi`) is required to support a call to `CPUInfo` which reads the registry. Either add `shlwapi.lib` under `[ Configuration Properties > Linker > Input ]`, or use the following:
```
// Alternatively, can add libraries using linker options.
#ifdef _WIN32
#pragma comment ( lib, "Shlwapi.lib" )
#ifdef _DEBUG
#pragma comment ( lib, "benchmarkd.lib" )
#else
#pragma comment ( lib, "benchmark.lib" )
#endif
#endif
```
Can also use the graphical version of CMake:
* Open `CMake GUI`.
* Under `Where to build the binaries`, same path as source plus `build`.
* Under `CMAKE_INSTALL_PREFIX`, same path as source plus `install`.
* Click `Configure`, `Generate`, `Open Project`.
* If build fails, try deleting entire directory and starting again, or unticking options to build less.
## Building with Intel 2015 Update 1 or Intel System Studio Update 4
See instructions for building with Visual Studio. Once built, right click on the solution and change the build to Intel.
## Building on Solaris
If you're running benchmarks on solaris, you'll want the kstat library linked in
too (`-lkstat`).
================================================
FILE: 3rd/benchmark-1.8.2/docs/python_bindings.md
================================================
# Building and installing Python bindings
Python bindings are available as wheels on [PyPI](https://pypi.org/project/google-benchmark/) for importing and
using Google Benchmark directly in Python.
Currently, pre-built wheels exist for macOS (both ARM64 and Intel x86), Linux x86-64 and 64-bit Windows.
Supported Python versions are Python 3.7 - 3.10.
To install Google Benchmark's Python bindings, run:
```bash
python -m pip install --upgrade pip # for manylinux2014 support
python -m pip install google-benchmark
```
In order to keep your system Python interpreter clean, it is advisable to run these commands in a virtual
environment. See the [official Python documentation](https://docs.python.org/3/library/venv.html)
on how to create virtual environments.
To build a wheel directly from source, you can follow these steps:
```bash
git clone https://github.com/google/benchmark.git
cd benchmark
# create a virtual environment and activate it
python3 -m venv venv --system-site-packages
source venv/bin/activate # .\venv\Scripts\Activate.ps1 on Windows
# upgrade Python's system-wide packages
python -m pip install --upgrade pip setuptools wheel
# builds the wheel and stores it in the directory "wheelhouse".
python -m pip wheel . -w wheelhouse
```
NB: Building wheels from source requires Bazel. For platform-specific instructions on how to install Bazel,
refer to the [Bazel installation docs](https://bazel.build/install).
================================================
FILE: 3rd/benchmark-1.8.2/docs/random_interleaving.md
================================================
<a name="interleaving" />
# Random Interleaving
[Random Interleaving](https://github.com/google/benchmark/issues/1051) is a
technique to lower run-to-run variance. It randomly interleaves repetitions of a
microbenchmark with repetitions from other microbenchmarks in the same benchmark
test. Data shows it is able to lower run-to-run variance by
[40%](https://github.com/google/benchmark/issues/1051) on average.
To use, you mainly need to set `--benchmark_enable_random_interleaving=true`,
and optionally specify non-zero repetition count `--benchmark_repetitions=9`
and optionally decrease the per-repetition time `--benchmark_min_time=0.1`.
================================================
FILE: 3rd/benchmark-1.8.2/docs/reducing_variance.md
================================================
# Reducing Variance
<a name="disabling-cpu-frequency-scaling" />
## Disabling CPU Frequency Scaling
If you see this error:
```
***WARNING*** CPU scaling is enabled, the benchmark real time measurements may be noisy and will incur extra overhead.
```
you might want to disable the CPU frequency scaling while running the
benchmark, as well as consider other ways to stabilize the performance of
your system while benchmarking.
See [Reducing Variance](reducing_variance.md) for more information.
Exactly how to do this depends on the Linux distribution,
desktop environment, and installed programs. Specific details are a moving
target, so we will not attempt to exhaustively document them here.
One simple option is to use the `cpupower` program to change the
performance governor to "performance". This tool is maintained along with
the Linux kernel and provided by your distribution.
It must be run as root, like this:
```bash
sudo cpupower frequency-set --governor performance
```
After this you can verify that all CPUs are using the performance governor
by running this command:
```bash
cpupower frequency-info -o proc
```
The benchmarks you subsequently run will have less variance.
<a name="reducing-variance" />
## Reducing Variance in Benchmarks
The Linux CPU frequency governor [discussed
above](user_guide#disabling-cpu-frequency-scaling) is not the only source
of noise in benchmarks. Some, but not all, of the sources of variance
include:
1. On multi-core machines not all CPUs/CPU cores/CPU threads run the same
speed, so running a benchmark one time and then again may give a
different result depending on which CPU it ran on.
2. CPU scaling features that run on the CPU, like Intel's Turbo Boost and
AMD Turbo Core and Precision Boost, can temporarily change the CPU
frequency even when the using the "performance" governor on Linux.
3. Context switching between CPUs, or scheduling competition on the CPU the
benchmark is running on.
4. Intel Hyperthreading or AMD SMT causing the same issue as above.
5. Cache effects caused by code running on other CPUs.
6. Non-uniform memory architectures (NUMA).
These can cause variance in benchmarks results within a single run
(`--benchmark_repetitions=N`) or across multiple runs of the benchmark
program.
Reducing sources of variance is OS and architecture dependent, which is one
reason some companies maintain machines dedicated to performance testing.
Some of the easier and and effective ways of reducing variance on a typical
Linux workstation are:
1. Use the performance governor as [discussed
above](user_guide#disabling-cpu-frequency-scaling).
1. Disable processor boosting by:
```sh
echo 0 | sudo tee /sys/devices/system/cpu/cpufreq/boost
```
See the Linux kernel's
[boost.txt](https://www.kernel.org/doc/Documentation/cpu-freq/boost.txt)
for more information.
2. Set the benchmark program's task affinity to a fixed cpu. For example:
```sh
taskset -c 0 ./mybenchmark
```
3. Disabling Hyperthreading/SMT. This can be done in the Bios or using the
`/sys` file system (see the LLVM project's [Benchmarking
tips](https://llvm.org/docs/Benchmarking.html)).
4. Close other programs that do non-trivial things based on timers, such as
your web browser, desktop environment, etc.
5. Reduce the working set of your benchmark to fit within the L1 cache, but
do be aware that this may lead you to optimize for an unrelistic
situation.
Further resources on this topic:
1. The LLVM project's [Benchmarking
tips](https://llvm.org/docs/Benchmarking.html).
1. The Arch Wiki [Cpu frequency
scaling](https://wiki.archlinux.org/title/CPU_frequency_scaling) page.
================================================
FILE: 3rd/benchmark-1.8.2/docs/releasing.md
================================================
# How to release
* Make sure you're on main and synced to HEAD
* Ensure the project builds and tests run
* `parallel -j0 exec ::: test/*_test` can help ensure everything at least
passes
* Prepare release notes
* `git log $(git describe --abbrev=0 --tags)..HEAD` gives you the list of
commits between the last annotated tag and HEAD
* Pick the most interesting.
* Create one last commit that updates the version saved in `CMakeLists.txt`, `MODULE.bazel`
and the `__version__` variable in `bindings/python/google_benchmark/__init__.py`to the
release version you're creating. (This version will be used if benchmark is installed
from the archive you'll be creating in the next step.)
```
project (benchmark VERSION 1.8.0 LANGUAGES CXX)
```
```
module(name = "com_github_google_benchmark", version="1.8.0")
```
```python
# bindings/python/google_benchmark/__init__.py
# ...
__version__ = "1.8.0" # <-- change this to the release version you are creating
# ...
```
* Create a release through github's interface
* Note this will create a lightweight tag.
* Update this to an annotated tag:
* `git pull --tags`
* `git tag -a -f <tag> <tag>`
* `git push --force --tags origin`
* Confirm that the "Build and upload Python wheels" action runs to completion
* run it manually if it hasn't run
================================================
FILE: 3rd/benchmark-1.8.2/docs/tools.md
================================================
# Benchmark Tools
## compare.py
The `compare.py` can be used to compare the result of benchmarks.
### Dependencies
The utility relies on the [scipy](https://www.scipy.org) package which can be installed using pip:
```bash
pip3 install -r requirements.txt
```
### Displaying aggregates only
The switch `-a` / `--display_aggregates_only` can be used to control the
displayment of the normal iterations vs the aggregates. When passed, it will
be passthrough to the benchmark binaries to be run, and will be accounted for
in the tool itself; only the aggregates will be displayed, but not normal runs.
It only affects the display, the separate runs will still be used to calculate
the U test.
### Modes of operation
There are three modes of operation:
1. Just compare two benchmarks
The program is invoked like:
``` bash
$ compare.py benchmarks <benchmark_baseline> <benchmark_contender> [benchmark options]...
```
Where `<benchmark_baseline>` and `<benchmark_contender>` either specify a benchmark executable file, or a JSON output file. The type of the input file is automatically detected. If a benchmark executable is specified then the benchmark is run to obtain the results. Otherwise the results are simply loaded from the output file.
`[benchmark options]` will be passed to the benchmarks invocations. They can be anything that binary accepts, be it either normal `--benchmark_*` parameters, or some custom parameters your binary takes.
Example output:
```
$ ./compare.py benchmarks ./a.out ./a.out
RUNNING: ./a.out --benchmark_out=/tmp/tmprBT5nW
Run on (8 X 4000 MHz CPU s)
2017-11-07 21:16:44
------------------------------------------------------
Benchmark Time CPU Iterations
------------------------------------------------------
BM_memcpy/8 36 ns 36 ns 19101577 211.669MB/s
BM_memcpy/64 76 ns 76 ns 9412571 800.199MB/s
BM_memcpy/512 84 ns 84 ns 8249070 5.64771GB/s
BM_memcpy/1024 116 ns 116 ns 6181763 8.19505GB/s
BM_memcpy/8192 643 ns 643 ns 1062855 11.8636GB/s
BM_copy/8 222 ns 222 ns 3137987 34.3772MB/s
BM_copy/64 1608 ns 1608 ns 432758 37.9501MB/s
BM_copy/512 12589 ns 12589 ns 54806 38.7867MB/s
BM_copy/1024 25169 ns 25169 ns 27713 38.8003MB/s
BM_copy/8192 201165 ns 201112 ns 3486 38.8466MB/s
RUNNING: ./a.out --benchmark_out=/tmp/tmpt1wwG_
Run on (8 X 4000 MHz CPU s)
2017-11-07 21:16:53
------------------------------------------------------
Benchmark Time CPU Iterations
------------------------------------------------------
BM_memcpy/8 36 ns 36 ns 19397903 211.255MB/s
BM_memcpy/64 73 ns 73 ns 9691174 839.635MB/s
BM_memcpy/512 85 ns 85 ns 8312329 5.60101GB/s
BM_memcpy/1024 118 ns 118 ns 6438774 8.11608GB/s
BM_memcpy/8192 656 ns 656 ns 1068644 11.6277GB/s
BM_copy/8 223 ns 223 ns 3146977 34.2338MB/s
BM_copy/64 1611 ns 1611 ns 435340 37.8751MB/s
BM_copy/512 12622 ns 12622 ns 54818 38.6844MB/s
BM_copy/1024 25257 ns 25239 ns 27779 38.6927MB/s
BM_copy/8192 205013 ns 205010 ns 3479 38.108MB/s
Comparing ./a.out to ./a.out
Benchmark Time CPU Time Old Time New CPU Old CPU New
------------------------------------------------------------------------------------------------------
BM_memcpy/8 +0.0020 +0.0020 36 36 36 36
BM_memcpy/64 -0.0468 -0.0470 76 73 76 73
BM_memcpy/512 +0.0081 +0.0083 84 85 84 85
BM_memcpy/1024 +0.0098 +0.0097 116 118 116 118
BM_memcpy/8192 +0.0200 +0.0203 643 656 643 656
BM_copy/8 +0.0046 +0.0042 222 223 222 223
BM_copy/64 +0.0020 +0.0020 1608 1611 1608 1611
BM_copy/512 +0.0027 +0.0026 12589 12622 12589 12622
BM_copy/1024 +0.0035 +0.0028 25169 25257 25169 25239
BM_copy/8192 +0.0191 +0.0194 201165 205013 201112 205010
```
What it does is for the every benchmark from the first run it looks for the benchmark with exactly the same name in the second run, and then compares the results. If the names differ, the benchmark is omitted from the diff.
As you can note, the values in `Time` and `CPU` columns are calculated as `(new - old) / |old|`.
2. Compare two different filters of one benchmark
The program is invoked like:
``` bash
$ compare.py filters <benchmark> <filter_baseline> <filter_contender> [benchmark options]...
```
Where `<benchmark>` either specify a benchmark executable file, or a JSON output file. The type of the input file is automatically detected. If a benchmark executable is specified then the benchmark is run to obtain the results. Otherwise the results are simply loaded from the output file.
Where `<filter_baseline>` and `<filter_contender>` are the same regex filters that you would pass to the `[--benchmark_filter=<regex>]` parameter of the benchmark binary.
`[benchmark options]` will be passed to the benchmarks invocations. They can be anything that binary accepts, be it either normal `--benchmark_*` parameters, or some custom parameters your binary takes.
Example output:
```
$ ./compare.py filters ./a.out BM_memcpy BM_copy
RUNNING: ./a.out --benchmark_filter=BM_memcpy --benchmark_out=/tmp/tmpBWKk0k
Run on (8 X 4000 MHz CPU s)
2017-11-07 21:37:28
------------------------------------------------------
Benchmark Time CPU Iterations
------------------------------------------------------
BM_memcpy/8 36 ns 36 ns 17891491 211.215MB/s
BM_memcpy/64 74 ns 74 ns 9400999 825.646MB/s
BM_memcpy/512 87 ns 87 ns 8027453 5.46126GB/s
BM_memcpy/1024 111 ns 111 ns 6116853 8.5648GB/s
BM_memcpy/8192 657 ns 656 ns 1064679 11.6247GB/s
RUNNING: ./a.out --benchmark_filter=BM_copy --benchmark_out=/tmp/tmpAvWcOM
Run on (8 X 4000 MHz CPU s)
2017-11-07 21:37:33
----------------------------------------------------
Benchmark Time CPU Iterations
----------------------------------------------------
BM_copy/8 227 ns 227 ns 3038700 33.6264MB/s
BM_copy/64 1640 ns 1640 ns 426893 37.2154MB/s
BM_copy/512 12804 ns 12801 ns 55417 38.1444MB/s
BM_copy/1024 25409 ns 25407 ns 27516 38.4365MB/s
BM_copy/8192 202986 ns 202990 ns 3454 38.4871MB/s
Comparing BM_memcpy to BM_copy (from ./a.out)
Benchmark Time CPU Time Old Time New CPU Old CPU New
--------------------------------------------------------------------------------------------------------------------
[BM_memcpy vs. BM_copy]/8 +5.2829 +5.2812 36 227 36 227
[BM_memcpy vs. BM_copy]/64 +21.1719 +21.1856 74 1640 74 1640
[BM_memcpy vs. BM_copy]/512 +145.6487 +145.6097 87 12804 87 12801
[BM_memcpy vs. BM_copy]/1024 +227.1860 +227.1776 111 25409 111 25407
[BM_memcpy vs. BM_copy]/8192 +308.1664 +308.2898 657 202986 656 202990
```
As you can see, it applies filter to the benchmarks, both when running the benchmark, and before doing the diff. And to make the diff work, the matches are replaced with some common string. Thus, you can compare two different benchmark families within one benchmark binary.
As you can note, the values in `Time` and `CPU` columns are calculated as `(new - old) / |old|`.
3. Compare filter one from benchmark one to filter two from benchmark two:
The program is invoked like:
``` bash
$ compare.py filters <benchmark_baseline> <filter_baseline> <benchmark_contender> <filter_contender> [benchmark options]...
```
Where `<benchmark_baseline>` and `<benchmark_contender>` either specify a benchmark executable file, or a JSON output file. The type of the input file is automatically detected. If a benchmark executable is specified then the benchmark is run to obtain the results. Otherwise the results are simply loaded from the output file.
Where `<filter_baseline>` and `<filter_contender>` are the same regex filters that you would pass to the `[--benchmark_filter=<regex>]` parameter of the benchmark binary.
`[benchmark options]` will be passed to the benchmarks invocations. They can be anything that binary accepts, be it either normal `--benchmark_*` parameters, or some custom parameters your binary takes.
Example output:
```
$ ./compare.py benchmarksfiltered ./a.out BM_memcpy ./a.out BM_copy
RUNNING: ./a.out --benchmark_filter=BM_memcpy --benchmark_out=/tmp/tmp_FvbYg
Run on (8 X 4000 MHz CPU s)
2017-11-07 21:38:27
------------------------------------------------------
Benchmark Time CPU Iterations
------------------------------------------------------
BM_memcpy/8 37 ns 37 ns 18953482 204.118MB/s
BM_memcpy/64 74 ns 74 ns 9206578 828.245MB/s
BM_memcpy/512 91 ns 91 ns 8086195 5.25476GB/s
BM_memcpy/1024 120 ns 120 ns 5804513 7.95662GB/s
BM_memcpy/8192 664 ns 664 ns 1028363 11.4948GB/s
RUNNING: ./a.out --benchmark_filter=BM_copy --benchmark_out=/tmp/tmpDfL5iE
Run on (8 X 4000 MHz CPU s)
2017-11-07 21:38:32
----------------------------------------------------
Benchmark Time CPU Iterations
----------------------------------------------------
BM_copy/8 230 ns 230 ns 2985909 33.1161MB/s
BM_copy/64 1654 ns 1653 ns 419408 36.9137MB/s
BM_copy/512 13122 ns 13120 ns 53403 37.2156MB/s
BM_copy/1024 26679 ns 26666 ns 26575 36.6218MB/s
BM_copy/8192 215068 ns 215053 ns 3221 36.3283MB/s
Comparing BM_memcpy (from ./a.out) to BM_copy (from ./a.out)
Benchmark Time CPU Time Old Time New CPU Old CPU New
--------------------------------------------------------------------------------------------------------------------
[BM_memcpy vs. BM_copy]/8 +5.1649 +5.1637 37 230 37 230
[BM_memcpy vs. BM_copy]/64 +21.4352 +21.4374 74 1654 74 1653
[BM_memcpy vs. BM_copy]/512 +143.6022 +143.5865 91 13122 91 13120
[BM_memcpy vs. BM_copy]/1024 +221.5903 +221.4790 120 26679 120 26666
[BM_memcpy vs. BM_copy]/8192 +322.9059 +323.0096 664 215068 664 215053
```
This is a mix of the previous two modes, two (potentially different) benchmark binaries are run, and a different filter is applied to each one.
As you can note, the values in `Time` and `CPU` columns are calculated as `(new - old) / |old|`.
### U test
If there is a sufficient repetition count of the benchmarks, the tool can do
a [U Test](https://en.wikipedia.org/wiki/Mann%E2%80%93Whitney_U_test), of the
null hypothesis that it is equally likely that a randomly selected value from
one sample will be less than or greater than a randomly selected value from a
second sample.
If the calculated p-value is below this value is lower than the significance
level alpha, then the result is said to be statistically significant and the
null hypothesis is rejected. Which in other words means that the two benchmarks
aren't identical.
**WARNING**: requires **LARGE** (no less than 9) number of repetitions to be
meaningful!
================================================
FILE: 3rd/benchmark-1.8.2/docs/user_guide.md
================================================
# User Guide
## Command Line
[Output Formats](#output-formats)
[Output Files](#output-files)
[Running Benchmarks](#running-benchmarks)
[Running a Subset of Benchmarks](#running-a-subset-of-benchmarks)
[Result Comparison](#result-comparison)
[Extra Context](#extra-context)
## Library
[Runtime and Reporting Considerations](#runtime-and-reporting-considerations)
[Setup/Teardown](#setupteardown)
[Passing Arguments](#passing-arguments)
[Custom Benchmark Name](#custom-benchmark-name)
[Calculating Asymptotic Complexity](#asymptotic-complexity)
[Templated Benchmarks](#templated-benchmarks)
[Fixtures](#fixtures)
[Custom Counters](#custom-counters)
[Multithreaded Benchmarks](#multithreaded-benchmarks)
[CPU Timers](#cpu-timers)
[Manual Timing](#manual-timing)
[Setting the Time Unit](#setting-the-time-unit)
[Random Interleaving](random_interleaving.md)
[User-Requested Performance Counters](perf_counters.md)
[Preventing Optimization](#preventing-optimization)
[Reporting Statistics](#reporting-statistics)
[Custom Statistics](#custom-statistics)
[Memory Usage](#memory-usage)
[Using RegisterBenchmark](#using-register-benchmark)
[Exiting with an Error](#exiting-with-an-error)
[A Faster `KeepRunning` Loop](#a-faster-keep-running-loop)
## Benchmarking Tips
[Disabling CPU Frequency Scaling](#disabling-cpu-frequency-scaling)
[Reducing Variance in Benchmarks](reducing_variance.md)
<a name="output-formats" />
## Output Formats
The library supports multiple output formats. Use the
`--benchmark_format=<console|json|csv>` flag (or set the
`BENCHMARK_FORMAT=<console|json|csv>` environment variable) to set
the format type. `console` is the default format.
The Console format is intended to be a human readable format. By default
the format generates color output. Context is output on stderr and the
tabular data on stdout. Example tabular output looks like:
```
Benchmark Time(ns) CPU(ns) Iterations
----------------------------------------------------------------------
BM_SetInsert/1024/1 28928 29349 23853 133.097kB/s 33.2742k items/s
BM_SetInsert/1024/8 32065 32913 21375 949.487kB/s 237.372k items/s
BM_SetInsert/1024/10 33157 33648 21431 1.13369MB/s 290.225k items/s
```
The JSON format outputs human readable json split into two top level attributes.
The `context` attribute contains information about the run in general, including
information about the CPU and the date.
The `benchmarks` attribute contains a list of every benchmark run. Example json
output looks like:
```json
{
"context": {
"date": "2015/03/17-18:40:25",
"num_cpus": 40,
"mhz_per_cpu": 2801,
"cpu_scaling_enabled": false,
"build_type": "debug"
},
"benchmarks": [
{
"name": "BM_SetInsert/1024/1",
"iterations": 94877,
"real_time": 29275,
"cpu_time": 29836,
"bytes_per_second": 134066,
"items_per_second": 33516
},
{
"name": "BM_SetInsert/1024/8",
"iterations": 21609,
"real_time": 32317,
"cpu_time": 32429,
"bytes_per_second": 986770,
"items_per_second": 246693
},
{
"name": "BM_SetInsert/1024/10",
"iterations": 21393,
"real_time": 32724,
"cpu_time": 33355,
"bytes_per_second": 1199226,
"items_per_second": 299807
}
]
}
```
The CSV format outputs comma-separated values. The `context` is output on stderr
and the CSV itself on stdout. Example CSV output looks like:
```
name,iterations,real_time,cpu_time,bytes_per_second,items_per_second,label
"BM_SetInsert/1024/1",65465,17890.7,8407.45,475768,118942,
"BM_SetInsert/1024/8",116606,18810.1,9766.64,3.27646e+06,819115,
"BM_SetInsert/1024/10",106365,17238.4,8421.53,4.74973e+06,1.18743e+06,
```
<a name="output-files" />
## Output Files
Write benchmark results to a file with the `--benchmark_out=<filename>` option
(or set `BENCHMARK_OUT`). Specify the output format with
`--benchmark_out_format={json|console|csv}` (or set
`BENCHMARK_OUT_FORMAT={json|console|csv}`). Note that the 'csv' reporter is
deprecated and the saved `.csv` file
[is not parsable](https://github.com/google/benchmark/issues/794) by csv
parsers.
Specifying `--benchmark_out` does not suppress the console output.
<a name="running-benchmarks" />
## Running Benchmarks
Benchmarks are executed by running the produced binaries. Benchmarks binaries,
by default, accept options that may be specified either through their command
line interface or by setting environment variables before execution. For every
`--option_flag=<value>` CLI switch, a corresponding environment variable
`OPTION_FLAG=<value>` exist and is used as default if set (CLI switches always
prevails). A complete list of CLI options is available running benchmarks
with the `--help` switch.
<a name="running-a-subset-of-benchmarks" />
## Running a Subset of Benchmarks
The `--benchmark_filter=<regex>` option (or `BENCHMARK_FILTER=<regex>`
environment variable) can be used to only run the benchmarks that match
the specified `<regex>`. For example:
```bash
$ ./run_benchmarks.x --benchmark_filter=BM_memcpy/32
Run on (1 X 2300 MHz CPU )
2016-06-25 19:34:24
Benchmark Time CPU Iterations
----------------------------------------------------
BM_memcpy/32 11 ns 11 ns 79545455
BM_memcpy/32k 2181 ns 2185 ns 324074
BM_memcpy/32 12 ns 12 ns 54687500
BM_memcpy/32k 1834 ns 1837 ns 357143
```
## Disabling Benchmarks
It is possible to temporarily disable benchmarks by renaming the benchmark
function to have the prefix "DISABLED_". This will cause the benchmark to
be skipped at runtime.
<a name="result-comparison" />
## Result comparison
It is possible to compare the benchmarking results.
See [Additional Tooling Documentation](tools.md)
<a name="extra-context" />
## Extra Context
Sometimes it's useful to add extra context to the content printed before the
results. By default this section includes information about the CPU on which
the benchmarks are running. If you do want to add more context, you can use
the `benchmark_context` command line flag:
```bash
$ ./run_benchmarks --benchmark_context=pwd=`pwd`
Run on (1 x 2300 MHz CPU)
pwd: /home/user/benchmark/
Benchmark Time CPU Iterations
----------------------------------------------------
BM_memcpy/32 11 ns 11 ns 79545455
BM_memcpy/32k 2181 ns 2185 ns 324074
```
You can get the same effect with the API:
```c++
benchmark::AddCustomContext("foo", "bar");
```
Note that attempts to add a second value with the same key will fail with an
error message.
<a name="runtime-and-reporting-considerations" />
## Runtime and Reporting Considerations
When the benchmark binary is executed, each benchmark function is run serially.
The number of iterations to run is determined dynamically by running the
benchmark a few times and measuring the time taken and ensuring that the
ultimate result will be statistically stable. As such, faster benchmark
functions will be run for more iterations than slower benchmark functions, and
the number of iterations is thus reported.
In all cases, the number of iterations for which the benchmark is run is
governed by the amount of time the benchmark takes. Concretely, the number of
iterations is at least one, not more than 1e9, until CPU time is greater than
the minimum time, or the wallclock time is 5x minimum time. The minimum time is
set per benchmark by calling `MinTime` on the registered benchmark object.
Furthermore warming up a benchmark might be necessary in order to get
stable results because of e.g caching effects of the code under benchmark.
Warming up means running the benchmark a given amount of time, before
results are actually taken into account. The amount of time for which
the warmup should be run can be set per benchmark by calling
`MinWarmUpTime` on the registered benchmark object or for all benchmarks
using the `--benchmark_min_warmup_time` command-line option. Note that
`MinWarmUpTime` will overwrite the value of `--benchmark_min_warmup_time`
for the single benchmark. How many iterations the warmup run of each
benchmark takes is determined the same way as described in the paragraph
above. Per default the warmup phase is set to 0 seconds and is therefore
disabled.
Average timings are then reported over the iterations run. If multiple
repetitions are requested using the `--benchmark_repetitions` command-line
option, or at registration time, the benchmark function will be run several
times and statistical results across these repetitions will also be reported.
As well as the per-benchmark entries, a preamble in the report will include
information about the machine on which the benchmarks are run.
<a name="setup-teardown" />
## Setup/Teardown
Global setup/teardown specific to each benchmark can be done by
passing a callback to Setup/Teardown:
The setup/teardown callbacks will be invoked once for each benchmark. If the
benchmark is multi-threaded (will run in k threads), they will be invoked
exactly once before each run with k threads.
If the benchmark uses different size groups of threads, the above will be true
for each size group.
Eg.,
```c++
static void DoSetup(const benchmark::State& state) {
}
static void DoTeardown(const benchmark::State& state) {
}
static void BM_func(benchmark::State& state) {...}
BENCHMARK(BM_func)->Arg(1)->Arg(3)->Threads(16)->Threads(32)->Setup(DoSetup)->Teardown(DoTeardown);
```
In this example, `DoSetup` and `DoTearDown` will be invoked 4 times each,
specifically, once for each of this family:
- BM_func_Arg_1_Threads_16, BM_func_Arg_1_Threads_32
- BM_func_Arg_3_Threads_16, BM_func_Arg_3_Threads_32
<a name="passing-arguments" />
## Passing Arguments
Sometimes a family of benchmarks can be implemented with just one routine that
takes an extra argument to specify which one of the family of benchmarks to
run. For example, the following code defines a family of benchmarks for
measuring the speed of `memcpy()` calls of different lengths:
```c++
static void BM_memcpy(benchmark::State& state) {
char* src = new char[state.range(0)];
char* dst = new char[state.range(0)];
memset(src, 'x', state.range(0));
for (auto _ : state)
memcpy(dst, src, state.range(0));
state.SetBytesProcessed(int64_t(state.iterations()) *
int64_t(state.range(0)));
delete[] src;
delete[] dst;
}
BENCHMARK(BM_memcpy)->Arg(8)->Arg(64)->Arg(512)->Arg(4<<10)->Arg(8<<10);
```
The preceding code is quite repetitive, and can be replaced with the following
short-hand. The following invocation will pick a few appropriate arguments in
the specified range and will generate a benchmark for each such argument.
```c++
BENCHMARK(BM_memcpy)->Range(8, 8<<10);
```
By default the arguments in the range are generated in multiples of eight and
the command above selects [ 8, 64, 512, 4k, 8k ]. In the following code the
range multiplier is changed to multiples of two.
```c++
BENCHMARK(BM_memcpy)->RangeMultiplier(2)->Range(8, 8<<10);
```
Now arguments generated are [ 8, 16, 32, 64, 128, 256, 512, 1024, 2k, 4k, 8k ].
The preceding code shows a method of defining a sparse range. The following
example shows a method of defining a dense range. It is then used to benchmark
the performance of `std::vector` initialization for uniformly increasing sizes.
```c++
static void BM_DenseRange(benchmark::State& state) {
for(auto _ : state) {
std::vector<int> v(state.range(0), state.range(0));
auto data = v.data();
benchmark::DoNotOptimize(data);
benchmark::ClobberMemory();
}
}
BENCHMARK(BM_DenseRange)->DenseRange(0, 1024, 128);
```
Now arguments generated are [ 0, 128, 256, 384, 512, 640, 768, 896, 1024 ].
You might have a benchmark that depends on two or more inputs. For example, the
following code defines a family of benchmarks for measuring the speed of set
insertion.
```c++
static void BM_SetInsert(benchmark::State& state) {
std::set<int> data;
for (auto _ : state) {
state.PauseTiming();
data = ConstructRandomSet(state.range(0));
state.ResumeTiming();
for (int j = 0; j < state.range(1); ++j)
data.insert(RandomNumber());
}
}
BENCHMARK(BM_SetInsert)
->Args({1<<10, 128})
->Args({2<<10, 128})
->Args({4<<10, 128})
->Args({8<<10, 128})
->Args({1<<10, 512})
->Args({2<<10, 512})
->Args({4<<10, 512})
->Args({8<<10, 512});
```
The preceding code is quite repetitive, and can be replaced with the following
short-hand. The following macro will pick a few appropriate arguments in the
product of the two specified ranges and will generate a benchmark for each such
pair.
<!-- {% raw %} -->
```c++
BENCHMARK(BM_SetInsert)->Ranges({{1<<10, 8<<10}, {128, 512}});
```
<!-- {% endraw %} -->
Some benchmarks may require specific argument values that cannot be expressed
with `Ranges`. In this case, `ArgsProduct` offers the ability to generate a
benchmark input for each combination in the product of the supplied vectors.
<!-- {% raw %} -->
```c++
BENCHMARK(BM_SetInsert)
->ArgsProduct({{1<<10, 3<<10, 8<<10}, {20, 40, 60, 80}})
// would generate the same benchmark arguments as
BENCHMARK(BM_SetInsert)
->Args({1<<10, 20})
->Args({3<<10, 20})
->Args({8<<10, 20})
->Args({3<<10, 40})
->Args({8<<10, 40})
->Args({1<<10, 40})
->Args({1<<10, 60})
->Args({3<<10, 60})
->Args({8<<10, 60})
->Args({1<<10, 80})
->Args({3<<10, 80})
->Args({8<<10, 80});
```
<!-- {% endraw %} -->
For the most common scenarios, helper methods for creating a list of
integers for a given sparse or dense range are provided.
```c++
BENCHMARK(BM_SetInsert)
->ArgsProduct({
benchmark::CreateRange(8, 128, /*multi=*/2),
benchmark::CreateDenseRange(1, 4, /*step=*/1)
})
// would generate the same benchmark arguments as
BENCHMARK(BM_SetInsert)
->ArgsProduct({
{8, 16, 32, 64, 128},
{1, 2, 3, 4}
});
```
For more complex patterns of inputs, passing a custom function to `Apply` allows
programmatic specification of an arbitrary set of arguments on which to run the
benchmark. The following example enumerates a dense range on one parameter,
and a sparse range on the second.
```c++
static void CustomArguments(benchmark::internal::Benchmark* b) {
for (int i = 0; i <= 10; ++i)
for (int j = 32; j <= 1024*1024; j *= 8)
b->Args({i, j});
}
BENCHMARK(BM_SetInsert)->Apply(CustomArguments);
```
### Passing Arbitrary Arguments to a Benchmark
In C++11 it is possible to define a benchmark that takes an arbitrary number
of extra arguments. The `BENCHMARK_CAPTURE(func, test_case_name, ...args)`
macro creates a benchmark that invokes `func` with the `benchmark::State` as
the first argument followed by the specified `args...`.
The `test_case_name` is appended to the name of the benchmark and
should describe the values passed.
```c++
template <class ...Args>
void BM_takes_args(benchmark::State& state, Args&&... args) {
auto args_tuple = std::make_tuple(std::move(args)...);
for (auto _ : state) {
std::cout << std::get<0>(args_tuple) << ": " << std::get<1>(args_tuple)
<< '\n';
[...]
}
}
// Registers a benchmark named "BM_takes_args/int_string_test" that passes
// the specified values to `args`.
BENCHMARK_CAPTURE(BM_takes_args, int_string_test, 42, std::string("abc"));
// Registers the same benchmark "BM_takes_args/int_test" that passes
// the specified values to `args`.
BENCHMARK_CAPTURE(BM_takes_args, int_test, 42, 43);
```
Note that elements of `...args` may refer to global variables. Users should
avoid modifying global state inside of a benchmark.
<a name="asymptotic-complexity" />
## Calculating Asymptotic Complexity (Big O)
Asymptotic complexity might be calculated for a family of benchmarks. The
following code will calculate the coefficient for the high-order term in the
running time and the normalized root-mean square error of string comparison.
```c++
static void BM_StringCompare(benchmark::State& state) {
std::string s1(state.range(0), '-');
std::string s2(state.range(0), '-');
for (auto _ : state) {
auto comparison_result = s1.compare(s2);
benchmark::DoNotOptimize(comparison_result);
}
state.SetComplexityN(state.range(0));
}
BENCHMARK(BM_StringCompare)
->RangeMultiplier(2)->Range(1<<10, 1<<18)->Complexity(benchmark::oN);
```
As shown in the following invocation, asymptotic complexity might also be
calculated automatically.
```c++
BENCHMARK(BM_StringCompare)
->RangeMultiplier(2)->Range(1<<10, 1<<18)->Complexity();
```
The following code will specify asymptotic complexity with a lambda function,
that might be used to customize high-order term calculation.
```c++
BENCHMARK(BM_StringCompare)->RangeMultiplier(2)
->Range(1<<10, 1<<18)->Complexity([](benchmark::IterationCount n)->double{return n; });
```
<a name="custom-benchmark-name" />
## Custom Benchmark Name
You can change the benchmark's name as follows:
```c++
BENCHMARK(BM_memcpy)->Name("memcpy")->RangeMultiplier(2)->Range(8, 8<<10);
```
The invocation will execute the benchmark as before using `BM_memcpy` but changes
the prefix in the report to `memcpy`.
<a name="templated-benchmarks" />
## Templated Benchmarks
This example produces and consumes messages of size `sizeof(v)` `range_x`
times. It also outputs throughput in the absence of multiprogramming.
```c++
template <class Q> void BM_Sequential(benchmark::State& state) {
Q q;
typename Q::value_type v;
for (auto _ : state) {
for (int i = state.range(0); i--; )
q.push(v);
for (int e = state.range(0); e--; )
q.Wait(&v);
}
// actually messages, not bytes:
state.SetBytesProcessed(
static_cast<int64_t>(state.iterations())*state.range(0));
}
// C++03
BENCHMARK_TEMPLATE(BM_Sequential, WaitQueue<int>)->Range(1<<0, 1<<10);
// C++11 or newer, you can use the BENCHMARK macro with template parameters:
BENCHMARK(BM_Sequential<WaitQueue<int>>)->Range(1<<0, 1<<10);
```
Three macros are provided for adding benchmark templates.
```c++
#ifdef BENCHMARK_HAS_CXX11
#define BENCHMARK(func<...>) // Takes any number of parameters.
#else // C++ < C++11
#define BENCHMARK_TEMPLATE(func, arg1)
#endif
#define BENCHMARK_TEMPLATE1(func, arg1)
#define BENCHMARK_TEMPLATE2(func, arg1, arg2)
```
<a name="fixtures" />
## Fixtures
Fixture tests are created by first defining a type that derives from
`::benchmark::Fixture` and then creating/registering the tests using the
following macros:
* `BENCHMARK_F(ClassName, Method)`
* `BENCHMARK_DEFINE_F(ClassName, Method)`
* `BENCHMARK_REGISTER_F(ClassName, Method)`
For Example:
```c++
class MyFixture : public benchmark::Fixture {
public:
void SetUp(const ::benchmark::State& state) {
}
void TearDown(const ::benchmark::State& state) {
}
};
BENCHMARK_F(MyFixture, FooTest)(benchmark::State& st) {
for (auto _ : st) {
...
}
}
BENCHMARK_DEFINE_F(MyFixture, BarTest)(benchmark::State& st) {
for (auto _ : st) {
...
}
}
/* BarTest is NOT registered */
BENCHMARK_REGISTER_F(MyFixture, BarTest)->Threads(2);
/* BarTest is now registered */
```
### Templated Fixtures
Also you can create templated fixture by using the following macros:
* `BENCHMARK_TEMPLATE_F(ClassName, Method, ...)`
* `BENCHMARK_TEMPLATE_DEFINE_F(ClassName, Method, ...)`
For example:
```c++
template<typename T>
class MyFixture : public benchmark::Fixture {};
BENCHMARK_TEMPLATE_F(MyFixture, IntTest, int)(benchmark::State& st) {
for (auto _ : st) {
...
}
}
BENCHMARK_TEMPLATE_DEFINE_F(MyFixture, DoubleTest, double)(benchmark::State& st) {
for (auto _ : st) {
...
}
}
BENCHMARK_REGISTER_F(MyFixture, DoubleTest)->Threads(2);
```
<a name="custom-counters" />
## Custom Counters
You can add your own counters with user-defined names. The example below
will add columns "Foo", "Bar" and "Baz" in its output:
```c++
static void UserCountersExample1(benchmark::State& state) {
double numFoos = 0, numBars = 0, numBazs = 0;
for (auto _ : state) {
// ... count Foo,Bar,Baz events
}
state.counters["Foo"] = numFoos;
state.counters["Bar"] = numBars;
state.counters["Baz"] = numBazs;
}
```
The `state.counters` object is a `std::map` with `std::string` keys
and `Counter` values. The latter is a `double`-like class, via an implicit
conversion to `double&`. Thus you can use all of the standard arithmetic
assignment operators (`=,+=,-=,*=,/=`) to change the value of each counter.
In multithreaded benchmarks, each counter is set on the calling thread only.
When the benchmark finishes, the counters from each thread will be summed;
the resulting sum is the value which will be shown for the benchmark.
The `Counter` constructor accepts three parameters: the value as a `double`
; a bit flag which allows you to show counters as rates, and/or as per-thread
iteration, and/or as per-thread averages, and/or iteration invariants,
and/or finally inverting the result; and a flag specifying the 'unit' - i.e.
is 1k a 1000 (default, `benchmark::Counter::OneK::kIs1000`), or 1024
(`benchmark::Counter::OneK::kIs1024`)?
```c++
// sets a simple counter
state.counters["Foo"] = numFoos;
// Set the counter as a rate. It will be presented divided
// by the duration of the benchmark.
// Meaning: per one second, how many 'foo's are processed?
state.counters["FooRate"] = Counter(numFoos, benchmark::Counter::kIsRate);
// Set the counter as a rate. It will be presented divided
// by the duration of the benchmark, and the result inverted.
// Meaning: how many seconds it takes to process one 'foo'?
state.counters["FooInvRate"] = Counter(numFoos, benchmark::Counter::kIsRate | benchmark::Counter::kInvert);
// Set the counter as a thread-average quantity. It will
// be presented divided by the number of threads.
state.counters["FooAvg"] = Counter(numFoos, benchmark::Counter::kAvgThreads);
// There's also a combined flag:
state.counters["FooAvgRate"] = Counter(numFoos,benchmark::Counter::kAvgThreadsRate);
// This says that we process with the rate of state.range(0) bytes every iteration:
state.counters["BytesProcessed"] = Counter(state.range(0), benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::OneK::kIs1024);
```
When you're compiling in C++11 mode or later you can use `insert()` with
`std::initializer_list`:
<!-- {% raw %} -->
```c++
// With C++11, this can be done:
state.counters.insert({{"Foo", numFoos}, {"Bar", numBars}, {"Baz", numBazs}});
// ... instead of:
state.counters["Foo"] = numFoos;
state.counters["Bar"] = numBars;
state.counters["Baz"] = numBazs;
```
<!-- {% endraw %} -->
### Counter Reporting
When using the console reporter, by default, user counters are printed at
the end after the table, the same way as ``bytes_processed`` and
``items_processed``. This is best for cases in which there are few counters,
or where there are only a couple of lines per benchmark. Here's an example of
the default output:
```
------------------------------------------------------------------------------
Benchmark Time CPU Iterations UserCounters...
------------------------------------------------------------------------------
BM_UserCounter/threads:8 2248 ns 10277 ns 68808 Bar=16 Bat=40 Baz=24 Foo=8
BM_UserCounter/threads:1 9797 ns 9788 ns 71523 Bar=2 Bat=5 Baz=3 Foo=1024m
BM_UserCounter/threads:2 4924 ns 9842 ns 71036 Bar=4 Bat=10 Baz=6 Foo=2
BM_UserCounter/threads:4 2589 ns 10284 ns 68012 Bar=8 Bat=20 Baz=12 Foo=4
BM_UserCounter/threads:8 2212 ns 10287 ns 68040 Bar=16 Bat=40 Baz=24 Foo=8
BM_UserCounter/threads:16 1782 ns 10278 ns 68144 Bar=32 Bat=80 Baz=48 Foo=16
BM_UserCounter/threads:32 1291 ns 10296 ns 68256 Bar=64 Bat=160 Baz=96 Foo=32
BM_UserCounter/threads:4 2615 ns 10307 ns 68040 Bar=8 Bat=20 Baz=12 Foo=4
BM_Factorial 26 ns 26 ns 26608979 40320
BM_Factorial/real_time 26 ns 26 ns 26587936 40320
BM_CalculatePiRange/1 16 ns 16 ns 45704255 0
BM_CalculatePiRange/8 73 ns 73 ns 9520927 3.28374
BM_CalculatePiRange/64 609 ns 609 ns 1140647 3.15746
BM_CalculatePiRange/512 4900 ns 4901 ns 142696 3.14355
```
If this doesn't suit you, you can print each counter as a table column by
passing the flag `--benchmark_counters_tabular=true` to the benchmark
application. This is best for cases in which there are a lot of counters, or
a lot of lines per individual benchmark. Note that this will trigger a
reprinting of the table header any time the counter set changes between
individual benchmarks. Here's an example of corresponding output when
`--benchmark_counters_tabular=true` is passed:
```
---------------------------------------------------------------------------------------
Benchmark Time CPU Iterations Bar Bat Baz Foo
---------------------------------------------------------------------------------------
BM_UserCounter/threads:8 2198 ns 9953 ns 70688 16 40 24 8
BM_UserCounter/threads:1 9504 ns 9504 ns 73787 2 5 3 1
BM_UserCounter/threads:2 4775 ns 9550 ns 72606 4 10 6 2
BM_UserCounter/threads:4 2508 ns 9951 ns 70332 8 20 12 4
BM_UserCounter/threads:8 2055 ns 9933 ns 70344 16 40 24 8
BM_UserCounter/threads:16 1610 ns 9946 ns 70720 32 80 48 16
BM_UserCounter/threads:32 1192 ns 9948 ns 70496 64 160 96 32
BM_UserCounter/threads:4 2506 ns 9949 ns 70332 8 20 12 4
--------------------------------------------------------------
Benchmark Time CPU Iterations
--------------------------------------------------------------
BM_Factorial 26 ns 26 ns 26392245 40320
BM_Factorial/real_time 26 ns 26 ns 26494107 40320
BM_CalculatePiRange/1 15 ns 15 ns 45571597 0
BM_CalculatePiRange/8 74 ns 74 ns 9450212 3.28374
BM_CalculatePiRange/64 595 ns 595 ns 1173901 3.15746
BM_CalculatePiRange/512 4752 ns 4752 ns 147380 3.14355
BM_CalculatePiRange/4k 37970 ns 37972 ns 18453 3.14184
BM_CalculatePiRange/32k 303733 ns 303744 ns 2305 3.14162
BM_CalculatePiRange/256k 2434095 ns 2434186 ns 288 3.1416
BM_CalculatePiRange/1024k 9721140 ns 9721413 ns 71 3.14159
BM_CalculatePi/threads:8 2255 ns 9943 ns 70936
```
Note above the additional header printed when the benchmark changes from
``BM_UserCounter`` to ``BM_Factorial``. This is because ``BM_Factorial`` does
not have the same counter set as ``BM_UserCounter``.
<a name="multithreaded-benchmarks"/>
## Multithreaded Benchmarks
In a multithreaded test (benchmark invoked by multiple threads simultaneously),
it is guaranteed that none of the threads will start until all have reached
the start of the benchmark loop, and all will have finished before any thread
exits the benchmark loop. (This behavior is also provided by the `KeepRunning()`
API) As such, any global setup or teardown can be wrapped in a check against the thread
index:
```c++
static void BM_MultiThreaded(benchmark::State& state) {
if (state.thread_index() == 0) {
// Setup code here.
}
for (auto _ : state) {
// Run the test as normal.
}
if (state.thread_index() == 0) {
// Teardown code here.
}
}
BENCHMARK(BM_MultiThreaded)->Threads(2);
```
To run the benchmark across a range of thread counts, instead of `Threads`, use
`ThreadRange`. This takes two parameters (`min_threads` and `max_threads`) and
runs the benchmark once for values in the inclusive range. For example:
```c++
BENCHMARK(BM_MultiThreaded)->ThreadRange(1, 8);
```
will run `BM_MultiThreaded` with thread counts 1, 2, 4, and 8.
If the benchmarked code itself uses threads and you want to compare it to
single-threaded code, you may want to use real-time ("wallclock") measurements
for latency comparisons:
```c++
BENCHMARK(BM_test)->Range(8, 8<<10)->UseRealTime();
```
Without `UseRealTime`, CPU time is used by default.
<a name="cpu-timers" />
## CPU Timers
By default, the CPU timer only measures the time spent by the main thread.
If the benchmark itself uses threads internally, this measurement may not
be what you are looking for. Instead, there is a way to measure the total
CPU usage of the process, by all the threads.
```c++
void callee(int i);
static void MyMain(int size) {
#pragma omp parallel for
for(int i = 0; i < size; i++)
callee(i);
}
static void BM_OpenMP(benchmark::State& state) {
for (auto _ : state)
MyMain(state.range(0));
}
// Measure the time spent by the main thread, use it to decide for how long to
// run the benchmark loop. Depending on the internal implementation detail may
// measure to anywhere from near-zero (the overhead spent before/after work
// handoff to worker thread[s]) to the whole single-thread time.
BENCHMARK(BM_OpenMP)->Range(8, 8<<10);
// Measure the user-visible time, the wall clock (literally, the time that
// has passed on the clock on the wall), use it to decide for how long to
// run the benchmark loop. This will always be meaningful, and will match the
// time spent by the main thread in single-threaded case, in general decreasing
// with the number of internal threads doing the work.
BENCHMARK(BM_OpenMP)->Range(8, 8<<10)->UseRealTime();
// Measure the total CPU consumption, use it to decide for how long to
// run the benchmark loop. This will always measure to no less than the
// time spent by the main thread in single-threaded case.
BENCHMARK(BM_OpenMP)->Range(8, 8<<10)->MeasureProcessCPUTime();
// A mixture of the last two. Measure the total CPU consumption, but use the
// wall clock to decide for how long to run the benchmark loop.
BENCHMARK(BM_OpenMP)->Range(8, 8<<10)->MeasureProcessCPUTime()->UseRealTime();
```
### Controlling Timers
Normally, the entire duration of the work loop (`for (auto _ : state) {}`)
is measured. But sometimes, it is necessary to do some work inside of
that loop, every iteration, but without counting that time to the benchmark time.
That is possible, although it is not recommended, since it has high overhead.
<!-- {% raw %} -->
```c++
static void BM_SetInsert_With_Timer_Control(benchmark::State& state) {
std::set<int> data;
for (auto _ : state) {
state.PauseTiming(); // Stop timers. They will not count until they are resumed.
data = ConstructRandomSet(state.range(0)); // Do something that should not be measured
state.ResumeTiming(); // And resume timers. They are now counting again.
// The rest will be measured.
for (int j = 0; j < state.range(1); ++j)
data.insert(RandomNumber());
}
}
BENCHMARK(BM_SetInsert_With_Timer_Control)->Ranges({{1<<10, 8<<10}, {128, 512}});
```
<!-- {% endraw %} -->
<a name="manual-timing" />
## Manual Timing
For benchmarking something for which neither CPU time nor real-time are
correct or accurate enough, completely manual timing is supported using
the `UseManualTime` function.
When `UseManualTime` is used, the benchmarked code must call
`SetIterationTime` once per iteration of the benchmark loop to
report the manually measured time.
An example use case for this is benchmarking GPU execution (e.g. OpenCL
or CUDA kernels, OpenGL or Vulkan or Direct3D draw calls), which cannot
be accurately measured using CPU time or real-time. Instead, they can be
measured accurately using a dedicated API, and these measurement results
can be reported back with `SetIterationTime`.
```c++
static void BM_ManualTiming(benchmark::State& state) {
int microseconds = state.range(0);
std::chrono::duration<double, std::micro> sleep_duration {
static_cast<double>(microseconds)
};
for (auto _ : state) {
auto start = std::chrono::high_resolution_clock::now();
// Simulate some useful workload with a sleep
std::this_thread::sleep_for(sleep_duration);
auto end = std::chrono::high_resolution_clock::now();
auto elapsed_seconds =
std::chrono::duration_cast<std::chrono::duration<double>>(
end - start);
state.SetIterationTime(elapsed_seconds.count());
}
}
BENCHMARK(BM_ManualTiming)->Range(1, 1<<17)->UseManualTime();
```
<a name="setting-the-time-unit" />
## Setting the Time Unit
If a benchmark runs a few milliseconds it may be hard to visually compare the
measured times, since the output data is given in nanoseconds per default. In
order to manually set the time unit, you can specify it manually:
```c++
BENCHMARK(BM_test)->Unit(benchmark::kMillisecond);
```
Additionally the default time unit can be set globally with the
`--benchmark_time_unit={ns|us|ms|s}` command line argument. The argument only
affects benchmarks where the time unit is not set explicitly.
<a name="preventing-optimization" />
## Preventing Optimization
To prevent a value or expression from being optimized away by the compiler
the `benchmark::DoNotOptimize(...)` and `benchmark::ClobberMemory()`
functions can be used.
```c++
static void BM_test(benchmark::State& state) {
for (auto _ : state) {
int x = 0;
for (int i=0; i < 64; ++i) {
benchmark::DoNotOptimize(x += i);
}
}
}
```
`DoNotOptimize(<expr>)` forces the *result* of `<expr>` to be stored in either
memory or a register. For GNU based compilers it acts as read/write barrier
for global memory. More specifically it forces the compiler to flush pending
writes to memory and reload any other values as necessary.
Note that `DoNotOptimize(<expr>)` does not prevent optimizations on `<expr>`
in any way. `<expr>` may even be removed entirely when the result is already
known. For example:
```c++
/* Example 1: `<expr>` is removed entirely. */
int foo(int x) { return x + 42; }
while (...) DoNotOptimize(foo(0)); // Optimized to DoNotOptimize(42);
/* Example 2: Result of '<expr>' is only reused */
int bar(int) __attribute__((const));
while (...) DoNotOptimize(bar(0)); // Optimized to:
// int __result__ = bar(0);
// while (...) DoNotOptimize(__result__);
```
The second tool for preventing optimizations is `ClobberMemory()`. In essence
`ClobberMemory()` forces the compiler to perform all pending writes to global
memory. Memory managed by block scope objects must be "escaped" using
`DoNotOptimize(...)` before it can be clobbered. In the below example
`ClobberMemory()` prevents the call to `v.push_back(42)` from being optimized
away.
```c++
static void BM_vector_push_back(benchmark::State& state) {
for (auto _ : state) {
std::vector<int> v;
v.reserve(1);
auto data = v.data(); // Allow v.data() to be clobbered. Pass as non-const
benchmark::DoNotOptimize(data); // lvalue to avoid undesired compiler optimizations
v.push_back(42);
benchmark::ClobberMemory(); // Force 42 to be written to memory.
}
}
```
Note that `ClobberMemory()` is only available for GNU or MSVC based compilers.
<a name="reporting-statistics" />
## Statistics: Reporting the Mean, Median and Standard Deviation / Coefficient of variation of Repeated Benchmarks
By default each benchmark is run once and that single result is reported.
However benchmarks are often noisy and a single result may not be representative
of the overall behavior. For this reason it's possible to repeatedly rerun the
benchmark.
The number of runs of each benchmark is specified globally by the
`--benchmark_repetitions` flag or on a per benchmark basis by calling
`Repetitions` on the registered benchmark object. When a benchmark is run more
than once the mean, median, standard deviation and coefficient of variation
of the runs will be reported.
Additionally the `--benchmark_report_aggregates_only={true|false}`,
`--benchmark_display_aggregates_only={true|false}` flags or
`ReportAggregatesOnly(bool)`, `DisplayAggregatesOnly(bool)` functions can be
used to change how repeated tests are reported. By default the result of each
repeated run is reported. When `report aggregates only` option is `true`,
only the aggregates (i.e. mean, median, standard deviation and coefficient
of variation, maybe complexity measurements if they were requested) of the runs
is reported, to both the reporters - standard output (console), and the file.
However when only the `display aggregates only` option is `true`,
only the aggregates are displayed in the standard output, while the file
output still contains everything.
Calling `ReportAggregatesOnly(bool)` / `DisplayAggregatesOnly(bool)` on a
registered benchmark object overrides the value of the appropriate flag for that
benchmark.
<a name="custom-statistics" />
## Custom Statistics
While having these aggregates is nice, this may not be enough for everyone.
For example you may want to know what the largest observation is, e.g. because
you have some real-time constraints. This is easy. The following code will
specify a custom statistic to be calculated, defined by a lambda function.
```c++
void BM_spin_empty(benchmark::State& state) {
for (auto _ : state) {
for (int x = 0; x < state.range(0); ++x) {
benchmark::DoNotOptimize(x);
}
}
}
BENCHMARK(BM_spin_empty)
->ComputeStatistics("max", [](const std::vector<double>& v) -> double {
return *(std::max_element(std::begin(v), std::end(v)));
})
->Arg(512);
```
While usually the statistics produce values in time units,
you can also produce percentages:
```c++
void BM_spin_empty(benchmark::State& state) {
for (auto _ : state) {
for (int x = 0; x < state.range(0); ++x) {
benchmark::DoNotOptimize(x);
}
}
}
BENCHMARK(BM_spin_empty)
->ComputeStatistics("ratio", [](const std::vector<double>& v) -> double {
return std::begin(v) / std::end(v);
}, benchmark::StatisticUnit::kPercentage)
->Arg(512);
```
<a name="memory-usage" />
## Memory Usage
It's often useful to also track memory usage for benchmarks, alongside CPU
performance. For this reason, benchmark offers the `RegisterMemoryManager`
method that allows a custom `MemoryManager` to be injected.
If set, the `MemoryManager::Start` and `MemoryManager::Stop` methods will be
called at the start and end of benchmark runs to allow user code to fill out
a report on the number of allocations, bytes used, etc.
This data will then be reported alongside other performance data, currently
only when using JSON output.
<a name="using-register-benchmark" />
## Using RegisterBenchmark(name, fn, args...)
The `RegisterBenchmark(name, func, args...)` function provides an alternative
way to create and register benchmarks.
`RegisterBenchmark(name, func, args...)` creates, registers, and returns a
pointer to a new benchmark with the specified `name` that invokes
`func(st, args...)` where `st` is a `benchmark::State` object.
Unlike the `BENCHMARK` registration macros, which can only be used at the global
scope, the `RegisterBenchmark` can be called anywhere. This allows for
benchmark tests to be registered programmatically.
Additionally `RegisterBenchmark` allows any callable object to be registered
as a benchmark. Including capturing lambdas and function objects.
For Example:
```c++
auto BM_test = [](benchmark::State& st, auto Inputs) { /* ... */ };
int main(int argc, char** argv) {
for (auto& test_input : { /* ... */ })
benchmark::RegisterBenchmark(test_input.name(), BM_test, test_input);
benchmark::Initialize(&argc, argv);
benchmark::RunSpecifiedBenchmarks();
benchmark::Shutdown();
}
```
<a name="exiting-with-an-error" />
## Exiting with an Error
When errors caused by external influences, such as file I/O and network
communication, occur within a benchmark the
`State::SkipWithError(const std::string& msg)` function can be used to skip that run
of benchmark and report the error. Note that only future iterations of the
`KeepRunning()` are skipped. For the ranged-for version of the benchmark loop
Users must explicitly exit the loop, otherwise all iterations will be performed.
Users may explicitly return to exit the benchmark immediately.
The `SkipWithError(...)` function may be used at any point within the benchmark,
including before and after the benchmark loop. Moreover, if `SkipWithError(...)`
has been used, it is not required to reach the benchmark loop and one may return
from the benchmark function early.
For example:
```c++
static void BM_test(benchmark::State& state) {
auto resource = GetResource();
if (!resource.good()) {
state.SkipWithError("Resource is not good!");
// KeepRunning() loop will not be entered.
}
while (state.KeepRunning()) {
auto data = resource.read_data();
if (!resource.good()) {
state.SkipWithError("Failed to read data!");
break; // Needed to skip the rest of the iteration.
}
do_stuff(data);
}
}
static void BM_test_ranged_fo(benchmark::State & state) {
auto resource = GetResource();
if (!resource.good()) {
state.SkipWithError("Resource is not good!");
return; // Early return is allowed when SkipWithError() has been used.
}
for (auto _ : state) {
auto data = resource.read_data();
if (!resource.good()) {
state.SkipWithError("Failed to read data!");
break; // REQUIRED to prevent all further iterations.
}
do_stuff(data);
}
}
```
<a name="a-faster-keep-running-loop" />
## A Faster KeepRunning Loop
In C++11 mode, a ranged-based for loop should be used in preference to
the `KeepRunning` loop for running the benchmarks. For example:
```c++
static void BM_Fast(benchmark::State &state) {
for (auto _ : state) {
FastOperation();
}
}
BENCHMARK(BM_Fast);
```
The reason the ranged-for loop is faster than using `KeepRunning`, is
because `KeepRunning` requires a memory load and store of the iteration count
ever iteration, whereas the ranged-for variant is able to keep the iteration count
in a register.
For example, an empty inner loop of using the ranged-based for method looks like:
```asm
# Loop Init
mov rbx, qword ptr [r14 + 104]
call benchmark::State::StartKeepRunning()
test rbx, rbx
je .LoopEnd
.LoopHeader: # =>This Inner Loop Header: Depth=1
add rbx, -1
jne .LoopHeader
.LoopEnd:
```
Compared to an empty `KeepRunning` loop, which looks like:
```asm
.LoopHeader: # in Loop: Header=BB0_3 Depth=1
cmp byte ptr [rbx], 1
jne .LoopInit
.LoopBody: # =>This Inner Loop Header: Depth=1
mov rax, qword ptr [rbx + 8]
lea rcx, [rax + 1]
mov qword ptr [rbx + 8], rcx
cmp rax, qword ptr [rbx + 104]
jb .LoopHeader
jmp .LoopEnd
.LoopInit:
mov rdi, rbx
call benchmark::State::StartKeepRunning()
jmp .LoopBody
.LoopEnd:
```
Unless C++03 compatibility is required, the ranged-for variant of writing
the benchmark loop should be preferred.
<a name="disabling-cpu-frequency-scaling" />
## Disabling CPU Frequency Scaling
If you see this error:
```
***WARNING*** CPU scaling is enabled, the benchmark real time measurements may
be noisy and will incur extra overhead.
```
you might want to disable the CPU frequency scaling while running the
benchmark, as well as consider other ways to stabilize the performance of
your system while benchmarking.
See [Reducing Variance](reducing_variance.md) for more information.
================================================
FILE: 3rd/benchmark-1.8.2/include/benchmark/benchmark.h
================================================
// Copyright 2015 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Support for registering benchmarks for functions.
/* Example usage:
// Define a function that executes the code to be measured a
// specified number of times:
static void BM_StringCreation(benchmark::State& state) {
for (auto _ : state)
std::string empty_string;
}
// Register the function as a benchmark
BENCHMARK(BM_StringCreation);
// Define another benchmark
static void BM_StringCopy(benchmark::State& state) {
std::string x = "hello";
for (auto _ : state)
std::string copy(x);
}
BENCHMARK(BM_StringCopy);
// Augment the main() program to invoke benchmarks if specified
// via the --benchmark_filter command line flag. E.g.,
// my_unittest --benchmark_filter=all
// my_unittest --benchmark_filter=BM_StringCreation
// my_unittest --benchmark_filter=String
// my_unittest --benchmark_filter='Copy|Creation'
int main(int argc, char** argv) {
benchmark::Initialize(&argc, argv);
benchmark::RunSpecifiedBenchmarks();
benchmark::Shutdown();
return 0;
}
// Sometimes a family of microbenchmarks can be implemented with
// just one routine that takes an extra argument to specify which
// one of the family of benchmarks to run. For example, the following
// code defines a family of microbenchmarks for measuring the speed
// of memcpy() calls of different lengths:
static void BM_memcpy(benchmark::State& state) {
char* src = new char[state.range(0)]; char* dst = new char[state.range(0)];
memset(src, 'x', state.range(0));
for (auto _ : state)
memcpy(dst, src, state.range(0));
state.SetBytesProcessed(state.iterations() * state.range(0));
delete[] src; delete[] dst;
}
BENCHMARK(BM_memcpy)->Arg(8)->Arg(64)->Arg(512)->Arg(1<<10)->Arg(8<<10);
// The preceding code is quite repetitive, and can be replaced with the
// following short-hand. The following invocation will pick a few
// appropriate arguments in the specified range and will generate a
// microbenchmark for each such argument.
BENCHMARK(BM_memcpy)->Range(8, 8<<10);
// You might have a microbenchmark that depends on two inputs. For
// example, the following code defines a family of microbenchmarks for
// measuring the speed of set insertion.
static void BM_SetInsert(benchmark::State& state) {
set<int> data;
for (auto _ : state) {
state.PauseTiming();
data = ConstructRandomSet(state.range(0));
state.ResumeTiming();
for (int j = 0; j < state.range(1); ++j)
data.insert(RandomNumber());
}
}
BENCHMARK(BM_SetInsert)
->Args({1<<10, 128})
->Args({2<<10, 128})
->Args({4<<10, 128})
->Args({8<<10, 128})
->Args({1<<10, 512})
->Args({2<<10, 512})
->Args({4<<10, 512})
->Args({8<<10, 512});
// The preceding code is quite repetitive, and can be replaced with
// the following short-hand. The following macro will pick a few
// appropriate arguments in the product of the two specified ranges
// and will generate a microbenchmark for each such pair.
BENCHMARK(BM_SetInsert)->Ranges({{1<<10, 8<<10}, {128, 512}});
// For more complex patterns of inputs, passing a custom function
// to Apply allows programmatic specification of an
// arbitrary set of arguments to run the microbenchmark on.
// The following example enumerates a dense range on
// one parameter, and a sparse range on the second.
static void CustomArguments(benchmark::internal::Benchmark* b) {
for (int i = 0; i <= 10; ++i)
for (int j = 32; j <= 1024*1024; j *= 8)
b->Args({i, j});
}
BENCHMARK(BM_SetInsert)->Apply(CustomArguments);
// Templated microbenchmarks work the same way:
// Produce then consume 'size' messages 'iters' times
// Measures throughput in the absence of multiprogramming.
template <class Q> int BM_Sequential(benchmark::State& state) {
Q q;
typename Q::value_type v;
for (auto _ : state) {
for (int i = state.range(0); i--; )
q.push(v);
for (int e = state.range(0); e--; )
q.Wait(&v);
}
// actually messages, not bytes:
state.SetBytesProcessed(state.iterations() * state.range(0));
}
BENCHMARK_TEMPLATE(BM_Sequential, WaitQueue<int>)->Range(1<<0, 1<<10);
Use `Benchmark::MinTime(double t)` to set the minimum time used to run the
benchmark. This option overrides the `benchmark_min_time` flag.
void BM_test(benchmark::State& state) {
... body ...
}
BENCHMARK(BM_test)->MinTime(2.0); // Run for at least 2 seconds.
In a multithreaded test, it is guaranteed that none of the threads will start
until all have reached the loop start, and all will have finished before any
thread exits the loop body. As such, any global setup or teardown you want to
do can be wrapped in a check against the thread index:
static void BM_MultiThreaded(benchmark::State& state) {
if (state.thread_index() == 0) {
// Setup code here.
}
for (auto _ : state) {
// Run the test as normal.
}
if (state.thread_index() == 0) {
// Teardown code here.
}
}
BENCHMARK(BM_MultiThreaded)->Threads(4);
If a benchmark runs a few milliseconds it may be hard to visually compare the
measured times, since the output data is given in nanoseconds per default. In
order to manually set the time unit, you can specify it manually:
BENCHMARK(BM_test)->Unit(benchmark::kMillisecond);
*/
#ifndef BENCHMARK_BENCHMARK_H_
#define BENCHMARK_BENCHMARK_H_
// The _MSVC_LANG check should detect Visual Studio 2015 Update 3 and newer.
#if __cplusplus >= 201103L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201103L)
#define BENCHMARK_HAS_CXX11
#endif
// This _MSC_VER check should detect VS 2017 v15.3 and newer.
#if __cplusplus >= 201703L || \
(defined(_MSC_VER) && _MSC_VER >= 1911 && _MSVC_LANG >= 201703L)
#define BENCHMARK_HAS_CXX17
#endif
#include <stdint.h>
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <iosfwd>
#include <limits>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "benchmark/export.h"
#if defined(BENCHMARK_HAS_CXX11)
#include <atomic>
#include <initializer_list>
#include <type_traits>
#include <utility>
#endif
#if defined(_MSC_VER)
#include <intrin.h> // for _ReadWriteBarrier
#endif
#ifndef BENCHMARK_HAS_CXX11
#define BENCHMARK_DISALLOW_COPY_AND_ASSIGN(TypeName) \
TypeName(const TypeName&); \
TypeName& operator=(const TypeName&)
#else
#define BENCHMARK_DISALLOW_COPY_AND_ASSIGN(TypeName) \
TypeName(const TypeName&) = delete; \
TypeName& operator=(const TypeName&) = delete
#endif
#ifdef BENCHMARK_HAS_CXX17
#define BENCHMARK_UNUSED [[maybe_unused]]
#elif defined(__GNUC__) || defined(__clang__)
#define BENCHMARK_UNUSED __attribute__((unused))
#else
#define BENCHMARK_UNUSED
#endif
// Used to annotate functions, methods and classes so they
// are not optimized by the compiler. Useful for tests
// where you expect loops to stay in place churning cycles
#if defined(__clang__)
#define BENCHMARK_DONT_OPTIMIZE __attribute__((optnone))
#elif defined(__GNUC__) || defined(__GNUG__)
#define BENCHMARK_DONT_OPTIMIZE __attribute__((optimize(0)))
#else
// MSVC & Intel do not have a no-optimize attribute, only line pragmas
#define BENCHMARK_DONT_OPTIMIZE
#endif
#if defined(__GNUC__) || defined(__clang__)
#define BENCHMARK_ALWAYS_INLINE __attribute__((always_inline))
#elif defined(_MSC_VER) && !defined(__clang__)
#define BENCHMARK_ALWAYS_INLINE __forceinline
#define __func__ __FUNCTION__
#else
#define BENCHMARK_ALWAYS_INLINE
#endif
#define BENCHMARK_INTERNAL_TOSTRING2(x) #x
#define BENCHMARK_INTERNAL_TOSTRING(x) BENCHMARK_INTERNAL_TOSTRING2(x)
// clang-format off
#if (defined(__GNUC__) && !defined(__NVCC__) && !defined(__NVCOMPILER)) || defined(__clang__)
#define BENCHMARK_BUILTIN_EXPECT(x, y) __builtin_expect(x, y)
#define BENCHMARK_DEPRECATED_MSG(msg) __attribute__((deprecated(msg)))
#define BENCHMARK_DISABLE_DEPRECATED_WARNING \
_Pragma("GCC diagnostic push") \
_Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
#define BENCHMARK_RESTORE_DEPRECATED_WARNING _Pragma("GCC diagnostic pop")
#elif defined(__NVCOMPILER)
#define BENCHMARK_BUILTIN_EXPECT(x, y) __builtin_expect(x, y)
#define BENCHMARK_DEPRECATED_MSG(msg) __attribute__((deprecated(msg)))
#define BENCHMARK_DISABLE_DEPRECATED_WARNING \
_Pragma("diagnostic push") \
_Pragma("diag_suppress deprecated_entity_with_custom_message")
#define BENCHMARK_RESTORE_DEPRECATED_WARNING _Pragma("diagnostic pop")
#else
#define BENCHMARK_BUILTIN_EXPECT(x, y) x
#define BENCHMARK_DEPRECATED_MSG(msg)
#define BENCHMARK_WARNING_MSG(msg) \
__pragma(message(__FILE__ "(" BENCHMARK_INTERNAL_TOSTRING( \
__LINE__) ") : warning note: " msg))
#define BENCHMARK_DISABLE_DEPRECATED_WARNING
#define BENCHMARK_RESTORE_DEPRECATED_WARNING
#endif
// clang-format on
#if defined(__GNUC__) && !defined(__clang__)
#define BENCHMARK_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#endif
#ifndef __has_builtin
#define __has_builtin(x) 0
#endif
#if defined(__GNUC__) || __has_builtin(__builtin_unreachable)
#define BENCHMARK_UNREACHABLE() __builtin_unreachable()
#elif defined(_MSC_VER)
#define BENCHMARK_UNREACHABLE() __assume(false)
#else
#define BENCHMARK_UNREACHABLE() ((void)0)
#endif
#ifdef BENCHMARK_HAS_CXX11
#define BENCHMARK_OVERRIDE override
#else
#define BENCHMARK_OVERRIDE
#endif
#if defined(_MSC_VER)
#pragma warning(push)
// C4251: <symbol> needs to have dll-interface to be used by clients of class
#pragma warning(disable : 4251)
#endif
namespace benchmark {
class BenchmarkReporter;
// Default number of minimum benchmark running time in seconds.
const char kDefaultMinTimeStr[] = "0.5s";
BENCHMARK_EXPORT void PrintDefaultHelp();
BENCHMARK_EXPORT void Initialize(int* argc, char** argv,
void (*HelperPrinterf)() = PrintDefaultHelp);
BENCHMARK_EXPORT void Shutdown();
// Report to stdout all arguments in 'argv' as unrecognized except the first.
// Returns true there is at least on unrecognized argument (i.e. 'argc' > 1).
BENCHMARK_EXPORT bool ReportUnrecognizedArguments(int argc, char** argv);
// Returns the current value of --benchmark_filter.
BENCHMARK_EXPORT std::string GetBenchmarkFilter();
// Sets a new value to --benchmark_filter. (This will override this flag's
// current value).
// Should be called after `benchmark::Initialize()`, as
// `benchmark::Initialize()` will override the flag's value.
BENCHMARK_EXPORT void SetBenchmarkFilter(std::string value);
// Returns the current value of --v (command line value for verbosity).
BENCHMARK_EXPORT int32_t GetBenchmarkVerbosity();
// Creates a default display reporter. Used by the library when no display
// reporter is provided, but also made available for external use in case a
// custom reporter should respect the `--benchmark_format` flag as a fallback
BENCHMARK_EXPORT BenchmarkReporter* CreateDefaultDisplayReporter();
// Generate a list of benchmarks matching the specified --benchmark_filter flag
// and if --benchmark_list_tests is specified return after printing the name
// of each matching benchmark. Otherwise run each matching benchmark and
// report the results.
//
// spec : Specify the benchmarks to run. If users do not specify this arg,
// then the value of FLAGS_benchmark_filter
// will be used.
//
// The second and third overload use the specified 'display_reporter' and
// 'file_reporter' respectively. 'file_reporter' will write to the file
// specified
// by '--benchmark_output'. If '--benchmark_output' is not given the
// 'file_reporter' is ignored.
//
// RETURNS: The number of matching benchmarks.
BENCHMARK_EXPORT size_t RunSpecifiedBenchmarks();
BENCHMARK_EXPORT size_t RunSpecifiedBenchmarks(std::string spec);
BENCHMARK_EXPORT size_t
RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter);
BENCHMARK_EXPORT size_t
RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter, std::string spec);
BENCHMARK_EXPORT size_t RunSpecifiedBenchmarks(
BenchmarkReporter* display_reporter, BenchmarkReporter* file_reporter);
BENCHMARK_EXPORT size_t
RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter,
BenchmarkReporter* file_reporter, std::string spec);
// TimeUnit is passed to a benchmark in order to specify th
gitextract_2jb94fdk/
├── .dockerignore
├── .editorconfig
├── .gitignore
├── 3rd/
│ ├── benchmark-1.8.2/
│ │ ├── .clang-format
│ │ ├── .clang-tidy
│ │ ├── .github/
│ │ │ ├── ISSUE_TEMPLATE/
│ │ │ │ ├── bug_report.md
│ │ │ │ └── feature_request.md
│ │ │ ├── install_bazel.sh
│ │ │ ├── libcxx-setup.sh
│ │ │ └── workflows/
│ │ │ ├── bazel.yml
│ │ │ ├── build-and-test-min-cmake.yml
│ │ │ ├── build-and-test-perfcounters.yml
│ │ │ ├── build-and-test.yml
│ │ │ ├── clang-format-lint.yml
│ │ │ ├── clang-tidy.yml
│ │ │ ├── doxygen.yml
│ │ │ ├── pylint.yml
│ │ │ ├── sanitizer.yml
│ │ │ ├── test_bindings.yml
│ │ │ └── wheels.yml
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── .ycm_extra_conf.py
│ │ ├── AUTHORS
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── CONTRIBUTING.md
│ │ ├── CONTRIBUTORS
│ │ ├── LICENSE
│ │ ├── MODULE.bazel
│ │ ├── README.md
│ │ ├── WORKSPACE
│ │ ├── WORKSPACE.bzlmod
│ │ ├── _config.yml
│ │ ├── appveyor.yml
│ │ ├── bazel/
│ │ │ └── benchmark_deps.bzl
│ │ ├── bindings/
│ │ │ └── python/
│ │ │ ├── BUILD
│ │ │ ├── build_defs.bzl
│ │ │ ├── google_benchmark/
│ │ │ │ ├── BUILD
│ │ │ │ ├── __init__.py
│ │ │ │ ├── benchmark.cc
│ │ │ │ └── example.py
│ │ │ ├── nanobind.BUILD
│ │ │ ├── python_headers.BUILD
│ │ │ └── requirements.txt
│ │ ├── cmake/
│ │ │ ├── Config.cmake.in
│ │ │ ├── GoogleTest.cmake.in
│ │ │ ├── benchmark.pc.in
│ │ │ ├── gnu_posix_regex.cpp
│ │ │ ├── posix_regex.cpp
│ │ │ ├── pthread_affinity.cpp
│ │ │ ├── std_regex.cpp
│ │ │ ├── steady_clock.cpp
│ │ │ └── thread_safety_attributes.cpp
│ │ ├── docs/
│ │ │ ├── AssemblyTests.md
│ │ │ ├── _config.yml
│ │ │ ├── dependencies.md
│ │ │ ├── index.md
│ │ │ ├── perf_counters.md
│ │ │ ├── platform_specific_build_instructions.md
│ │ │ ├── python_bindings.md
│ │ │ ├── random_interleaving.md
│ │ │ ├── reducing_variance.md
│ │ │ ├── releasing.md
│ │ │ ├── tools.md
│ │ │ └── user_guide.md
│ │ ├── include/
│ │ │ └── benchmark/
│ │ │ ├── benchmark.h
│ │ │ └── export.h
│ │ ├── setup.py
│ │ ├── src/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── arraysize.h
│ │ │ ├── benchmark.cc
│ │ │ ├── benchmark_api_internal.cc
│ │ │ ├── benchmark_api_internal.h
│ │ │ ├── benchmark_main.cc
│ │ │ ├── benchmark_name.cc
│ │ │ ├── benchmark_register.cc
│ │ │ ├── benchmark_register.h
│ │ │ ├── benchmark_runner.cc
│ │ │ ├── benchmark_runner.h
│ │ │ ├── check.cc
│ │ │ ├── check.h
│ │ │ ├── colorprint.cc
│ │ │ ├── colorprint.h
│ │ │ ├── commandlineflags.cc
│ │ │ ├── commandlineflags.h
│ │ │ ├── complexity.cc
│ │ │ ├── complexity.h
│ │ │ ├── console_reporter.cc
│ │ │ ├── counter.cc
│ │ │ ├── counter.h
│ │ │ ├── csv_reporter.cc
│ │ │ ├── cycleclock.h
│ │ │ ├── internal_macros.h
│ │ │ ├── json_reporter.cc
│ │ │ ├── log.h
│ │ │ ├── mutex.h
│ │ │ ├── perf_counters.cc
│ │ │ ├── perf_counters.h
│ │ │ ├── re.h
│ │ │ ├── reporter.cc
│ │ │ ├── statistics.cc
│ │ │ ├── statistics.h
│ │ │ ├── string_util.cc
│ │ │ ├── string_util.h
│ │ │ ├── sysinfo.cc
│ │ │ ├── thread_manager.h
│ │ │ ├── thread_timer.h
│ │ │ ├── timers.cc
│ │ │ └── timers.h
│ │ ├── test/
│ │ │ ├── BUILD
│ │ │ ├── CMakeLists.txt
│ │ │ ├── args_product_test.cc
│ │ │ ├── basic_test.cc
│ │ │ ├── benchmark_gtest.cc
│ │ │ ├── benchmark_min_time_flag_iters_test.cc
│ │ │ ├── benchmark_min_time_flag_time_test.cc
│ │ │ ├── benchmark_name_gtest.cc
│ │ │ ├── benchmark_random_interleaving_gtest.cc
│ │ │ ├── benchmark_setup_teardown_test.cc
│ │ │ ├── benchmark_test.cc
│ │ │ ├── clobber_memory_assembly_test.cc
│ │ │ ├── commandlineflags_gtest.cc
│ │ │ ├── complexity_test.cc
│ │ │ ├── cxx03_test.cc
│ │ │ ├── diagnostics_test.cc
│ │ │ ├── display_aggregates_only_test.cc
│ │ │ ├── donotoptimize_assembly_test.cc
│ │ │ ├── donotoptimize_test.cc
│ │ │ ├── filter_test.cc
│ │ │ ├── fixture_test.cc
│ │ │ ├── internal_threading_test.cc
│ │ │ ├── link_main_test.cc
│ │ │ ├── map_test.cc
│ │ │ ├── memory_manager_test.cc
│ │ │ ├── min_time_parse_gtest.cc
│ │ │ ├── multiple_ranges_test.cc
│ │ │ ├── options_test.cc
│ │ │ ├── output_test.h
│ │ │ ├── output_test_helper.cc
│ │ │ ├── perf_counters_gtest.cc
│ │ │ ├── perf_counters_test.cc
│ │ │ ├── register_benchmark_test.cc
│ │ │ ├── repetitions_test.cc
│ │ │ ├── report_aggregates_only_test.cc
│ │ │ ├── reporter_output_test.cc
│ │ │ ├── skip_with_error_test.cc
│ │ │ ├── spec_arg_test.cc
│ │ │ ├── spec_arg_verbosity_test.cc
│ │ │ ├── state_assembly_test.cc
│ │ │ ├── statistics_gtest.cc
│ │ │ ├── string_util_gtest.cc
│ │ │ ├── templated_fixture_test.cc
│ │ │ ├── time_unit_gtest.cc
│ │ │ ├── user_counters_tabular_test.cc
│ │ │ ├── user_counters_test.cc
│ │ │ └── user_counters_thousands_test.cc
│ │ └── tools/
│ │ ├── BUILD.bazel
│ │ ├── compare.py
│ │ ├── gbench/
│ │ │ ├── Inputs/
│ │ │ │ ├── test1_run1.json
│ │ │ │ ├── test1_run2.json
│ │ │ │ ├── test2_run.json
│ │ │ │ ├── test3_run0.json
│ │ │ │ ├── test3_run1.json
│ │ │ │ ├── test4_run.json
│ │ │ │ ├── test4_run0.json
│ │ │ │ └── test4_run1.json
│ │ │ ├── __init__.py
│ │ │ ├── report.py
│ │ │ └── util.py
│ │ ├── libpfm.BUILD.bazel
│ │ ├── requirements.txt
│ │ └── strip_asm.py
│ └── googletest-1.12.1/
│ ├── .clang-format
│ ├── .github/
│ │ ├── ISSUE_TEMPLATE/
│ │ │ ├── 00-bug_report.md
│ │ │ ├── 10-feature_request.md
│ │ │ └── config.yml
│ │ └── workflows/
│ │ └── gtest-ci.yml
│ ├── .gitignore
│ ├── BUILD.bazel
│ ├── CMakeLists.txt
│ ├── CONTRIBUTING.md
│ ├── CONTRIBUTORS
│ ├── LICENSE
│ ├── README.md
│ ├── WORKSPACE
│ ├── ci/
│ │ ├── linux-presubmit.sh
│ │ └── macos-presubmit.sh
│ ├── docs/
│ │ ├── _config.yml
│ │ ├── _data/
│ │ │ └── navigation.yml
│ │ ├── _layouts/
│ │ │ └── default.html
│ │ ├── _sass/
│ │ │ └── main.scss
│ │ ├── advanced.md
│ │ ├── assets/
│ │ │ └── css/
│ │ │ └── style.scss
│ │ ├── community_created_documentation.md
│ │ ├── faq.md
│ │ ├── gmock_cheat_sheet.md
│ │ ├── gmock_cook_book.md
│ │ ├── gmock_faq.md
│ │ ├── gmock_for_dummies.md
│ │ ├── index.md
│ │ ├── pkgconfig.md
│ │ ├── platforms.md
│ │ ├── primer.md
│ │ ├── quickstart-bazel.md
│ │ ├── quickstart-cmake.md
│ │ ├── reference/
│ │ │ ├── actions.md
│ │ │ ├── assertions.md
│ │ │ ├── matchers.md
│ │ │ ├── mocking.md
│ │ │ └── testing.md
│ │ └── samples.md
│ ├── googlemock/
│ │ ├── CMakeLists.txt
│ │ ├── README.md
│ │ ├── cmake/
│ │ │ ├── gmock.pc.in
│ │ │ └── gmock_main.pc.in
│ │ ├── docs/
│ │ │ └── README.md
│ │ ├── include/
│ │ │ └── gmock/
│ │ │ ├── gmock-actions.h
│ │ │ ├── gmock-cardinalities.h
│ │ │ ├── gmock-function-mocker.h
│ │ │ ├── gmock-matchers.h
│ │ │ ├── gmock-more-actions.h
│ │ │ ├── gmock-more-matchers.h
│ │ │ ├── gmock-nice-strict.h
│ │ │ ├── gmock-spec-builders.h
│ │ │ ├── gmock.h
│ │ │ └── internal/
│ │ │ ├── custom/
│ │ │ │ ├── README.md
│ │ │ │ ├── gmock-generated-actions.h
│ │ │ │ ├── gmock-matchers.h
│ │ │ │ └── gmock-port.h
│ │ │ ├── gmock-internal-utils.h
│ │ │ ├── gmock-port.h
│ │ │ └── gmock-pp.h
│ │ ├── src/
│ │ │ ├── gmock-all.cc
│ │ │ ├── gmock-cardinalities.cc
│ │ │ ├── gmock-internal-utils.cc
│ │ │ ├── gmock-matchers.cc
│ │ │ ├── gmock-spec-builders.cc
│ │ │ ├── gmock.cc
│ │ │ └── gmock_main.cc
│ │ └── test/
│ │ ├── BUILD.bazel
│ │ ├── gmock-actions_test.cc
│ │ ├── gmock-cardinalities_test.cc
│ │ ├── gmock-function-mocker_test.cc
│ │ ├── gmock-internal-utils_test.cc
│ │ ├── gmock-matchers-arithmetic_test.cc
│ │ ├── gmock-matchers-comparisons_test.cc
│ │ ├── gmock-matchers-containers_test.cc
│ │ ├── gmock-matchers-misc_test.cc
│ │ ├── gmock-matchers_test.h
│ │ ├── gmock-more-actions_test.cc
│ │ ├── gmock-nice-strict_test.cc
│ │ ├── gmock-port_test.cc
│ │ ├── gmock-pp-string_test.cc
│ │ ├── gmock-pp_test.cc
│ │ ├── gmock-spec-builders_test.cc
│ │ ├── gmock_all_test.cc
│ │ ├── gmock_ex_test.cc
│ │ ├── gmock_leak_test.py
│ │ ├── gmock_leak_test_.cc
│ │ ├── gmock_link2_test.cc
│ │ ├── gmock_link_test.cc
│ │ ├── gmock_link_test.h
│ │ ├── gmock_output_test.py
│ │ ├── gmock_output_test_.cc
│ │ ├── gmock_output_test_golden.txt
│ │ ├── gmock_stress_test.cc
│ │ ├── gmock_test.cc
│ │ └── gmock_test_utils.py
│ └── googletest/
│ ├── CMakeLists.txt
│ ├── README.md
│ ├── cmake/
│ │ ├── Config.cmake.in
│ │ ├── gtest.pc.in
│ │ ├── gtest_main.pc.in
│ │ ├── internal_utils.cmake
│ │ └── libgtest.la.in
│ ├── docs/
│ │ └── README.md
│ ├── include/
│ │ └── gtest/
│ │ ├── gtest-assertion-result.h
│ │ ├── gtest-death-test.h
│ │ ├── gtest-matchers.h
│ │ ├── gtest-message.h
│ │ ├── gtest-param-test.h
│ │ ├── gtest-printers.h
│ │ ├── gtest-spi.h
│ │ ├── gtest-test-part.h
│ │ ├── gtest-typed-test.h
│ │ ├── gtest.h
│ │ ├── gtest_pred_impl.h
│ │ ├── gtest_prod.h
│ │ └── internal/
│ │ ├── custom/
│ │ │ ├── README.md
│ │ │ ├── gtest-port.h
│ │ │ ├── gtest-printers.h
│ │ │ └── gtest.h
│ │ ├── gtest-death-test-internal.h
│ │ ├── gtest-filepath.h
│ │ ├── gtest-internal.h
│ │ ├── gtest-param-util.h
│ │ ├── gtest-port-arch.h
│ │ ├── gtest-port.h
│ │ ├── gtest-string.h
│ │ └── gtest-type-util.h
│ ├── samples/
│ │ ├── prime_tables.h
│ │ ├── sample1.cc
│ │ ├── sample1.h
│ │ ├── sample10_unittest.cc
│ │ ├── sample1_unittest.cc
│ │ ├── sample2.cc
│ │ ├── sample2.h
│ │ ├── sample2_unittest.cc
│ │ ├── sample3-inl.h
│ │ ├── sample3_unittest.cc
│ │ ├── sample4.cc
│ │ ├── sample4.h
│ │ ├── sample4_unittest.cc
│ │ ├── sample5_unittest.cc
│ │ ├── sample6_unittest.cc
│ │ ├── sample7_unittest.cc
│ │ ├── sample8_unittest.cc
│ │ └── sample9_unittest.cc
│ ├── src/
│ │ ├── gtest-all.cc
│ │ ├── gtest-assertion-result.cc
│ │ ├── gtest-death-test.cc
│ │ ├── gtest-filepath.cc
│ │ ├── gtest-internal-inl.h
│ │ ├── gtest-matchers.cc
│ │ ├── gtest-port.cc
│ │ ├── gtest-printers.cc
│ │ ├── gtest-test-part.cc
│ │ ├── gtest-typed-test.cc
│ │ ├── gtest.cc
│ │ └── gtest_main.cc
│ └── test/
│ ├── BUILD.bazel
│ ├── googletest-break-on-failure-unittest.py
│ ├── googletest-break-on-failure-unittest_.cc
│ ├── googletest-catch-exceptions-test.py
│ ├── googletest-catch-exceptions-test_.cc
│ ├── googletest-color-test.py
│ ├── googletest-color-test_.cc
│ ├── googletest-death-test-test.cc
│ ├── googletest-death-test_ex_test.cc
│ ├── googletest-env-var-test.py
│ ├── googletest-env-var-test_.cc
│ ├── googletest-failfast-unittest.py
│ ├── googletest-failfast-unittest_.cc
│ ├── googletest-filepath-test.cc
│ ├── googletest-filter-unittest.py
│ ├── googletest-filter-unittest_.cc
│ ├── googletest-global-environment-unittest.py
│ ├── googletest-global-environment-unittest_.cc
│ ├── googletest-json-outfiles-test.py
│ ├── googletest-json-output-unittest.py
│ ├── googletest-list-tests-unittest.py
│ ├── googletest-list-tests-unittest_.cc
│ ├── googletest-listener-test.cc
│ ├── googletest-message-test.cc
│ ├── googletest-options-test.cc
│ ├── googletest-output-test-golden-lin.txt
│ ├── googletest-output-test.py
│ ├── googletest-output-test_.cc
│ ├── googletest-param-test-invalid-name1-test.py
│ ├── googletest-param-test-invalid-name1-test_.cc
│ ├── googletest-param-test-invalid-name2-test.py
│ ├── googletest-param-test-invalid-name2-test_.cc
│ ├── googletest-param-test-test.cc
│ ├── googletest-param-test-test.h
│ ├── googletest-param-test2-test.cc
│ ├── googletest-port-test.cc
│ ├── googletest-printers-test.cc
│ ├── googletest-setuptestsuite-test.py
│ ├── googletest-setuptestsuite-test_.cc
│ ├── googletest-shuffle-test.py
│ ├── googletest-shuffle-test_.cc
│ ├── googletest-test-part-test.cc
│ ├── googletest-throw-on-failure-test.py
│ ├── googletest-throw-on-failure-test_.cc
│ ├── googletest-uninitialized-test.py
│ ├── googletest-uninitialized-test_.cc
│ ├── gtest-typed-test2_test.cc
│ ├── gtest-typed-test_test.cc
│ ├── gtest-typed-test_test.h
│ ├── gtest-unittest-api_test.cc
│ ├── gtest_all_test.cc
│ ├── gtest_assert_by_exception_test.cc
│ ├── gtest_environment_test.cc
│ ├── gtest_help_test.py
│ ├── gtest_help_test_.cc
│ ├── gtest_json_test_utils.py
│ ├── gtest_list_output_unittest.py
│ ├── gtest_list_output_unittest_.cc
│ ├── gtest_main_unittest.cc
│ ├── gtest_no_test_unittest.cc
│ ├── gtest_pred_impl_unittest.cc
│ ├── gtest_premature_exit_test.cc
│ ├── gtest_prod_test.cc
│ ├── gtest_repeat_test.cc
│ ├── gtest_skip_check_output_test.py
│ ├── gtest_skip_environment_check_output_test.py
│ ├── gtest_skip_in_environment_setup_test.cc
│ ├── gtest_skip_test.cc
│ ├── gtest_sole_header_test.cc
│ ├── gtest_stress_test.cc
│ ├── gtest_test_macro_stack_footprint_test.cc
│ ├── gtest_test_utils.py
│ ├── gtest_testbridge_test.py
│ ├── gtest_testbridge_test_.cc
│ ├── gtest_throw_on_failure_ex_test.cc
│ ├── gtest_unittest.cc
│ ├── gtest_xml_outfile1_test_.cc
│ ├── gtest_xml_outfile2_test_.cc
│ ├── gtest_xml_outfiles_test.py
│ ├── gtest_xml_output_unittest.py
│ ├── gtest_xml_output_unittest_.cc
│ ├── gtest_xml_test_utils.py
│ ├── production.cc
│ └── production.h
├── CMakeLists.txt
├── Dockerfile
├── LICENSE
├── README.md
├── src/
│ ├── Clock.cpp
│ ├── Clock.h
│ ├── CmdFlag.h
│ ├── HHWheelTimer.cpp
│ ├── HHWheelTimer.h
│ ├── HashedWheelBucket.cpp
│ ├── HashedWheelBucket.h
│ ├── HashedWheelTimer.cpp
│ ├── HashedWheelTimer.h
│ ├── Logging.cpp
│ ├── Logging.h
│ ├── Preprocessor.h
│ ├── PriorityQueueTimer.cpp
│ ├── PriorityQueueTimer.h
│ ├── QuadHeapTimer.cpp
│ ├── QuadHeapTimer.h
│ ├── RBTreeTimer.cpp
│ ├── RBTreeTimer.h
│ ├── TimerBase.cpp
│ ├── TimerBase.h
│ ├── list_impl.h
│ ├── timer_list.cpp
│ └── timer_list.h
└── test/
├── BenchTimer.cpp
├── TestTimer.cpp
└── main.cpp
Showing preview only (971K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (6158 symbols across 283 files)
FILE: 3rd/benchmark-1.8.2/.ycm_extra_conf.py
function DirectoryOfThisScript (line 41) | def DirectoryOfThisScript():
function MakeRelativePathsInFlagsAbsolute (line 45) | def MakeRelativePathsInFlagsAbsolute( flags, working_directory ):
function IsHeaderFile (line 74) | def IsHeaderFile( filename ):
function GetCompilationInfoForFile (line 79) | def GetCompilationInfoForFile( filename ):
function FlagsForFile (line 97) | def FlagsForFile( filename, **kwargs ):
FILE: 3rd/benchmark-1.8.2/bindings/python/google_benchmark/__init__.py
class __OptionMaker (line 75) | class __OptionMaker:
class Options (line 81) | class Options:
method __init__ (line 84) | def __init__(self, func):
method make (line 89) | def make(cls, func_or_options):
method __getattr__ (line 95) | def __getattr__(self, builder_name):
function register (line 121) | def register(undefined=None, *, name=None):
function _flags_parser (line 144) | def _flags_parser(argv):
function _run_benchmarks (line 149) | def _run_benchmarks(argv):
function main (line 155) | def main(argv=None):
FILE: 3rd/benchmark-1.8.2/bindings/python/google_benchmark/benchmark.cc
function Initialize (line 16) | std::vector<std::string> Initialize(const std::vector<std::string>& argv) {
function NB_MODULE (line 43) | NB_MODULE(_benchmark, m) {
FILE: 3rd/benchmark-1.8.2/bindings/python/google_benchmark/example.py
function empty (line 31) | def empty(state):
function sum_million (line 37) | def sum_million(state):
function pause_timing (line 42) | def pause_timing(state):
function skipped (line 54) | def skipped(state):
function manual_timing (line 63) | def manual_timing(state):
function custom_counters (line 74) | def custom_counters(state):
function with_options (line 98) | def with_options(state):
function with_options2 (line 105) | def with_options2(state):
function passing_argument (line 113) | def passing_argument(state):
function using_range (line 120) | def using_range(state):
function computing_complexity (line 129) | def computing_complexity(state):
FILE: 3rd/benchmark-1.8.2/cmake/gnu_posix_regex.cpp
function main (line 3) | int main() {
FILE: 3rd/benchmark-1.8.2/cmake/posix_regex.cpp
function main (line 3) | int main() {
FILE: 3rd/benchmark-1.8.2/cmake/pthread_affinity.cpp
function main (line 2) | int main() {
FILE: 3rd/benchmark-1.8.2/cmake/std_regex.cpp
function main (line 3) | int main() {
FILE: 3rd/benchmark-1.8.2/cmake/steady_clock.cpp
function main (line 3) | int main() {
FILE: 3rd/benchmark-1.8.2/cmake/thread_safety_attributes.cpp
function main (line 4) | int main() {}
FILE: 3rd/benchmark-1.8.2/include/benchmark/benchmark.h
function namespace (line 299) | namespace benchmark {
function BENCHMARK_ALWAYS_INLINE (line 925) | BENCHMARK_ALWAYS_INLINE
function StateIterator (line 1023) | struct State::StateIterator {
function class (line 1081) | class BENCHMARK_EXPORT Benchmark {
function CPUInfo (line 1670) | struct BENCHMARK_EXPORT CPUInfo {
function SystemInfo (line 1694) | struct BENCHMARK_EXPORT SystemInfo {
function BenchmarkName (line 1706) | struct BENCHMARK_EXPORT BenchmarkName {
type Context (line 1728) | struct Context {
function Run (line 1737) | struct BENCHMARK_EXPORT Run {
FILE: 3rd/benchmark-1.8.2/setup.py
function _get_long_description (line 19) | def _get_long_description(fp: str) -> str:
function _get_version (line 24) | def _get_version(fp: str) -> str:
function _parse_requirements (line 34) | def _parse_requirements(fp: str) -> List[str]:
function temp_fill_include_path (line 44) | def temp_fill_include_path(fp: str):
class BazelExtension (line 64) | class BazelExtension(setuptools.Extension):
method __init__ (line 67) | def __init__(self, name: str, bazel_target: str):
class BuildBazelExtension (line 75) | class BuildBazelExtension(build_ext.build_ext):
method run (line 78) | def run(self):
method bazel_build (line 83) | def bazel_build(self, ext: BazelExtension):
FILE: 3rd/benchmark-1.8.2/src/arraysize.h
function namespace (line 6) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/benchmark.cc
type benchmark (line 59) | namespace benchmark {
type internal (line 147) | namespace internal {
function BENCHMARK_EXPORT (line 151) | BENCHMARK_EXPORT std::map<std::string, std::string>*& GetGlobalConte...
function UseCharPointer (line 156) | void UseCharPointer(char const volatile*) {}
function FlushStreams (line 305) | void FlushStreams(BenchmarkReporter* reporter) {
function Report (line 312) | void Report(BenchmarkReporter* display_reporter,
function RunBenchmarks (line 334) | void RunBenchmarks(const std::vector<BenchmarkInstance>& benchmarks,
function BENCHMARK_DISABLE_DEPRECATED_WARNING (line 462) | BENCHMARK_DISABLE_DEPRECATED_WARNING
function IsZero (line 484) | bool IsZero(double n) {
function GetOutputOptions (line 488) | ConsoleReporter::OutputOptions GetOutputOptions(bool force_no_color) {
function PrintUsageAndExit (line 638) | void PrintUsageAndExit() {
function SetDefaultTimeUnitFromFlag (line 643) | void SetDefaultTimeUnitFromFlag(const std::string& time_unit_flag) {
function ParseCommandLineFlags (line 661) | void ParseCommandLineFlags(int* argc, char** argv) {
function InitializeStreams (line 718) | int InitializeStreams() {
type internal (line 300) | namespace internal {
function BENCHMARK_EXPORT (line 151) | BENCHMARK_EXPORT std::map<std::string, std::string>*& GetGlobalConte...
function UseCharPointer (line 156) | void UseCharPointer(char const volatile*) {}
function FlushStreams (line 305) | void FlushStreams(BenchmarkReporter* reporter) {
function Report (line 312) | void Report(BenchmarkReporter* display_reporter,
function RunBenchmarks (line 334) | void RunBenchmarks(const std::vector<BenchmarkInstance>& benchmarks,
function BENCHMARK_DISABLE_DEPRECATED_WARNING (line 462) | BENCHMARK_DISABLE_DEPRECATED_WARNING
function IsZero (line 484) | bool IsZero(double n) {
function GetOutputOptions (line 488) | ConsoleReporter::OutputOptions GetOutputOptions(bool force_no_color) {
function PrintUsageAndExit (line 638) | void PrintUsageAndExit() {
function SetDefaultTimeUnitFromFlag (line 643) | void SetDefaultTimeUnitFromFlag(const std::string& time_unit_flag) {
function ParseCommandLineFlags (line 661) | void ParseCommandLineFlags(int* argc, char** argv) {
function InitializeStreams (line 718) | int InitializeStreams() {
function BenchmarkReporter (line 514) | BenchmarkReporter* CreateDefaultDisplayReporter() {
function RunSpecifiedBenchmarks (line 522) | size_t RunSpecifiedBenchmarks() {
function RunSpecifiedBenchmarks (line 526) | size_t RunSpecifiedBenchmarks(std::string spec) {
function RunSpecifiedBenchmarks (line 530) | size_t RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter) {
function RunSpecifiedBenchmarks (line 535) | size_t RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter,
function RunSpecifiedBenchmarks (line 540) | size_t RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter,
function RunSpecifiedBenchmarks (line 546) | size_t RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter,
function TimeUnit (line 608) | TimeUnit GetDefaultTimeUnit() { return default_time_unit; }
function SetDefaultTimeUnit (line 610) | void SetDefaultTimeUnit(TimeUnit unit) { default_time_unit = unit; }
function GetBenchmarkFilter (line 612) | std::string GetBenchmarkFilter() { return FLAGS_benchmark_filter; }
function SetBenchmarkFilter (line 614) | void SetBenchmarkFilter(std::string value) {
function GetBenchmarkVerbosity (line 618) | int32_t GetBenchmarkVerbosity() { return FLAGS_v; }
function RegisterMemoryManager (line 620) | void RegisterMemoryManager(MemoryManager* manager) {
function AddCustomContext (line 624) | void AddCustomContext(const std::string& key, const std::string& value) {
type internal (line 634) | namespace internal {
function BENCHMARK_EXPORT (line 151) | BENCHMARK_EXPORT std::map<std::string, std::string>*& GetGlobalConte...
function UseCharPointer (line 156) | void UseCharPointer(char const volatile*) {}
function FlushStreams (line 305) | void FlushStreams(BenchmarkReporter* reporter) {
function Report (line 312) | void Report(BenchmarkReporter* display_reporter,
function RunBenchmarks (line 334) | void RunBenchmarks(const std::vector<BenchmarkInstance>& benchmarks,
function BENCHMARK_DISABLE_DEPRECATED_WARNING (line 462) | BENCHMARK_DISABLE_DEPRECATED_WARNING
function IsZero (line 484) | bool IsZero(double n) {
function GetOutputOptions (line 488) | ConsoleReporter::OutputOptions GetOutputOptions(bool force_no_color) {
function PrintUsageAndExit (line 638) | void PrintUsageAndExit() {
function SetDefaultTimeUnitFromFlag (line 643) | void SetDefaultTimeUnitFromFlag(const std::string& time_unit_flag) {
function ParseCommandLineFlags (line 661) | void ParseCommandLineFlags(int* argc, char** argv) {
function InitializeStreams (line 718) | int InitializeStreams() {
function PrintDefaultHelp (line 725) | void PrintDefaultHelp() {
function Initialize (line 749) | void Initialize(int* argc, char** argv, void (*HelperPrintf)()) {
function Shutdown (line 755) | void Shutdown() { delete internal::global_context; }
function ReportUnrecognizedArguments (line 757) | bool ReportUnrecognizedArguments(int argc, char** argv) {
FILE: 3rd/benchmark-1.8.2/src/benchmark_api_internal.cc
type benchmark (line 7) | namespace benchmark {
type internal (line 8) | namespace internal {
function State (line 92) | State BenchmarkInstance::Run(
FILE: 3rd/benchmark-1.8.2/src/benchmark_api_internal.h
function namespace (line 15) | namespace internal {
FILE: 3rd/benchmark-1.8.2/src/benchmark_name.cc
type benchmark (line 17) | namespace benchmark {
function size_impl (line 22) | size_t size_impl() { return 0; }
function size_impl (line 25) | size_t size_impl(const Head& head, const Tail&... tail) {
function join_impl (line 31) | void join_impl(std::string&, char) {}
function join_impl (line 34) | void join_impl(std::string& s, const char delimiter, const Head& head,
function join (line 46) | std::string join(char delimiter, const Ts&... ts) {
function BENCHMARK_EXPORT (line 54) | BENCHMARK_EXPORT
FILE: 3rd/benchmark-1.8.2/src/benchmark_register.cc
type benchmark (line 52) | namespace benchmark {
type internal (line 65) | namespace internal {
class BenchmarkFamilies (line 73) | class BenchmarkFamilies {
method BenchmarkFamilies (line 90) | BenchmarkFamilies() {}
function BenchmarkFamilies (line 96) | BenchmarkFamilies* BenchmarkFamilies::GetInstance() {
method BenchmarkFamilies (line 90) | BenchmarkFamilies() {}
function Benchmark (line 188) | Benchmark* RegisterBenchmarkInternal(Benchmark* bench) {
function FindBenchmarksInternal (line 197) | bool FindBenchmarksInternal(const std::string& re,
function Benchmark (line 232) | Benchmark* Benchmark::Name(const std::string& name) {
function Benchmark (line 237) | Benchmark* Benchmark::Arg(int64_t x) {
function Benchmark (line 243) | Benchmark* Benchmark::Unit(TimeUnit unit) {
function Benchmark (line 249) | Benchmark* Benchmark::Range(int64_t start, int64_t limit) {
function Benchmark (line 260) | Benchmark* Benchmark::Ranges(
function Benchmark (line 274) | Benchmark* Benchmark::ArgsProduct(
function Benchmark (line 302) | Benchmark* Benchmark::ArgName(const std::string& name) {
function Benchmark (line 308) | Benchmark* Benchmark::ArgNames(const std::vector<std::string>& names) {
function Benchmark (line 314) | Benchmark* Benchmark::DenseRange(int64_t start, int64_t limit, int s...
function Benchmark (line 323) | Benchmark* Benchmark::Args(const std::vector<int64_t>& args) {
function Benchmark (line 329) | Benchmark* Benchmark::Apply(void (*custom_arguments)(Benchmark* benc...
function Benchmark (line 334) | Benchmark* Benchmark::Setup(void (*setup)(const benchmark::State&)) {
function Benchmark (line 340) | Benchmark* Benchmark::Teardown(void (*teardown)(const benchmark::Sta...
function Benchmark (line 346) | Benchmark* Benchmark::RangeMultiplier(int multiplier) {
function Benchmark (line 352) | Benchmark* Benchmark::MinTime(double t) {
function Benchmark (line 359) | Benchmark* Benchmark::MinWarmUpTime(double t) {
function Benchmark (line 366) | Benchmark* Benchmark::Iterations(IterationCount n) {
function Benchmark (line 374) | Benchmark* Benchmark::Repetitions(int n) {
function Benchmark (line 380) | Benchmark* Benchmark::ReportAggregatesOnly(bool value) {
function Benchmark (line 385) | Benchmark* Benchmark::DisplayAggregatesOnly(bool value) {
function Benchmark (line 401) | Benchmark* Benchmark::MeasureProcessCPUTime() {
function Benchmark (line 407) | Benchmark* Benchmark::UseRealTime() {
function Benchmark (line 414) | Benchmark* Benchmark::UseManualTime() {
function Benchmark (line 421) | Benchmark* Benchmark::Complexity(BigO complexity) {
function Benchmark (line 426) | Benchmark* Benchmark::Complexity(BigOFunc* complexity) {
function Benchmark (line 432) | Benchmark* Benchmark::ComputeStatistics(const std::string& name,
function Benchmark (line 439) | Benchmark* Benchmark::Threads(int t) {
function Benchmark (line 445) | Benchmark* Benchmark::ThreadRange(int min_threads, int max_threads) {
function Benchmark (line 453) | Benchmark* Benchmark::DenseThreadRange(int min_threads, int max_thre...
function Benchmark (line 466) | Benchmark* Benchmark::ThreadPerCpu() {
function TimeUnit (line 489) | TimeUnit Benchmark::GetTimeUnit() const {
function ClearRegisteredBenchmarks (line 501) | void ClearRegisteredBenchmarks() {
function CreateRange (line 505) | std::vector<int64_t> CreateRange(int64_t lo, int64_t hi, int multi) {
function CreateDenseRange (line 511) | std::vector<int64_t> CreateDenseRange(int64_t start, int64_t limit, in...
FILE: 3rd/benchmark-1.8.2/src/benchmark_register.h
function namespace (line 10) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/benchmark_runner.cc
type benchmark (line 59) | namespace benchmark {
type internal (line 61) | namespace internal {
function CreateRunReport (line 71) | BenchmarkReporter::Run CreateRunReport(
function RunInThread (line 123) | void RunInThread(const BenchmarkInstance* b, IterationCount iters,
function ComputeMinTime (line 148) | double ComputeMinTime(const benchmark::internal::BenchmarkInstance& b,
function IterationCount (line 158) | IterationCount ComputeIters(const benchmark::internal::BenchmarkInst...
function BenchTimeType (line 170) | BenchTimeType ParseBenchMinTime(const std::string& value) {
function IterationCount (line 313) | IterationCount BenchmarkRunner::PredictNumItersNeeded(
function RunResults (line 486) | RunResults&& BenchmarkRunner::GetResults() {
FILE: 3rd/benchmark-1.8.2/src/benchmark_runner.h
function namespace (line 26) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/check.cc
type benchmark (line 3) | namespace benchmark {
type internal (line 4) | namespace internal {
function BENCHMARK_EXPORT (line 8) | BENCHMARK_EXPORT AbortHandlerT*& GetAbortHandler() { return handler; }
FILE: 3rd/benchmark-1.8.2/src/check.h
function namespace (line 29) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/colorprint.cc
type benchmark (line 34) | namespace benchmark {
function PlatformColorCode (line 42) | PlatformColorCode GetPlatformColorCode(LogColor color) {
function FormatString (line 85) | std::string FormatString(const char* msg, va_list args) {
function FormatString (line 113) | std::string FormatString(const char* msg, ...) {
function ColorPrintf (line 121) | void ColorPrintf(std::ostream& out, LogColor color, const char* fmt, ....
function ColorPrintf (line 128) | void ColorPrintf(std::ostream& out, LogColor color, const char* fmt,
function IsColorTerminal (line 158) | bool IsColorTerminal() {
FILE: 3rd/benchmark-1.8.2/src/colorprint.h
function namespace (line 8) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/commandlineflags.cc
type benchmark (line 28) | namespace benchmark {
function ParseInt32 (line 34) | bool ParseInt32(const std::string& src_text, const char* str, int32_t*...
function ParseDouble (line 68) | bool ParseDouble(const std::string& src_text, const char* str, double*...
function ParseKvPairs (line 87) | bool ParseKvPairs(const std::string& src_text, const char* str,
function FlagToEnvVar (line 112) | static std::string FlagToEnvVar(const char* flag) {
function BENCHMARK_EXPORT (line 124) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 131) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 144) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 157) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 164) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 209) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 222) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 235) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 248) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 260) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 276) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 281) | BENCHMARK_EXPORT
FILE: 3rd/benchmark-1.8.2/src/commandlineflags.h
function namespace (line 37) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/complexity.cc
type benchmark (line 26) | namespace benchmark {
function BigOFunc (line 29) | BigOFunc* FittingCurve(BigO complexity) {
function GetBigOString (line 54) | std::string GetBigOString(BigO complexity) {
function LeastSq (line 83) | LeastSq MinimalLeastSq(const std::vector<int64_t>& n,
function LeastSq (line 125) | LeastSq MinimalLeastSq(const std::vector<int64_t>& n,
function ComputeBigO (line 157) | std::vector<BenchmarkReporter::Run> ComputeBigO(
FILE: 3rd/benchmark-1.8.2/src/console_reporter.cc
type benchmark (line 34) | namespace benchmark {
function BENCHMARK_EXPORT (line 36) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 56) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 74) | BENCHMARK_EXPORT
function IgnoreColorPrint (line 96) | static void IgnoreColorPrint(std::ostream& out, LogColor, const char* ...
function FormatTime (line 104) | static std::string FormatTime(double time) {
function BENCHMARK_EXPORT (line 126) | BENCHMARK_EXPORT
FILE: 3rd/benchmark-1.8.2/src/counter.cc
type benchmark (line 17) | namespace benchmark {
type internal (line 18) | namespace internal {
function Finish (line 20) | double Finish(Counter const& c, IterationCount iterations, double cp...
function Finish (line 42) | void Finish(UserCounters* l, IterationCount iterations, double cpu_t...
function Increment (line 49) | void Increment(UserCounters* l, UserCounters const& r) {
function SameNames (line 66) | bool SameNames(UserCounters const& l, UserCounters const& r) {
FILE: 3rd/benchmark-1.8.2/src/counter.h
function namespace (line 20) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/csv_reporter.cc
type benchmark (line 30) | namespace benchmark {
function CsvEscape (line 39) | std::string CsvEscape(const std::string& s) {
function BENCHMARK_EXPORT (line 55) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 61) | BENCHMARK_EXPORT
function BENCHMARK_EXPORT (line 108) | BENCHMARK_EXPORT
FILE: 3rd/benchmark-1.8.2/src/cycleclock.h
function namespace (line 54) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/json_reporter.cc
type benchmark (line 30) | namespace benchmark {
function StrEscape (line 33) | std::string StrEscape(const std::string& s) {
function FormatKV (line 67) | std::string FormatKV(std::string const& key, std::string const& value) {
function FormatKV (line 72) | std::string FormatKV(std::string const& key, const char* value) {
function FormatKV (line 77) | std::string FormatKV(std::string const& key, bool value) {
function FormatKV (line 82) | std::string FormatKV(std::string const& key, int64_t value) {
function FormatKV (line 88) | std::string FormatKV(std::string const& key, double value) {
function RoundDouble (line 106) | int64_t RoundDouble(double v) { return std::lround(v); }
FILE: 3rd/benchmark-1.8.2/src/log.h
function namespace (line 14) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/mutex.h
function namespace (line 67) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/perf_counters.cc
type benchmark (line 26) | namespace benchmark {
type internal (line 27) | namespace internal {
function PerfCounters (line 74) | PerfCounters PerfCounters::Create(
function PerfCounters (line 241) | PerfCounters PerfCounters::Create(
function PerfCounters (line 258) | PerfCounters& PerfCounters::operator=(PerfCounters&& other) noexcept {
FILE: 3rd/benchmark-1.8.2/src/perf_counters.h
function namespace (line 39) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/re.h
function class (line 61) | class Regex {
function Init (line 90) | inline bool Regex::Init(const std::string& spec, std::string* error) {
FILE: 3rd/benchmark-1.8.2/src/reporter.cc
type benchmark (line 27) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/statistics.cc
type benchmark (line 27) | namespace benchmark {
function StatisticsMean (line 33) | double StatisticsMean(const std::vector<double>& v) {
function StatisticsMedian (line 38) | double StatisticsMedian(const std::vector<double>& v) {
function StatisticsStdDev (line 67) | double StatisticsStdDev(const std::vector<double>& v) {
function StatisticsCV (line 78) | double StatisticsCV(const std::vector<double>& v) {
function ComputeStats (line 87) | std::vector<BenchmarkReporter::Run> ComputeStats(
FILE: 3rd/benchmark-1.8.2/src/statistics.h
function namespace (line 23) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/string_util.cc
type benchmark (line 15) | namespace benchmark {
function ToExponentAndMantissa (line 33) | void ToExponentAndMantissa(double val, double thresh, int precision,
function ExponentToPrefix (line 89) | std::string ExponentToPrefix(int64_t exponent, bool iec) {
function ToBinaryStringFullySpecified (line 103) | std::string ToBinaryStringFullySpecified(double value, double threshold,
function AppendHumanReadable (line 114) | void AppendHumanReadable(int n, std::string* str) {
function HumanReadableNumber (line 121) | std::string HumanReadableNumber(double n, double one_k) {
function StrFormatImp (line 128) | std::string StrFormatImp(const char* msg, va_list args) {
function StrFormat (line 158) | std::string StrFormat(const char* format, ...) {
function StrSplit (line 166) | std::vector<std::string> StrSplit(const std::string& str, char delim) {
function stoul (line 186) | unsigned long stoul(const std::string& str, size_t* pos, int base) {
function stoi (line 212) | int stoi(const std::string& str, size_t* pos, int base) {
function stod (line 238) | double stod(const std::string& str, size_t* pos) {
FILE: 3rd/benchmark-1.8.2/src/string_util.h
function namespace (line 13) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/sysinfo.cc
type benchmark (line 80) | namespace benchmark {
function PrintImp (line 83) | void PrintImp(std::ostream& out) { out << std::endl; }
function PrintImp (line 86) | void PrintImp(std::ostream& out, First&& f, Rest&&... rest) {
function BENCHMARK_NORETURN (line 92) | BENCHMARK_NORETURN void PrintErrorAndDie(Args&&... args) {
type ValueUnion (line 101) | struct ValueUnion {
method ValueUnion (line 115) | ValueUnion() : size(0), buff(nullptr, &std::free) {}
method ValueUnion (line 117) | explicit ValueUnion(std::size_t buff_size)
method ValueUnion (line 121) | ValueUnion(ValueUnion&& other) = default;
method GetAsString (line 127) | std::string GetAsString() const { return std::string(data()); }
method GetAsInteger (line 129) | int64_t GetAsInteger() const {
method GetAsArray (line 138) | std::array<T, N> GetAsArray() {
function ValueUnion (line 147) | ValueUnion GetSysctlImp(std::string const& name) {
method ValueUnion (line 115) | ValueUnion() : size(0), buff(nullptr, &std::free) {}
method ValueUnion (line 117) | explicit ValueUnion(std::size_t buff_size)
method ValueUnion (line 121) | ValueUnion(ValueUnion&& other) = default;
method GetAsString (line 127) | std::string GetAsString() const { return std::string(data()); }
method GetAsInteger (line 129) | int64_t GetAsInteger() const {
method GetAsArray (line 138) | std::array<T, N> GetAsArray() {
function BENCHMARK_MAYBE_UNUSED (line 179) | BENCHMARK_MAYBE_UNUSED
function GetSysctl (line 190) | bool GetSysctl(std::string const& name, Tp* out) {
function GetSysctl (line 199) | bool GetSysctl(std::string const& name, std::array<Tp, N>* out) {
function ReadFromFile (line 208) | bool ReadFromFile(std::string const& fname, ArgT* arg) {
function CpuScaling (line 216) | CPUInfo::Scaling CpuScaling(int num_cpus) {
function CountSetBitsInCPUMap (line 238) | int CountSetBitsInCPUMap(std::string val) {
function BENCHMARK_MAYBE_UNUSED (line 257) | BENCHMARK_MAYBE_UNUSED
function GetCacheSizesMacOSX (line 296) | std::vector<CPUInfo::CacheInfo> GetCacheSizesMacOSX() {
function GetCacheSizesWindows (line 323) | std::vector<CPUInfo::CacheInfo> GetCacheSizesWindows() {
function GetCacheSizesQNX (line 370) | std::vector<CPUInfo::CacheInfo> GetCacheSizesQNX() {
function GetCacheSizes (line 407) | std::vector<CPUInfo::CacheInfo> GetCacheSizes() {
function GetSystemName (line 421) | std::string GetSystemName() {
function GetNumCPUs (line 471) | int GetNumCPUs() {
class ThreadAffinityGuard (line 552) | class ThreadAffinityGuard final {
method ThreadAffinityGuard (line 554) | ThreadAffinityGuard() : reset_affinity(SetAffinity()) {
method ThreadAffinityGuard (line 575) | ThreadAffinityGuard(ThreadAffinityGuard&&) = delete;
method ThreadAffinityGuard (line 576) | ThreadAffinityGuard(const ThreadAffinityGuard&) = delete;
method ThreadAffinityGuard (line 577) | ThreadAffinityGuard& operator=(ThreadAffinityGuard&&) = delete;
method ThreadAffinityGuard (line 578) | ThreadAffinityGuard& operator=(const ThreadAffinityGuard&) = delete;
method SetAffinity (line 581) | bool SetAffinity() {
function GetCPUCyclesPerSecond (line 626) | double GetCPUCyclesPerSecond(CPUInfo::Scaling scaling) {
function GetLoadAvg (line 816) | std::vector<double> GetLoadAvg() {
function CPUInfo (line 837) | const CPUInfo& CPUInfo::Get() {
function SystemInfo (line 849) | const SystemInfo& SystemInfo::Get() {
FILE: 3rd/benchmark-1.8.2/src/thread_manager.h
function namespace (line 9) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/thread_timer.h
function namespace (line 7) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/src/timers.cc
type benchmark (line 64) | namespace benchmark {
function MakeTime (line 76) | double MakeTime(FILETIME const& kernel_time, FILETIME const& user_time) {
function MakeTime (line 88) | double MakeTime(struct rusage const& ru) {
function MakeTime (line 96) | double MakeTime(thread_basic_info_data_t const& info) {
function MakeTime (line 104) | double MakeTime(struct timespec const& ts) {
function BENCHMARK_NORETURN (line 109) | BENCHMARK_NORETURN static void DiagnoseAndExit(const char* msg) {
function ProcessCPUUsage (line 116) | double ProcessCPUUsage() {
function ThreadCPUUsage (line 151) | double ThreadCPUUsage() {
function LocalDateTimeString (line 197) | std::string LocalDateTimeString() {
FILE: 3rd/benchmark-1.8.2/src/timers.h
function namespace (line 7) | namespace benchmark {
FILE: 3rd/benchmark-1.8.2/test/args_product_test.cc
class ArgsProductFixture (line 8) | class ArgsProductFixture : public ::benchmark::Fixture {
method ArgsProductFixture (line 10) | ArgsProductFixture()
method SetUp (line 26) | void SetUp(const ::benchmark::State& state) override {
FILE: 3rd/benchmark-1.8.2/test/basic_test.cc
function BM_empty (line 6) | void BM_empty(benchmark::State& state) {
function BM_spin_empty (line 15) | void BM_spin_empty(benchmark::State& state) {
function BM_spin_pause_before (line 25) | void BM_spin_pause_before(benchmark::State& state) {
function BM_spin_pause_during (line 38) | void BM_spin_pause_during(benchmark::State& state) {
function BM_pause_during (line 53) | void BM_pause_during(benchmark::State& state) {
function BM_spin_pause_after (line 64) | void BM_spin_pause_after(benchmark::State& state) {
function BM_spin_pause_before_and_after (line 77) | void BM_spin_pause_before_and_after(benchmark::State& state) {
function BM_empty_stop_start (line 93) | void BM_empty_stop_start(benchmark::State& state) {
function BM_KeepRunning (line 100) | void BM_KeepRunning(benchmark::State& state) {
function BM_KeepRunningBatch (line 110) | void BM_KeepRunningBatch(benchmark::State& state) {
function BM_RangedFor (line 136) | void BM_RangedFor(benchmark::State& state) {
function BM_OneTemplateFunc (line 147) | void BM_OneTemplateFunc(benchmark::State& state) {
function BM_TwoTemplateFunc (line 158) | void BM_TwoTemplateFunc(benchmark::State& state) {
FILE: 3rd/benchmark-1.8.2/test/benchmark_gtest.cc
type benchmark (line 10) | namespace benchmark {
type internal (line 11) | namespace internal {
function TEST (line 15) | TEST(AddRangeTest, Simple) {
function TEST (line 21) | TEST(AddRangeTest, Simple64) {
function TEST (line 27) | TEST(AddRangeTest, Advanced) {
function TEST (line 33) | TEST(AddRangeTest, Advanced64) {
function TEST (line 39) | TEST(AddRangeTest, FullRange8) {
function TEST (line 46) | TEST(AddRangeTest, FullRange64) {
function TEST (line 55) | TEST(AddRangeTest, NegativeRanges) {
function TEST (line 61) | TEST(AddRangeTest, StrictlyNegative) {
function TEST (line 67) | TEST(AddRangeTest, SymmetricNegativeRanges) {
function TEST (line 73) | TEST(AddRangeTest, SymmetricNegativeRangesOddMult) {
function TEST (line 79) | TEST(AddRangeTest, NegativeRangesAsymmetric) {
function TEST (line 85) | TEST(AddRangeTest, NegativeRangesLargeStep) {
function TEST (line 92) | TEST(AddRangeTest, ZeroOnlyRange) {
function TEST (line 98) | TEST(AddRangeTest, ZeroStartingRange) {
function TEST (line 104) | TEST(AddRangeTest, NegativeRange64) {
function TEST (line 110) | TEST(AddRangeTest, NegativeRangePreservesExistingOrder) {
function TEST (line 118) | TEST(AddRangeTest, FullNegativeRange64) {
function TEST (line 131) | TEST(AddRangeTest, Simple8) {
function TEST (line 138) | TEST(AddCustomContext, Simple) {
function TEST (line 153) | TEST(AddCustomContext, DuplicateKey) {
FILE: 3rd/benchmark-1.8.2/test/benchmark_min_time_flag_iters_test.cc
class TestReporter (line 14) | class TestReporter : public benchmark::ConsoleReporter {
method ReportContext (line 16) | virtual bool ReportContext(const Context& context) BENCHMARK_OVERRIDE {
method ReportRuns (line 20) | virtual void ReportRuns(const std::vector<Run>& report) BENCHMARK_OVER...
method TestReporter (line 26) | TestReporter() {}
function BM_MyBench (line 40) | static void BM_MyBench(benchmark::State& state) {
function main (line 46) | int main(int argc, char** argv) {
FILE: 3rd/benchmark-1.8.2/test/benchmark_min_time_flag_time_test.cc
class TestReporter (line 20) | class TestReporter : public benchmark::ConsoleReporter {
method ReportContext (line 22) | virtual bool ReportContext(const Context& context) BENCHMARK_OVERRIDE {
method ReportRuns (line 26) | virtual void ReportRuns(const std::vector<Run>& report) BENCHMARK_OVER...
method ReportRunsConfig (line 31) | virtual void ReportRunsConfig(double min_time, bool /* has_explicit_it...
method TestReporter (line 36) | TestReporter() {}
function AlmostEqual (line 46) | bool AlmostEqual(double a, double b) {
function DoTestHelper (line 50) | void DoTestHelper(int* argc, const char** argv, double expected) {
function BM_MyBench (line 65) | static void BM_MyBench(benchmark::State& state) {
function main (line 71) | int main(int argc, char** argv) {
FILE: 3rd/benchmark-1.8.2/test/benchmark_name_gtest.cc
function TEST (line 9) | TEST(BenchmarkNameTest, Empty) {
function TEST (line 14) | TEST(BenchmarkNameTest, FunctionName) {
function TEST (line 20) | TEST(BenchmarkNameTest, FunctionNameAndArgs) {
function TEST (line 27) | TEST(BenchmarkNameTest, MinTime) {
function TEST (line 35) | TEST(BenchmarkNameTest, MinWarmUpTime) {
function TEST (line 43) | TEST(BenchmarkNameTest, Iterations) {
function TEST (line 51) | TEST(BenchmarkNameTest, Repetitions) {
function TEST (line 59) | TEST(BenchmarkNameTest, TimeType) {
function TEST (line 67) | TEST(BenchmarkNameTest, Threads) {
function TEST (line 75) | TEST(BenchmarkNameTest, TestEmptyFunctionName) {
FILE: 3rd/benchmark-1.8.2/test/benchmark_random_interleaving_gtest.cc
type benchmark (line 11) | namespace benchmark {
type internal (line 17) | namespace internal {
class EventQueue (line 20) | class EventQueue : public std::queue<std::string> {
method Put (line 22) | void Put(const std::string& event) { push(event); }
method Clear (line 24) | void Clear() {
method Get (line 30) | std::string Get() {
class NullReporter (line 39) | class NullReporter : public BenchmarkReporter {
method ReportContext (line 41) | bool ReportContext(const Context& /*context*/) override { return t...
method ReportRuns (line 42) | void ReportRuns(const std::vector<Run>& /* report */) override {}
class BenchmarkTest (line 45) | class BenchmarkTest : public testing::Test {
method SetupHook (line 47) | static void SetupHook(int /* num_threads */) { queue->push("Setup"...
method TeardownHook (line 49) | static void TeardownHook(int /* num_threads */) { queue->push("Tea...
method Execute (line 51) | void Execute(const std::string& pattern) {
function BM_Match1 (line 62) | void BM_Match1(benchmark::State& state) {
function TEST_F (line 78) | TEST_F(BenchmarkTest, Match1) {
function TEST_F (line 91) | TEST_F(BenchmarkTest, Match1WithRepetition) {
function TEST_F (line 102) | TEST_F(BenchmarkTest, Match1WithRandomInterleaving) {
FILE: 3rd/benchmark-1.8.2/test/benchmark_setup_teardown_test.cc
type singlethreaded (line 13) | namespace singlethreaded {
function DoSetup1 (line 17) | static void DoSetup1(const benchmark::State& state) {
function DoTeardown1 (line 24) | static void DoTeardown1(const benchmark::State& state) {
function BM_with_setup (line 29) | static void BM_with_setup(benchmark::State& state) {
type concurrent (line 43) | namespace concurrent {
function DoSetup2 (line 49) | static void DoSetup2(const benchmark::State& state) {
function DoTeardown2 (line 54) | static void DoTeardown2(const benchmark::State& state) {
function BM_concurrent (line 59) | static void BM_concurrent(benchmark::State& state) {
type fixture_interaction (line 74) | namespace fixture_interaction {
class FIXTURE_BECHMARK_NAME (line 81) | class FIXTURE_BECHMARK_NAME : public ::benchmark::Fixture {
method SetUp (line 83) | void SetUp(const ::benchmark::State&) override {
function DoSetupWithFixture (line 95) | static void DoSetupWithFixture(const benchmark::State&) {
type repetitions (line 109) | namespace repetitions {
function DoSetupWithRepetitions (line 113) | static void DoSetupWithRepetitions(const benchmark::State&) {
function BM_WithRep (line 116) | static void BM_WithRep(benchmark::State& state) {
function main (line 130) | int main(int argc, char** argv) {
FILE: 3rd/benchmark-1.8.2/test/benchmark_test.cc
function CalculatePi (line 34) | double CalculatePi(int depth) {
function ConstructRandomSet (line 44) | std::set<int64_t> ConstructRandomSet(int64_t size) {
function BM_Factorial (line 55) | static void BM_Factorial(benchmark::State& state) {
function BM_CalculatePiRange (line 66) | static void BM_CalculatePiRange(benchmark::State& state) {
function BM_CalculatePi (line 75) | static void BM_CalculatePi(benchmark::State& state) {
function BM_SetInsert (line 86) | static void BM_SetInsert(benchmark::State& state) {
function BM_Sequential (line 106) | static void BM_Sequential(benchmark::State& state) {
function BM_StringCompare (line 124) | static void BM_StringCompare(benchmark::State& state) {
function BM_SetupTeardown (line 135) | static void BM_SetupTeardown(benchmark::State& state) {
function BM_LongTest (line 155) | static void BM_LongTest(benchmark::State& state) {
function BM_ParallelMemset (line 164) | static void BM_ParallelMemset(benchmark::State& state) {
function BM_ManualTiming (line 188) | static void BM_ManualTiming(benchmark::State& state) {
function BM_with_args (line 215) | void BM_with_args(benchmark::State& state, Args&&...) {
function BM_non_template_args (line 223) | void BM_non_template_args(benchmark::State& state, int, double) {
function BM_DenseThreadRanges (line 231) | static void BM_DenseThreadRanges(benchmark::State& st) {
function BM_BenchmarkName (line 253) | static void BM_BenchmarkName(benchmark::State& state) {
function BM_templated_test (line 264) | static void BM_templated_test(benchmark::State& state) {
FILE: 3rd/benchmark-1.8.2/test/clobber_memory_assembly_test.cc
function test_basic (line 16) | void test_basic() {
function test_redundant_store (line 27) | void test_redundant_store() {
function test_redundant_read (line 37) | void test_redundant_read() {
function test_redundant_read2 (line 51) | void test_redundant_read2() {
FILE: 3rd/benchmark-1.8.2/test/commandlineflags_gtest.cc
type benchmark (line 8) | namespace benchmark {
function setenv (line 12) | int setenv(const char* name, const char* value, int overwrite) {
function unsetenv (line 23) | int unsetenv(const char* name) { return _putenv_s(name, ""); }
function TEST (line 27) | TEST(BoolFromEnv, Default) {
function TEST (line 32) | TEST(BoolFromEnv, False) {
function TEST (line 90) | TEST(BoolFromEnv, True) {
function TEST (line 154) | TEST(Int32FromEnv, NotInEnv) {
function TEST (line 159) | TEST(Int32FromEnv, InvalidInteger) {
function TEST (line 165) | TEST(Int32FromEnv, ValidInteger) {
function TEST (line 171) | TEST(DoubleFromEnv, NotInEnv) {
function TEST (line 176) | TEST(DoubleFromEnv, InvalidReal) {
function TEST (line 182) | TEST(DoubleFromEnv, ValidReal) {
function TEST (line 188) | TEST(StringFromEnv, Default) {
function TEST (line 193) | TEST(StringFromEnv, Valid) {
function TEST (line 199) | TEST(KvPairsFromEnv, Default) {
function TEST (line 205) | TEST(KvPairsFromEnv, MalformedReturnsDefault) {
function TEST (line 212) | TEST(KvPairsFromEnv, Single) {
function TEST (line 219) | TEST(KvPairsFromEnv, Multiple) {
FILE: 3rd/benchmark-1.8.2/test/complexity_test.cc
function AddComplexityTest (line 16) | int AddComplexityTest(const std::string &test_name,
function BM_Complexity_O1 (line 70) | void BM_Complexity_O1(benchmark::State &state) {
function ConstructRandomVector (line 110) | std::vector<int> ConstructRandomVector(int64_t size) {
function BM_Complexity_O_N (line 119) | void BM_Complexity_O_N(benchmark::State &state) {
function BM_Complexity_O_N_log_N (line 162) | static void BM_Complexity_O_N_log_N(benchmark::State &state) {
function BM_ComplexityCaptureArgs (line 205) | void BM_ComplexityCaptureArgs(benchmark::State &state, int n) {
function main (line 228) | int main(int argc, char *argv[]) { RunOutputTests(argc, argv); }
FILE: 3rd/benchmark-1.8.2/test/cxx03_test.cc
function BM_empty (line 15) | void BM_empty(benchmark::State& state) {
function BM_old_arg_range_interface (line 25) | void BM_old_arg_range_interface(benchmark::State& state) {
function BM_template2 (line 34) | void BM_template2(benchmark::State& state) {
function BM_template1 (line 40) | void BM_template1(benchmark::State& state) {
type BM_Fixture (line 47) | struct BM_Fixture : public ::benchmark::Fixture {}
function BM_counters (line 56) | void BM_counters(benchmark::State& state) {
FILE: 3rd/benchmark-1.8.2/test/diagnostics_test.cc
function TestHandler (line 20) | void TestHandler() {
function try_invalid_pause_resume (line 28) | void try_invalid_pause_resume(benchmark::State& state) {
function BM_diagnostic_test (line 46) | void BM_diagnostic_test(benchmark::State& state) {
function BM_diagnostic_test_keep_running (line 62) | void BM_diagnostic_test_keep_running(benchmark::State& state) {
function main (line 78) | int main(int argc, char* argv[]) {
FILE: 3rd/benchmark-1.8.2/test/display_aggregates_only_test.cc
function BM_SummaryRepeat (line 13) | void BM_SummaryRepeat(benchmark::State& state) {
function main (line 19) | int main(int argc, char* argv[]) {
FILE: 3rd/benchmark-1.8.2/test/donotoptimize_assembly_test.cc
function Add42 (line 17) | inline int Add42(int x) { return x + 42; }
type NotTriviallyCopyable (line 19) | struct NotTriviallyCopyable {
method NotTriviallyCopyable (line 21) | explicit NotTriviallyCopyable(int x) : value(x) {}
type Large (line 26) | struct Large {
type ExtraLarge (line 31) | struct ExtraLarge {
function test_with_rvalue (line 40) | void test_with_rvalue() {
function test_with_large_rvalue (line 47) | void test_with_large_rvalue() {
function test_with_non_trivial_rvalue (line 57) | void test_with_non_trivial_rvalue() {
function test_with_lvalue (line 64) | void test_with_lvalue() {
function test_with_large_lvalue (line 73) | void test_with_large_lvalue() {
function test_with_extra_large_lvalue_with_op (line 84) | void test_with_extra_large_lvalue_with_op() {
function test_with_big_array_with_op (line 92) | void test_with_big_array_with_op() {
function test_with_non_trivial_lvalue (line 100) | void test_with_non_trivial_lvalue() {
function test_with_const_lvalue (line 109) | void test_with_const_lvalue() {
function test_with_large_const_lvalue (line 117) | void test_with_large_const_lvalue() {
function test_with_const_extra_large_obj (line 128) | void test_with_const_extra_large_obj() {
function test_with_const_big_array (line 134) | void test_with_const_big_array() {
function test_with_non_trivial_const_lvalue (line 140) | void test_with_non_trivial_const_lvalue() {
function test_div_by_two (line 148) | int test_div_by_two(int input) {
function test_inc_integer (line 158) | int test_inc_integer() {
function test_pointer_rvalue (line 172) | void test_pointer_rvalue() {
function test_pointer_const_lvalue (line 182) | void test_pointer_const_lvalue() {
function test_pointer_lvalue (line 193) | void test_pointer_lvalue() {
FILE: 3rd/benchmark-1.8.2/test/donotoptimize_test.cc
function double_up (line 9) | std::int64_t double_up(const std::int64_t x) { return x * 2; }
type BitRef (line 14) | struct BitRef {
method BitRef (line 19) | static BitRef Make() {
method BitRef (line 26) | BitRef(int i, unsigned char& b) : index(i), byte(b) {}
function main (line 29) | int main(int, char*[]) {
FILE: 3rd/benchmark-1.8.2/test/filter_test.cc
class TestReporter (line 15) | class TestReporter : public benchmark::ConsoleReporter {
method ReportContext (line 17) | bool ReportContext(const Context& context) override {
method ReportRuns (line 21) | void ReportRuns(const std::vector<Run>& report) override {
method TestReporter (line 27) | TestReporter() : count_(0), max_family_index_(0) {}
method GetCount (line 31) | int GetCount() const { return count_; }
method GetMaxFamilyIndex (line 33) | int64_t GetMaxFamilyIndex() const { return max_family_index_; }
function NoPrefix (line 42) | static void NoPrefix(benchmark::State& state) {
function BM_Foo (line 48) | static void BM_Foo(benchmark::State& state) {
function BM_Bar (line 54) | static void BM_Bar(benchmark::State& state) {
function BM_FooBar (line 60) | static void BM_FooBar(benchmark::State& state) {
function BM_FooBa (line 66) | static void BM_FooBa(benchmark::State& state) {
function main (line 72) | int main(int argc, char** argv) {
FILE: 3rd/benchmark-1.8.2/test/fixture_test.cc
class FIXTURE_BECHMARK_NAME (line 9) | class FIXTURE_BECHMARK_NAME : public ::benchmark::Fixture {
method SetUp (line 11) | void SetUp(const ::benchmark::State& state) override {
method TearDown (line 18) | void TearDown(const ::benchmark::State& state) override {
FILE: 3rd/benchmark-1.8.2/test/internal_threading_test.cc
function MyBusySpinwait (line 17) | void MyBusySpinwait() {
function BM_MainThread (line 37) | void BM_MainThread(benchmark::State& state) {
function BM_WorkerThread (line 79) | void BM_WorkerThread(benchmark::State& state) {
function BM_MainThreadAndWorkerThread (line 122) | void BM_MainThreadAndWorkerThread(benchmark::State& state) {
function main (line 185) | int main(int argc, char* argv[]) { RunOutputTests(argc, argv); }
FILE: 3rd/benchmark-1.8.2/test/link_main_test.cc
function BM_empty (line 3) | void BM_empty(benchmark::State& state) {
FILE: 3rd/benchmark-1.8.2/test/map_test.cc
function ConstructRandomMap (line 8) | std::map<int, int> ConstructRandomMap(int size) {
function BM_MapLookup (line 19) | static void BM_MapLookup(benchmark::State& state) {
class MapFixture (line 36) | class MapFixture : public ::benchmark::Fixture {
method SetUp (line 38) | void SetUp(const ::benchmark::State& st) override {
method TearDown (line 42) | void TearDown(const ::benchmark::State&) override { m.clear(); }
FILE: 3rd/benchmark-1.8.2/test/memory_manager_test.cc
class TestMemoryManager (line 7) | class TestMemoryManager : public benchmark::MemoryManager {
method Start (line 8) | void Start() override {}
method Stop (line 9) | void Stop(Result& result) override {
function BM_empty (line 15) | void BM_empty(benchmark::State& state) {
function main (line 41) | int main(int argc, char* argv[]) {
FILE: 3rd/benchmark-1.8.2/test/min_time_parse_gtest.cc
function TEST (line 6) | TEST(ParseMinTimeTest, InvalidInput) {
FILE: 3rd/benchmark-1.8.2/test/multiple_ranges_test.cc
class MultipleRangesFixture (line 8) | class MultipleRangesFixture : public ::benchmark::Fixture {
method MultipleRangesFixture (line 10) | MultipleRangesFixture()
method SetUp (line 31) | void SetUp(const ::benchmark::State& state) override {
function BM_CheckDefaultArgument (line 81) | void BM_CheckDefaultArgument(benchmark::State& state) {
function BM_MultipleRanges (line 90) | static void BM_MultipleRanges(benchmark::State& st) {
FILE: 3rd/benchmark-1.8.2/test/options_test.cc
function BM_basic (line 11) | void BM_basic(benchmark::State& state) {
function BM_basic_slow (line 16) | void BM_basic_slow(benchmark::State& state) {
function CustomArgs (line 53) | void CustomArgs(benchmark::internal::Benchmark* b) {
function BM_explicit_iteration_count (line 61) | void BM_explicit_iteration_count(benchmark::State& state) {
FILE: 3rd/benchmark-1.8.2/test/output_test.h
type MatchRules (line 24) | enum MatchRules {
type TestCase (line 31) | struct TestCase {
type TestCaseID (line 40) | enum TestCaseID {
type Results (line 85) | struct Results
type std (line 86) | typedef std::function<void(Results const&)> ResultsCheckFn;
function NumThreads (line 92) | struct Results {
function std (line 120) | const std::string* Get(const std::string& entry_name) const {
FILE: 3rd/benchmark-1.8.2/test/output_test_helper.cc
type internal (line 20) | namespace internal {
function TestCaseList (line 32) | TestCaseList& GetTestCaseList(TestCaseID ID) {
function SubMap (line 39) | SubMap& GetSubstitutions() {
function PerformSubstitutions (line 81) | std::string PerformSubstitutions(std::string source) {
function CheckCase (line 95) | void CheckCase(std::stringstream& remaining_output, TestCase const& TC,
function CheckCases (line 128) | void CheckCases(TestCaseList const& checks, std::stringstream& output) {
class TestReporter (line 141) | class TestReporter : public benchmark::BenchmarkReporter {
method TestReporter (line 143) | TestReporter(std::vector<benchmark::BenchmarkReporter*> reps)
method ReportContext (line 146) | bool ReportContext(const Context& context) override {
method ReportRuns (line 160) | void ReportRuns(const std::vector<Run>& report) override {
method Finalize (line 163) | void Finalize() override {
class ResultsChecker (line 182) | class ResultsChecker {
type PatternAndFn (line 184) | struct PatternAndFn : public TestCase { // reusing TestCase for its...
method PatternAndFn (line 185) | PatternAndFn(const std::string& rx, ResultsCheckFn fn_)
function ResultsChecker (line 207) | ResultsChecker& GetResultsChecker() {
type PatternAndFn (line 184) | struct PatternAndFn : public TestCase { // reusing TestCase for its...
method PatternAndFn (line 185) | PatternAndFn(const std::string& rx, ResultsCheckFn fn_)
type internal (line 178) | namespace internal {
function TestCaseList (line 32) | TestCaseList& GetTestCaseList(TestCaseID ID) {
function SubMap (line 39) | SubMap& GetSubstitutions() {
function PerformSubstitutions (line 81) | std::string PerformSubstitutions(std::string source) {
function CheckCase (line 95) | void CheckCase(std::stringstream& remaining_output, TestCase const& TC,
function CheckCases (line 128) | void CheckCases(TestCaseList const& checks, std::stringstream& output) {
class TestReporter (line 141) | class TestReporter : public benchmark::BenchmarkReporter {
method TestReporter (line 143) | TestReporter(std::vector<benchmark::BenchmarkReporter*> reps)
method ReportContext (line 146) | bool ReportContext(const Context& context) override {
method ReportRuns (line 160) | void ReportRuns(const std::vector<Run>& report) override {
method Finalize (line 163) | void Finalize() override {
class ResultsChecker (line 182) | class ResultsChecker {
type PatternAndFn (line 184) | struct PatternAndFn : public TestCase { // reusing TestCase for its...
method PatternAndFn (line 185) | PatternAndFn(const std::string& rx, ResultsCheckFn fn_)
function ResultsChecker (line 207) | ResultsChecker& GetResultsChecker() {
type PatternAndFn (line 184) | struct PatternAndFn : public TestCase { // reusing TestCase for its...
method PatternAndFn (line 185) | PatternAndFn(const std::string& rx, ResultsCheckFn fn_)
function AddChecker (line 302) | size_t AddChecker(const std::string& bm_name, const ResultsCheckFn& fn) {
function AddCases (line 361) | int AddCases(TestCaseID ID, std::initializer_list<TestCase> il) {
function SetSubstitutions (line 367) | int SetSubstitutions(
function BENCHMARK_DISABLE_DEPRECATED_WARNING (line 387) | BENCHMARK_DISABLE_DEPRECATED_WARNING
function BENCHMARK_RESTORE_DEPRECATED_WARNING (line 448) | BENCHMARK_RESTORE_DEPRECATED_WARNING
function ToHex (line 459) | static char ToHex(int ch) {
function RandomHexChar (line 464) | static char RandomHexChar() {
function GetRandomFileName (line 470) | static std::string GetRandomFileName() {
function FileExists (line 478) | static bool FileExists(std::string const& name) {
function GetTempFileName (line 483) | static std::string GetTempFileName() {
function GetFileReporterOutput (line 496) | std::string GetFileReporterOutput(int argc, char* argv[]) {
FILE: 3rd/benchmark-1.8.2/test/perf_counters_gtest.cc
type MsgHandler (line 8) | struct MsgHandler {
function TEST (line 23) | TEST(PerfCountersTest, Init) {
function TEST (line 27) | TEST(PerfCountersTest, OneCounter) {
function TEST (line 35) | TEST(PerfCountersTest, NegativeTest) {
function TEST (line 84) | TEST(PerfCountersTest, Read1Counter) {
function TEST (line 100) | TEST(PerfCountersTest, Read2Counters) {
function TEST (line 118) | TEST(PerfCountersTest, ReopenExistingCounters) {
function TEST (line 136) | TEST(PerfCountersTest, CreateExistingMeasurements) {
function BENCHMARK_DONT_OPTIMIZE (line 204) | BENCHMARK_DONT_OPTIMIZE size_t do_work() {
function measure (line 216) | void measure(size_t threadcount, PerfCounterValues* before,
function TEST (line 236) | TEST(PerfCountersTest, MultiThreaded) {
function TEST (line 266) | TEST(PerfCountersTest, HardwareLimits) {
FILE: 3rd/benchmark-1.8.2/test/perf_counters_test.cc
function BM_Simple (line 8) | static void BM_Simple(benchmark::State& state) {
function CheckSimple (line 17) | static void CheckSimple(Results const& e) {
function main (line 23) | int main(int argc, char* argv[]) {
FILE: 3rd/benchmark-1.8.2/test/register_benchmark_test.cc
class TestReporter (line 11) | class TestReporter : public benchmark::ConsoleReporter {
method ReportRuns (line 13) | void ReportRuns(const std::vector<Run>& report) override {
type TestCase (line 21) | struct TestCase {
method TestCase (line 25) | TestCase(const std::string& xname) : TestCase(xname, "") {}
method TestCase (line 26) | TestCase(const std::string& xname, const std::string& xlabel)
method CheckRun (line 31) | void CheckRun(Run const& run) const {
function AddCases (line 47) | int AddCases(std::initializer_list<TestCase> const& v) {
function BM_function (line 65) | void BM_function(benchmark::State& state) {
function BM_extra_args (line 81) | void BM_extra_args(benchmark::State& st, const char* label) {
function RegisterFromFunction (line 86) | int RegisterFromFunction() {
function DISABLED_BM_function (line 101) | void DISABLED_BM_function(benchmark::State& state) {
type CustomFixture (line 114) | struct CustomFixture {
function TestRegistrationAtRuntime (line 121) | void TestRegistrationAtRuntime() {
function RunTestOne (line 145) | void RunTestOne() {
function RunTestTwo (line 165) | void RunTestTwo() {
function main (line 191) | int main(int argc, char* argv[]) {
FILE: 3rd/benchmark-1.8.2/test/repetitions_test.cc
function BM_ExplicitRepetitions (line 9) | static void BM_ExplicitRepetitions(benchmark::State& state) {
function BM_ImplicitRepetitions (line 111) | static void BM_ImplicitRepetitions(benchmark::State& state) {
function main (line 214) | int main(int argc, char* argv[]) { RunOutputTests(argc, argv); }
FILE: 3rd/benchmark-1.8.2/test/report_aggregates_only_test.cc
function BM_SummaryRepeat (line 13) | void BM_SummaryRepeat(benchmark::State& state) {
function main (line 19) | int main(int argc, char* argv[]) {
FILE: 3rd/benchmark-1.8.2/test/reporter_output_test.cc
function AddContextCases (line 16) | static int AddContextCases() {
function BM_basic (line 67) | void BM_basic(benchmark::State& state) {
function BM_bytes_per_second (line 93) | void BM_bytes_per_second(benchmark::State& state) {
function BM_items_per_second (line 125) | void BM_items_per_second(benchmark::State& state) {
function BM_label (line 157) | void BM_label(benchmark::State& state) {
function BM_time_label_nanosecond (line 186) | void BM_time_label_nanosecond(benchmark::State& state) {
function BM_time_label_microsecond (line 209) | void BM_time_label_microsecond(benchmark::State& state) {
function BM_time_label_millisecond (line 232) | void BM_time_label_millisecond(benchmark::State& state) {
function BM_time_label_second (line 255) | void BM_time_label_second(benchmark::State& state) {
function BM_error (line 281) | void BM_error(benchmark::State& state) {
function BM_no_arg_name (line 306) | void BM_no_arg_name(benchmark::State& state) {
function BM_arg_name (line 326) | void BM_arg_name(benchmark::State& state) {
function BM_arg_names (line 346) | void BM_arg_names(benchmark::State& state) {
function BM_name (line 368) | void BM_name(benchmark::State& state) {
function BM_BigArgs (line 394) | void BM_BigArgs(benchmark::State& state) {
function BM_Complexity_O1 (line 406) | void BM_Complexity_O1(benchmark::State& state) {
function BM_Repeat (line 425) | void BM_Repeat(benchmark::State& state) {
function BM_RepeatOnce (line 639) | void BM_RepeatOnce(benchmark::State& state) {
function BM_SummaryRepeat (line 656) | void BM_SummaryRepeat(benchmark::State& state) {
function BM_SummaryDisplay (line 707) | void BM_SummaryDisplay(benchmark::State& state) {
function BM_RepeatTimeUnit (line 757) | void BM_RepeatTimeUnit(benchmark::State& state) {
function BM_UserStats (line 821) | void BM_UserStats(benchmark::State& state) {
function BM_UserPercentStats (line 952) | void BM_UserPercentStats(benchmark::State& state) {
function BM_JSON_Format (line 1097) | void BM_JSON_Format(benchmark::State& state) {
function BM_CSV_Format (line 1118) | void BM_CSV_Format(benchmark::State& state) {
function main (line 1130) | int main(int argc, char* argv[]) { RunOutputTests(argc, argv); }
FILE: 3rd/benchmark-1.8.2/test/skip_with_error_test.cc
class TestReporter (line 11) | class TestReporter : public benchmark::ConsoleReporter {
method ReportContext (line 13) | bool ReportContext(const Context& context) override {
method ReportRuns (line 17) | void ReportRuns(const std::vector<Run>& report) override {
method TestReporter (line 22) | TestReporter() {}
type TestCase (line 28) | struct TestCase {
method CheckRun (line 35) | void CheckRun(Run const& run) const {
function AddCases (line 51) | int AddCases(const std::string& base_name,
function BM_error_no_running (line 66) | void BM_error_no_running(benchmark::State& state) {
function BM_error_before_running (line 72) | void BM_error_before_running(benchmark::State& state) {
function BM_error_before_running_batch (line 81) | void BM_error_before_running_batch(benchmark::State& state) {
function BM_error_before_running_range_for (line 90) | void BM_error_before_running_range_for(benchmark::State& state) {
function BM_error_during_running (line 99) | void BM_error_during_running(benchmark::State& state) {
function BM_error_during_running_ranged_for (line 122) | void BM_error_during_running_ranged_for(benchmark::State& state) {
function BM_error_after_running (line 144) | void BM_error_after_running(benchmark::State& state) {
function BM_error_while_paused (line 158) | void BM_error_while_paused(benchmark::State& state) {
function main (line 182) | int main(int argc, char* argv[]) {
FILE: 3rd/benchmark-1.8.2/test/spec_arg_test.cc
class TestReporter (line 18) | class TestReporter : public benchmark::ConsoleReporter {
method ReportContext (line 20) | bool ReportContext(const Context& context) override {
method ReportRuns (line 24) | void ReportRuns(const std::vector<Run>& report) override {
method TestReporter (line 30) | TestReporter() {}
function BM_NotChosen (line 44) | static void BM_NotChosen(benchmark::State& state) {
function BM_Chosen (line 51) | static void BM_Chosen(benchmark::State& state) {
function main (line 57) | int main(int argc, char** argv) {
FILE: 3rd/benchmark-1.8.2/test/spec_arg_verbosity_test.cc
function BM_Verbosity (line 8) | static void BM_Verbosity(benchmark::State& state) {
function main (line 14) | int main(int argc, char** argv) {
FILE: 3rd/benchmark-1.8.2/test/state_assembly_test.cc
function test_for_auto_loop (line 18) | int test_for_auto_loop() {
function test_while_loop (line 41) | int test_while_loop() {
FILE: 3rd/benchmark-1.8.2/test/statistics_gtest.cc
function TEST (line 9) | TEST(StatisticsTest, Mean) {
function TEST (line 15) | TEST(StatisticsTest, Median) {
function TEST (line 21) | TEST(StatisticsTest, StdDev) {
function TEST (line 28) | TEST(StatisticsTest, CV) {
FILE: 3rd/benchmark-1.8.2/test/string_util_gtest.cc
function TEST (line 12) | TEST(StringUtilTest, stoul) {
function TEST (line 75) | TEST(StringUtilTest, stoi){{size_t pos = 0;
function TEST (line 122) | TEST(StringUtilTest, stod){{size_t pos = 0;
function TEST (line 155) | TEST(StringUtilTest, StrSplit) {
FILE: 3rd/benchmark-1.8.2/test/templated_fixture_test.cc
class MyFixture (line 8) | class MyFixture : public ::benchmark::Fixture {
method MyFixture (line 10) | MyFixture() : data(0) {}
FILE: 3rd/benchmark-1.8.2/test/time_unit_gtest.cc
type benchmark (line 4) | namespace benchmark {
type internal (line 5) | namespace internal {
class DummyBenchmark (line 9) | class DummyBenchmark : public Benchmark {
method DummyBenchmark (line 11) | DummyBenchmark() : Benchmark("dummy") {}
method Run (line 12) | void Run(State&) override {}
function TEST (line 15) | TEST(DefaultTimeUnitTest, TimeUnitIsNotSet) {
function TEST (line 20) | TEST(DefaultTimeUnitTest, DefaultIsSet) {
function TEST (line 27) | TEST(DefaultTimeUnitTest, DefaultAndExplicitUnitIsSet) {
FILE: 3rd/benchmark-1.8.2/test/user_counters_tabular_test.cc
function BM_Counters_Tabular (line 64) | void BM_Counters_Tabular(benchmark::State& state) {
function CheckTabular (line 355) | void CheckTabular(Results const& e) {
function BM_CounterRates_Tabular (line 372) | void BM_CounterRates_Tabular(benchmark::State& state) {
function CheckTabularRate (line 414) | void CheckTabularRate(Results const& e) {
function BM_CounterSet0_Tabular (line 431) | void BM_CounterSet0_Tabular(benchmark::State& state) {
function CheckSet0 (line 463) | void CheckSet0(Results const& e) {
function BM_CounterSet1_Tabular (line 471) | void BM_CounterSet1_Tabular(benchmark::State& state) {
function CheckSet1 (line 503) | void CheckSet1(Results const& e) {
function BM_CounterSet2_Tabular (line 515) | void BM_CounterSet2_Tabular(benchmark::State& state) {
function CheckSet2 (line 547) | void CheckSet2(Results const& e) {
function main (line 558) | int main(int argc, char* argv[]) { RunOutputTests(argc, argv); }
FILE: 3rd/benchmark-1.8.2/test/user_counters_test.cc
function BM_Counters_Simple (line 25) | void BM_Counters_Simple(benchmark::State& state) {
function CheckSimple (line 52) | void CheckSimple(Results const& e) {
function BM_Counters_WithBytesAndItemsPSec (line 67) | void BM_Counters_WithBytesAndItemsPSec(benchmark::State& state) {
function CheckBytesAndItemsPSec (line 104) | void CheckBytesAndItemsPSec(Results const& e) {
function BM_Counters_Rate (line 119) | void BM_Counters_Rate(benchmark::State& state) {
function CheckRate (line 151) | void CheckRate(Results const& e) {
function BM_Invert (line 163) | void BM_Invert(benchmark::State& state) {
function CheckInvert (line 194) | void CheckInvert(Results const& e) {
function BM_Counters_InvertedRate (line 204) | void BM_Counters_InvertedRate(benchmark::State& state) {
function CheckInvertedRate (line 239) | void CheckInvertedRate(Results const& e) {
function BM_Counters_Threads (line 251) | void BM_Counters_Threads(benchmark::State& state) {
function CheckThreads (line 281) | void CheckThreads(Results const& e) {
function BM_Counters_AvgThreads (line 291) | void BM_Counters_AvgThreads(benchmark::State& state) {
function CheckAvgThreads (line 322) | void CheckAvgThreads(Results const& e) {
function BM_Counters_AvgThreadsRate (line 333) | void BM_Counters_AvgThreadsRate(benchmark::State& state) {
function CheckAvgThreadsRate (line 367) | void CheckAvgThreadsRate(Results const& e) {
function BM_Counters_IterationInvariant (line 378) | void BM_Counters_IterationInvariant(benchmark::State& state) {
function CheckIterationInvariant (line 408) | void CheckIterationInvariant(Results const& e) {
function BM_Counters_kIsIterationInvariantRate (line 421) | void BM_Counters_kIsIterationInvariantRate(benchmark::State& state) {
function CheckIsIterationInvariantRate (line 457) | void CheckIsIterationInvariantRate(Results const& e) {
function BM_Counters_AvgIterations (line 471) | void BM_Counters_AvgIterations(benchmark::State& state) {
function CheckAvgIterations (line 501) | void CheckAvgIterations(Results const& e) {
function BM_Counters_kAvgIterationsRate (line 513) | void BM_Counters_kAvgIterationsRate(benchmark::State& state) {
function CheckAvgIterationsRate (line 547) | void CheckAvgIterationsRate(Results const& e) {
function main (line 561) | int main(int argc, char* argv[]) { RunOutputTests(argc, argv); }
FILE: 3rd/benchmark-1.8.2/test/user_counters_thousands_test.cc
function BM_Counters_Thousands (line 11) | void BM_Counters_Thousands(benchmark::State& state) {
function CheckThousands (line 168) | void CheckThousands(Results const& e) {
function main (line 186) | int main(int argc, char* argv[]) { RunOutputTests(argc, argv); }
FILE: 3rd/benchmark-1.8.2/tools/compare.py
function check_inputs (line 17) | def check_inputs(in1, in2, flags):
function create_parser (line 40) | def create_parser():
function main (line 184) | def main():
class TestParser (line 272) | class TestParser(unittest.TestCase):
method setUp (line 273) | def setUp(self):
method test_benchmarks_basic (line 283) | def test_benchmarks_basic(self):
method test_benchmarks_basic_without_utest (line 293) | def test_benchmarks_basic_without_utest(self):
method test_benchmarks_basic_display_aggregates_only (line 304) | def test_benchmarks_basic_display_aggregates_only(self):
method test_benchmarks_basic_with_utest_alpha (line 314) | def test_benchmarks_basic_with_utest_alpha(self):
method test_benchmarks_basic_without_utest_with_utest_alpha (line 325) | def test_benchmarks_basic_without_utest_with_utest_alpha(self):
method test_benchmarks_with_remainder (line 336) | def test_benchmarks_with_remainder(self):
method test_benchmarks_with_remainder_after_doubleminus (line 346) | def test_benchmarks_with_remainder_after_doubleminus(self):
method test_filters_basic (line 356) | def test_filters_basic(self):
method test_filters_with_remainder (line 367) | def test_filters_with_remainder(self):
method test_filters_with_remainder_after_doubleminus (line 378) | def test_filters_with_remainder_after_doubleminus(self):
method test_benchmarksfiltered_basic (line 389) | def test_benchmarksfiltered_basic(self):
method test_benchmarksfiltered_with_remainder (line 401) | def test_benchmarksfiltered_with_remainder(self):
method test_benchmarksfiltered_with_remainder_after_doubleminus (line 413) | def test_benchmarksfiltered_with_remainder_after_doubleminus(self):
FILE: 3rd/benchmark-1.8.2/tools/gbench/report.py
class BenchmarkColor (line 14) | class BenchmarkColor(object):
method __init__ (line 15) | def __init__(self, name, code):
method __repr__ (line 19) | def __repr__(self):
method __format__ (line 23) | def __format__(self, format):
function color_format (line 53) | def color_format(use_color, fmt_str, *args, **kwargs):
function find_longest_name (line 69) | def find_longest_name(benchmark_list):
function calculate_change (line 81) | def calculate_change(old_val, new_val):
function filter_benchmark (line 92) | def filter_benchmark(json_orig, family, replacement=""):
function get_unique_benchmark_names (line 108) | def get_unique_benchmark_names(json):
function intersect (line 119) | def intersect(list1, list2):
function is_potentially_comparable_benchmark (line 127) | def is_potentially_comparable_benchmark(x):
function partition_benchmarks (line 131) | def partition_benchmarks(json1, json2):
function get_timedelta_field_as_seconds (line 161) | def get_timedelta_field_as_seconds(benchmark, field_name):
function calculate_geomean (line 171) | def calculate_geomean(json):
function extract_field (line 185) | def extract_field(partition, field_name):
function calc_utest (line 192) | def calc_utest(timings_cpu, timings_time):
function print_utest (line 210) | def print_utest(bc_name, utest, utest_alpha, first_col_width, use_color=...
function get_difference_report (line 243) | def get_difference_report(
function print_difference_report (line 330) | def print_difference_report(
class TestGetUniqueBenchmarkNames (line 397) | class TestGetUniqueBenchmarkNames(unittest.TestCase):
method load_results (line 398) | def load_results(self):
method test_basic (line 409) | def test_basic(self):
class TestReportDifference (line 425) | class TestReportDifference(unittest.TestCase):
method setUpClass (line 427) | def setUpClass(cls):
method test_json_diff_report_pretty_printing (line 445) | def test_json_diff_report_pretty_printing(self):
method test_json_diff_report_output (line 476) | def test_json_diff_report_output(self):
class TestReportDifferenceBetweenFamilies (line 616) | class TestReportDifferenceBetweenFamilies(unittest.TestCase):
method setUpClass (line 618) | def setUpClass(cls):
method test_json_diff_report_pretty_printing (line 635) | def test_json_diff_report_pretty_printing(self):
method test_json_diff_report (line 654) | def test_json_diff_report(self):
class TestReportDifferenceWithUTest (line 700) | class TestReportDifferenceWithUTest(unittest.TestCase):
method setUpClass (line 702) | def setUpClass(cls):
method test_json_diff_report_pretty_printing (line 721) | def test_json_diff_report_pretty_printing(self):
method test_json_diff_report_pretty_printing_aggregates_only (line 771) | def test_json_diff_report_pretty_printing_aggregates_only(self):
method test_json_diff_report (line 818) | def test_json_diff_report(self):
class TestReportDifferenceWithUTestWhileDisplayingAggregatesOnly (line 904) | class TestReportDifferenceWithUTestWhileDisplayingAggregatesOnly(
method setUpClass (line 907) | def setUpClass(cls):
method test_json_diff_report_pretty_printing (line 926) | def test_json_diff_report_pretty_printing(self):
method test_json_diff_report (line 977) | def test_json_diff_report(self):
class TestReportDifferenceForPercentageAggregates (line 1065) | class TestReportDifferenceForPercentageAggregates(
method setUpClass (line 1068) | def setUpClass(cls):
method test_json_diff_report_pretty_printing (line 1087) | def test_json_diff_report_pretty_printing(self):
method test_json_diff_report (line 1102) | def test_json_diff_report(self):
class TestReportSorting (line 1127) | class TestReportSorting(unittest.TestCase):
method setUpClass (line 1129) | def setUpClass(cls):
method test_json_diff_report_pretty_printing (line 1143) | def test_json_diff_report_pretty_printing(self):
function assert_utest (line 1170) | def assert_utest(unittest_instance, lhs, rhs):
function assert_measurements (line 1186) | def assert_measurements(unittest_instance, lhs, rhs):
FILE: 3rd/benchmark-1.8.2/tools/gbench/util.py
function is_executable_file (line 19) | def is_executable_file(filename):
function is_json_file (line 44) | def is_json_file(filename):
function classify_input_file (line 58) | def classify_input_file(filename):
function check_input_file (line 79) | def check_input_file(filename):
function find_benchmark_flag (line 92) | def find_benchmark_flag(prefix, benchmark_flags):
function remove_benchmark_flags (line 106) | def remove_benchmark_flags(prefix, benchmark_flags):
function load_benchmark_results (line 115) | def load_benchmark_results(fname, benchmark_filter):
function sort_benchmark_results (line 143) | def sort_benchmark_results(result):
function run_benchmark (line 160) | def run_benchmark(exe_name, benchmark_flags):
function run_or_load_benchmark (line 189) | def run_or_load_benchmark(filename, benchmark_flags):
FILE: 3rd/benchmark-1.8.2/tools/strip_asm.py
function find_used_labels (line 12) | def find_used_labels(asm):
function normalize_labels (line 22) | def normalize_labels(asm):
function transform_labels (line 39) | def transform_labels(asm):
function is_identifier (line 52) | def is_identifier(tk):
function process_identifiers (line 64) | def process_identifiers(l):
function process_asm (line 84) | def process_asm(asm):
function main (line 123) | def main():
FILE: 3rd/googletest-1.12.1/googlemock/include/gmock/gmock-actions.h
function namespace (line 154) | namespace testing {
function Result (line 491) | Result Call(Args... args) && {
function StdFunctionAdaptor (line 504) | StdFunctionAdaptor final {
type T (line 585) | typedef T (*FactoryFunction)();
function SetFactory (line 586) | static void SetFactory(FactoryFunction factory) {
function Clear (line 592) | static void Clear() {
function IsSet (line 598) | static bool IsSet() { return producer_ != nullptr; }
function Exists (line 602) | static bool Exists() {
function T (line 609) | static T Get() {
function class (line 621) | class FixedValueProducer : public ValueProducer {
function class (line 632) | class FactoryValueProducer : public ValueProducer {
function Clear (line 658) | static void Clear() { address_ = nullptr; }
function IsSet (line 661) | static bool IsSet() { return address_ != nullptr; }
function Exists (line 665) | static bool Exists() {
function T (line 672) | static T& Get() {
function Get (line 687) | static void Get() {}
type typename (line 703) | typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
function virtual (line 706) | virtual ~ActionInterface() {}
type ActionAdapter (line 735) | struct ActionAdapter {
type typename (line 751) | typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
function explicit (line 770) | explicit Action(ActionInterface<F>* impl)
function Result (line 789) | Result Perform(ArgumentTuple args) const {
function operator (line 798) | operator OnceAction<F>() const { // NOLINT
type typename (line 878) | typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
function explicit (line 880) | explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
function Result (line 882) | Result Perform(const ArgumentTuple& args) override {
function namespace (line 912) | namespace internal {
function R (line 1438) | R operator()(Args&&... args) && {
type UserConstructorTag (line 1476) | struct UserConstructorTag {}
function R (line 1593) | R operator()(Args... args) && {
type OA (line 1621) | struct OA {
function T (line 1646) | T* operator()() const {
type internal (line 1776) | typedef internal::IgnoredValue Unused;
function PolymorphicAction (line 1849) | inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
function PolymorphicAction (line 1854) | inline PolymorphicAction<internal::ReturnVoidAction> Return() {
function internal (line 1905) | inline internal::DoDefaultAction DoDefault() {
function namespace (line 2067) | namespace internal {
function explicit (line 2108) | explicit ActionImpl(std::shared_ptr<Impl> impl) : Base{std::move(impl)} {}
FILE: 3rd/googletest-1.12.1/googlemock/include/gmock/gmock-cardinalities.h
function namespace (line 53) | namespace testing {
FILE: 3rd/googletest-1.12.1/googlemock/include/gmock/gmock-function-mocker.h
function namespace (line 47) | namespace testing {
FILE: 3rd/googletest-1.12.1/googlemock/include/gmock/gmock-matchers.h
function namespace (line 288) | namespace testing {
type RawT (line 542) | typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
type RawU (line 543) | typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
function namespace (line 559) | namespace internal {
function class (line 775) | class NotNullMatcher {
function DescribeTo (line 783) | void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
function DescribeNegationTo (line 784) | void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }
function MatchAndExplain (line 834) | bool MatchAndExplain(Super& x,
function DescribeTo (line 840) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 845) | void DescribeNegationTo(::std::ostream* os) const override {
function CaseInsensitiveCStringEquals (line 858) | inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rh...
function CaseInsensitiveCStringEquals (line 862) | inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,
function MatchAndExplain (line 969) | bool MatchAndExplain(const internal::StringView& s,
function DescribeTo (line 999) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 1004) | void DescribeNegationTo(::std::ostream* os) const {
function MatchAndExplain (line 1022) | bool MatchAndExplain(const internal::StringView& s,
function DescribeTo (line 1053) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 1058) | void DescribeNegationTo(::std::ostream* os) const {
function MatchAndExplain (line 1076) | bool MatchAndExplain(const internal::StringView& s,
function DescribeTo (line 1107) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 1112) | void DescribeNegationTo(::std::ostream* os) const {
function class (line 1123) | class WhenBase64UnescapedMatcher {
function DescribeTo (line 1192) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 1195) | void DescribeNegationTo(::std::ostream* os) const override {
function matcher_ (line 1233) | matcher_(matcher) {}
function MatchAndExplain (line 1235) | bool MatchAndExplain(const T& x,
function DescribeTo (line 1240) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 1244) | void DescribeNegationTo(::std::ostream* os) const override {
function DescribeTo (line 1280) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 1289) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 1298) | bool MatchAndExplain(const T& x,
function MatchAndExplain (line 1403) | bool MatchAndExplain(const T& x,
function DescribeTo (line 1516) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 1520) | void DescribeNegationTo(::std::ostream* os) const {
function class (line 1626) | class IsNanMatcher {
function DescribeTo (line 1634) | void DescribeTo(::std::ostream* os) const { *os << "is NaN"; }
function DescribeNegationTo (line 1635) | void DescribeNegationTo(::std::ostream* os) const { *os << "isn't NaN"; }
function DescribeTo (line 1710) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 1731) | void DescribeNegationTo(::std::ostream* os) const override {
function operator (line 1763) | operator Matcher<FloatType>() const {
function operator (line 1768) | operator Matcher<const FloatType&>() const {
function operator (line 1773) | operator Matcher<FloatType&>() const {
function explicit (line 1795) | explicit FloatingEq2Matcher(bool nan_eq_nan) { Init(-1, nan_eq_nan); }
function explicit (line 1797) | explicit FloatingEq2Matcher(FloatType max_abs_error) {
function explicit (line 1889) | explicit Impl(const InnerMatcher& matcher)
function DescribeTo (line 1892) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 1897) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 1902) | bool MatchAndExplain(Pointer pointer,
function typename (line 1945) | typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
function DescribeTo (line 1951) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 1956) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 1961) | bool MatchAndExplain(PointerType pointer,
function matcher_ (line 1986) | matcher_(matcher) {}
function DescribeTo (line 1988) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 1993) | void DescribeNegationTo(::std::ostream* os) const {
function std (line 2001) | static std::string GetToName() { return GetTypeName<To>(); }
function DescribeTo (line 2060) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 2065) | void DescribeNegationTo(::std::ostream* os) const {
function MatchAndExplainImpl (line 2087) | bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
function DescribeTo (line 2127) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 2132) | void DescribeNegationTo(::std::ostream* os) const {
function MatchAndExplainImpl (line 2155) | bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
type Functor (line 2178) | typedef Functor StorageType;
function CheckIsValid (line 2180) | static void CheckIsValid(Functor /* functor */) {}
type ResType (line 2191) | typedef ResType ResultType;
type ResType (line 2192) | typedef ResType (*StorageType)(ArgType);
function CheckIsValid (line 2194) | static void CheckIsValid(ResType (*f)(ArgType)) {
function ResType (line 2199) | ResType Invoke(ResType (*f)(ArgType), T arg) {
function DescribeTo (line 2243) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 2252) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 2261) | bool MatchAndExplain(T obj, MatchResultListener* listener) const override {
function explicit (line 2308) | explicit Impl(const SizeMatcher& size_matcher)
function DescribeTo (line 2311) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 2315) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 2320) | bool MatchAndExplain(Container container,
type typename (line 2358) | typedef typename std::iterator_traits<
function explicit (line 2361) | explicit Impl(const DistanceMatcher& distance_matcher)
function DescribeTo (line 2364) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 2368) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 2373) | bool MatchAndExplain(Container container,
type typename (line 2409) | typedef typename View::type StlContainer;
type typename (line 2410) | typedef typename View::const_reference StlContainerReference;
function explicit (line 2419) | explicit ContainerEqMatcher(const Container& expected)
function DescribeTo (line 2422) | void DescribeTo(::std::ostream* os) const {
function DescribeNegationTo (line 2426) | void DescribeNegationTo(::std::ostream* os) const {
type internal (line 2434) | typedef internal::StlContainerView<
type typename (line 2510) | typedef typename LhsView::type LhsStlContainer;
type typename (line 2511) | typedef typename LhsView::const_reference LhsStlContainerReference;
type typename (line 2514) | typedef
function DescribeTo (line 2521) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 2526) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 2531) | bool MatchAndExplain(LhsContainer lhs,
type typename (line 2581) | typedef typename RhsView::type RhsStlContainer;
type typename (line 2582) | typedef typename RhsStlContainer::value_type RhsValue;
type typename (line 2610) | typedef typename LhsView::type LhsStlContainer;
type typename (line 2611) | typedef typename LhsView::const_reference LhsStlContainerReference;
type typename (line 2612) | typedef typename LhsStlContainer::value_type LhsValue;
type LhsValue (line 2617) | typedef ::std::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg;
function DescribeTo (line 2624) | void DescribeTo(::std::ostream* os) const override {
function DescribeNegationTo (line 2631) | void DescribeNegationTo(::std::ostream* os) const override {
function MatchAndExplain (line 2640) | bool MatchAndExplain(LhsContainer lhs,
type typename (line 2696) | typedef typename View::type StlContainer;
type typename (line 2697) | typedef typename View::const_reference StlContainerReference;
type typename (line 2698) | typedef typename StlContainer::value_type Element;
function MatchAndExplainImpl (line 2708) | bool MatchAndExplainImpl(bool all_elements_should_match, Container conta...
function MatchAndExplainImpl (line 2727) | bool MatchAndExplainImpl(const Matcher<size_t>& count_matcher,
function PolymorphicMatcher (line 4252) | inline PolymorphicMatcher<internal::IsNullMatcher> IsNull() {
function PolymorphicMatcher (line 4259) | inline PolymorphicMatcher<internal::NotNullMatcher> NotNull() {
function PolymorphicMatcher (line 4271) | inline PolymorphicMatcher<internal::IsNanMatcher> IsNan() {
function internal (line 4277) | inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) {
function internal (line 4283) | inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double r...
function internal (line 4290) | inline internal::FloatingEqMatcher<double> DoubleNear(double rhs,
function internal (line 4298) | inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear(
function internal (line 4305) | inline internal::FloatingEqMatcher<float> FloatEq(float rhs) {
function internal (line 4311) | inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {
function internal (line 4318) | inline internal::FloatingEqMatcher<float> FloatNear(float rhs,
function internal (line 4326) | inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear(
function PropertyType (line 4385) | PropertyType, PropertyType (Class::*)() const>>
function PolymorphicMatcher (line 4525) | inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> St...
function PolymorphicMatcher (line 4532) | inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> St...
function PolymorphicMatcher (line 4539) | inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> St...
function PolymorphicMatcher (line 4546) | inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring>> St...
function PolymorphicMatcher (line 4554) | inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring>> HasS...
function PolymorphicMatcher (line 4561) | inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring>> Sta...
function PolymorphicMatcher (line 4568) | inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring>> EndsW...
function internal (line 4578) | inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); }
function internal (line 4582) | inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); }
function internal (line 4586) | inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); }
function internal (line 4590) | inline internal::Le2Matcher Le() { return internal::Le2Matcher(); }
function internal (line 4594) | inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); }
function internal (line 4598) | inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); }
function internal (line 4602) | inline internal::FloatingEq2Matcher<float> FloatEq() {
function internal (line 4608) | inline internal::FloatingEq2Matcher<double> DoubleEq() {
function internal (line 4614) | inline internal::FloatingEq2Matcher<float> NanSensitiveFloatEq() {
function internal (line 4620) | inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleEq() {
function internal (line 4626) | inline internal::FloatingEq2Matcher<float> FloatNear(float max_abs_error) {
function internal (line 4632) | inline internal::FloatingEq2Matcher<double> DoubleNear(double max_abs_er...
function internal (line 4639) | inline internal::FloatingEq2Matcher<float> NanSensitiveFloatNear(
function internal (line 4647) | inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleNear(
function typename (line 4729) | typename std::remove_const<Container>::type>
type typename (line 4763) | typedef typename internal::StlContainerView<RhsContainer> RhsView;
type typename (line 4764) | typedef typename RhsView::type RhsStlContainer;
type typename (line 4765) | typedef typename RhsStlContainer::value_type Second;
function namespace (line 4995) | namespace no_adl {
FILE: 3rd/googletest-1.12.1/googlemock/include/gmock/gmock-more-actions.h
function namespace (line 578) | namespace testing {
FILE: 3rd/googletest-1.12.1/googlemock/include/gmock/gmock-more-matchers.h
function namespace (line 45) | namespace testing {
FILE: 3rd/googletest-1.12.1/googlemock/include/gmock/gmock-nice-strict.h
function namespace (line 72) | namespace testing {
FILE: 3rd/googletest-1.12.1/googlemock/include/gmock/gmock-spec-builders.h
function namespace (line 89) | namespace testing {
type CallReaction (line 351) | enum CallReaction {
function class (line 360) | class GTEST_API_ Mock {
function class (line 477) | class GTEST_API_ Expectation {
function class (line 556) | class ExpectationSet {
function class (line 611) | class GTEST_API_ Sequence {
function class (line 649) | class GTEST_API_ InSequence {
function namespace (line 661) | namespace internal {
type typename (line 1254) | typedef
function T (line 1320) | T Unwrap() { return std::move(value_); }
function explicit (line 1340) | explicit ReferenceOrValueWrapper(reference ref) : value_ptr_(&ref) {}
function class (line 1362) | class Cleanup final {
function public (line 1375) | public UntypedFunctionMockerBase {
function Cleanup (line 1769) | const Cleanup report_uninteresting_call(
function Cleanup (line 1814) | const Cleanup handle_failures([&] {
function namespace (line 1837) | namespace internal {
function Expectation (line 2003) | inline Expectation::Expectation(internal::ExpectationBase& exp) // NOLINT
FILE: 3rd/googletest-1.12.1/googlemock/include/gmock/gmock.h
function namespace (line 71) | namespace testing {
FILE: 3rd/googletest-1.12.1/googlemock/include/gmock/internal/gmock-internal-utils.h
function namespace (line 52) | namespace testing {
FILE: 3rd/googletest-1.12.1/googlemock/src/gmock-cardinalities.cc
type testing (line 45) | namespace testing {
class BetweenCardinalityImpl (line 50) | class BetweenCardinalityImpl : public CardinalityInterface {
method BetweenCardinalityImpl (line 52) | BetweenCardinalityImpl(int min, int max)
method ConservativeLowerBound (line 72) | int ConservativeLowerBound() const override { return min_; }
method ConservativeUpperBound (line 73) | int ConservativeUpperBound() const override { return max_; }
method IsSatisfiedByCallCount (line 75) | bool IsSatisfiedByCallCount(int call_count) const override {
method IsSaturatedByCallCount (line 79) | bool IsSaturatedByCallCount(int call_count) const override {
method BetweenCardinalityImpl (line 89) | BetweenCardinalityImpl(const BetweenCardinalityImpl&) = delete;
method BetweenCardinalityImpl (line 90) | BetweenCardinalityImpl& operator=(const BetweenCardinalityImpl&) = d...
function FormatTimes (line 94) | inline std::string FormatTimes(int n) {
function GTEST_API_ (line 139) | GTEST_API_ Cardinality AtLeast(int n) { return Between(n, INT_MAX); }
function GTEST_API_ (line 142) | GTEST_API_ Cardinality AtMost(int n) { return Between(0, n); }
function GTEST_API_ (line 145) | GTEST_API_ Cardinality AnyNumber() { return AtLeast(0); }
function GTEST_API_ (line 148) | GTEST_API_ Cardinality Between(int min, int max) {
function GTEST_API_ (line 153) | GTEST_API_ Cardinality Exactly(int n) { return Between(n, n); }
FILE: 3rd/googletest-1.12.1/googlemock/src/gmock-internal-utils.cc
type testing (line 52) | namespace testing {
type internal (line 53) | namespace internal {
function GTEST_API_ (line 57) | GTEST_API_ std::string JoinAsKeyValueTuple(
function GTEST_API_ (line 79) | GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_n...
class GoogleTestFailureReporter (line 100) | class GoogleTestFailureReporter : public FailureReporterInterface {
method ReportFailure (line 102) | void ReportFailure(FailureType type, const char* file, int line,
function GTEST_API_ (line 115) | GTEST_API_ FailureReporterInterface* GetFailureReporter() {
function GTEST_API_ (line 131) | GTEST_API_ bool LogIsVisible(LogSeverity severity) {
function GTEST_API_ (line 152) | GTEST_API_ void Log(LogSeverity severity, const std::string& message,
function GTEST_API_ (line 189) | GTEST_API_ WithoutMatchers GetWithoutMatchers() { return WithoutMatc...
function GTEST_API_ (line 191) | GTEST_API_ void IllegalDoDefault(const char* file, int line) {
function UnBase64Impl (line 201) | constexpr char UnBase64Impl(char c, const char* const base64, char c...
function UnBase64Impl (line 208) | constexpr std::array<char, 256> UnBase64Impl(IndexSequence<I...>,
function UnBase64 (line 213) | constexpr std::array<char, 256> UnBase64(const char* const base64) {
function Base64Unescape (line 221) | bool Base64Unescape(const std::string& encoded, std::string* decoded) {
FILE: 3rd/googletest-1.12.1/googlemock/src/gmock-matchers.cc
type testing (line 44) | namespace testing {
type internal (line 45) | namespace internal {
function GTEST_API_ (line 52) | GTEST_API_ std::string FormatMatcherDescription(
class MaxBipartiteMatchState (line 124) | class MaxBipartiteMatchState {
method MaxBipartiteMatchState (line 126) | explicit MaxBipartiteMatchState(const MatchMatrix& graph)
method ElementMatcherPairs (line 132) | ElementMatcherPairs Compute() {
method TryAugment (line 184) | bool TryAugment(size_t ilhs, ::std::vector<char>* seen) {
function GTEST_API_ (line 228) | GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchM...
function LogElementMatcherPairVec (line 232) | static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
FILE: 3rd/googletest-1.12.1/googlemock/src/gmock-spec-builders.cc
type testing (line 64) | namespace testing {
type internal (line 65) | namespace internal {
function GTEST_API_ (line 72) | GTEST_API_ void LogWithLocation(testing::internal::LogSeverity sever...
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 109) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 136) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 156) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 187) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 211) | GTEST_LOCK_EXCLUDED_(mutex_) {
function ReportUninterestingCall (line 283) | void ReportUninterestingCall(CallReaction reaction, const std::strin...
function GTEST_LOCK_EXCLUDED_ (line 318) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 331) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 342) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 359) | GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
function Expectation (line 375) | Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* ...
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 395) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
function CallReaction (line 438) | CallReaction intToCallReaction(int mock_behavior) {
type MockObjectState (line 456) | struct MockObjectState {
method MockObjectState (line 457) | MockObjectState()
class MockObjectRegistry (line 474) | class MockObjectRegistry {
method StateMap (line 527) | StateMap& states() { return states_; }
function GTEST_LOCK_EXCLUDED_ (line 548) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 558) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 565) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 572) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 579) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 587) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 600) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 609) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 618) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 628) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 653) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 657) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 661) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 668) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_LOCK_EXCLUDED_ (line 678) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 698) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
function GTEST_EXCLUSIVE_LOCK_REQUIRED_ (line 716) | GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
FILE: 3rd/googletest-1.12.1/googlemock/src/gmock.cc
type testing (line 52) | namespace testing {
type internal (line 53) | namespace internal {
function ParseGoogleMockFlag (line 93) | static bool ParseGoogleMockFlag(const char* str, const char* flag_name,
function ParseGoogleMockFlag (line 112) | static bool ParseGoogleMockFlag(const char* str, const char* flag_name,
function ParseGoogleMockFlag (line 125) | static bool ParseGoogleMockFlag(const char* str, const char* flag_name,
function InitGoogleMockImpl (line 143) | void InitGoogleMockImpl(int* argc, CharType** argv) {
function GTEST_API_ (line 201) | GTEST_API_ void InitGoogleMock(int* argc, char** argv) {
function GTEST_API_ (line 207) | GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv) {
function GTEST_API_ (line 213) | GTEST_API_ void InitGoogleMock() {
FILE: 3rd/googletest-1.12.1/googlemock/src/gmock_main.cc
function setup (line 39) | void setup() {
function loop (line 45) | void loop() { RUN_ALL_TESTS(); }
function GTEST_API_ (line 63) | GTEST_API_ int main(int argc, char** argv) {
FILE: 3rd/googletest-1.12.1/googlemock/test/gmock-actions_test.cc
type testing (line 62) | namespace testing {
function TEST (line 67) | TEST(TypeTraits, Negation) {
type MyFalse (line 104) | struct MyFalse : std::integral_constant<int, 0> {}
type MyTrue (line 107) | struct MyTrue : std::integral_constant<int, -1> {}
function TEST (line 109) | TEST(TypeTraits, Conjunction) {
function TEST (line 148) | TEST(TypeTraits, Disjunction) {
function TEST (line 187) | TEST(TypeTraits, IsInvocableRV) {
function TEST (line 256) | TEST(BuiltInDefaultValueTest, IsNullForPointerTypes) {
function TEST (line 263) | TEST(BuiltInDefaultValueTest, ExistsForPointerTypes) {
function TEST (line 271) | TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) {
function TEST (line 300) | TEST(BuiltInDefaultValueTest, ExistsForNumericTypes) {
function TEST (line 324) | TEST(BuiltInDefaultValueTest, IsFalseForBool) {
function TEST (line 329) | TEST(BuiltInDefaultValueTest, BoolExists) {
function TEST (line 335) | TEST(BuiltInDefaultValueTest, IsEmptyStringForString) {
function TEST (line 341) | TEST(BuiltInDefaultValueTest, ExistsForString) {
function TEST (line 347) | TEST(BuiltInDefaultValueTest, WorksForConstTypes) {
class MyDefaultConstructible (line 355) | class MyDefaultConstructible {
method MyDefaultConstructible (line 357) | MyDefaultConstructible() : value_(42) {}
method value (line 359) | int value() const { return value_; }
class MyNonDefaultConstructible (line 366) | class MyNonDefaultConstructible {
method MyNonDefaultConstructible (line 369) | explicit MyNonDefaultConstructible(int a_value) : value_(a_value) {}
method value (line 371) | int value() const { return value_; }
function TEST (line 377) | TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) {
function TEST (line 381) | TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructi...
function TEST (line 385) | TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleTy...
function TEST (line 390) | TEST(BuiltInDefaultValueDeathTest, IsUndefinedForReferences) {
function TEST (line 395) | TEST(BuiltInDefaultValueDeathTest, IsUndefinedForNonDefaultConstructib...
function TEST (line 401) | TEST(DefaultValueTest, IsInitiallyUnset) {
function TEST (line 408) | TEST(DefaultValueTest, CanBeSetAndUnset) {
function TEST (line 435) | TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
function TEST (line 447) | TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
function TEST (line 458) | TEST(DefaultValueTest, GetWorksForVoid) { return DefaultValue<void>::G...
function TEST (line 463) | TEST(DefaultValueOfReferenceTest, IsInitiallyUnset) {
function TEST (line 470) | TEST(DefaultValueOfReferenceTest, IsInitiallyNotExisting) {
function TEST (line 477) | TEST(DefaultValueOfReferenceTest, CanBeSetAndUnset) {
function TEST (line 502) | TEST(DefaultValueOfReferenceDeathTest, GetReturnsBuiltInDefaultValueWh...
class MyActionImpl (line 516) | class MyActionImpl : public ActionInterface<MyGlobalFunction> {
method Perform (line 518) | int Perform(const std::tuple<bool, int>& args) override {
function TEST (line 523) | TEST(ActionInterfaceTest, CanBeImplementedByDefiningPerform) {
function TEST (line 528) | TEST(ActionInterfaceTest, MakeAction) {
function TEST (line 541) | TEST(ActionTest, CanBeConstructedFromActionInterface) {
function TEST (line 546) | TEST(ActionTest, DelegatesWorkToActionInterface) {
function TEST (line 554) | TEST(ActionTest, IsCopyable) {
class IsNotZero (line 580) | class IsNotZero : public ActionInterface<bool(int)> { // NOLINT
method Perform (line 582) | bool Perform(const std::tuple<int>& arg) override {
function TEST (line 587) | TEST(ActionTest, CanBeConvertedToOtherActionType) {
class ReturnSecondArgumentAction (line 598) | class ReturnSecondArgumentAction {
method Result (line 604) | Result Perform(const ArgumentTuple& args) {
class ReturnZeroFromNullaryFunctionAction (line 611) | class ReturnZeroFromNullaryFunctionAction {
method Result (line 621) | Result Perform(const std::tuple<>&) const {
function ReturnSecondArgument (line 629) | PolymorphicAction<ReturnSecondArgumentAction> ReturnSecondArgument() {
function ReturnZeroFromNullaryFunction (line 633) | PolymorphicAction<ReturnZeroFromNullaryFunctionAction>
function TEST (line 640) | TEST(MakePolymorphicActionTest, ConstructsActionFromImpl) {
function TEST (line 647) | TEST(MakePolymorphicActionTest, WorksWhenPerformHasOneTemplateParamete...
function TEST (line 657) | TEST(ReturnTest, WorksForVoid) {
function TEST (line 663) | TEST(ReturnTest, ReturnsGivenValue) {
function TEST (line 672) | TEST(ReturnTest, AcceptsStringLiteral) {
function TEST (line 683) | TEST(ReturnTest, SupportsReferenceLikeReturnType) {
function TEST (line 710) | TEST(ReturnTest, PrefersConversionOperator) {
function TEST (line 745) | TEST(ReturnTest, ConversionRequiresConstLvalueReference) {
function TEST (line 763) | TEST(ReturnTest, ConversionRequiresMutableLvalueReference) {
function TEST (line 792) | TEST(ReturnTest, MoveOnlyResultType) {
type Base (line 812) | struct Base {
type Derived (line 816) | struct Derived : public Base {
function TEST (line 820) | TEST(ReturnTest, IsCovariant) {
class FromType (line 834) | class FromType {
method FromType (line 836) | explicit FromType(bool* is_converted) : converted_(is_converted) {}
class ToType (line 843) | class ToType {
method ToType (line 846) | ToType(const FromType& x) { *x.converted() = true; }
function TEST (line 849) | TEST(ReturnTest, ConvertsArgumentWhenConverted) {
function TEST (line 862) | TEST(ReturnNullTest, WorksInPointerReturningFunction) {
function TEST (line 872) | TEST(ReturnNullTest, WorksInSmartPointerReturningFunction) {
function TEST (line 881) | TEST(ReturnRefTest, WorksForReference) {
function TEST (line 889) | TEST(ReturnRefTest, IsCovariant) {
function CanCallReturnRef (line 900) | bool CanCallReturnRef(T&&) {
function CanCallReturnRef (line 903) | bool CanCallReturnRef(Unused) { return false; }
function TEST (line 906) | TEST(ReturnRefTest, WorksForNonTemporary) {
function TEST (line 921) | TEST(ReturnRefTest, DoesNotWorkForTemporary) {
function TEST (line 937) | TEST(ReturnRefOfCopyTest, WorksForReference) {
function TEST (line 950) | TEST(ReturnRefOfCopyTest, IsCovariant) {
function TEST (line 961) | TEST(ReturnRoundRobinTest, WorksForInitList) {
function TEST (line 973) | TEST(ReturnRoundRobinTest, WorksForVector) {
class MockClass (line 987) | class MockClass {
method MockClass (line 989) | MockClass() {}
method MockClass (line 1001) | MockClass(const MockClass&) = delete;
method MockClass (line 1002) | MockClass& operator=(const MockClass&) = delete;
function TEST (line 1007) | TEST(DoDefaultTest, ReturnsBuiltInDefaultValueByDefault) {
function TEST (line 1015) | TEST(DoDefaultDeathTest, DiesForUnknowType) {
function VoidFunc (line 1028) | void VoidFunc(bool /* flag */) {}
function TEST (line 1030) | TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
function TEST (line 1044) | TEST(DoDefaultTest, ReturnsUserSpecifiedPerTypeDefaultValueWhenThereIs...
function TEST (line 1053) | TEST(DoDefaultTest, DoesWhatOnCallSpecifies) {
function TEST (line 1061) | TEST(DoDefaultTest, CannotBeUsedInOnCall) {
function TEST (line 1072) | TEST(SetArgPointeeTest, SetsTheNthPointee) {
function TEST (line 1091) | TEST(SetArgPointeeTest, AcceptsStringLiteral) {
function TEST (line 1107) | TEST(SetArgPointeeTest, AcceptsWideStringLiteral) {
function TEST (line 1126) | TEST(SetArgPointeeTest, AcceptsCharPointer) {
function TEST (line 1145) | TEST(SetArgPointeeTest, AcceptsWideCharPointer) {
function TEST (line 1167) | TEST(SetArgumentPointeeTest, SetsTheNthPointee) {
function Nullary (line 1186) | int Nullary() { return 1; }
class NullaryFunctor (line 1188) | class NullaryFunctor {
function VoidNullary (line 1194) | void VoidNullary() { g_done = true; }
class VoidNullaryFunctor (line 1196) | class VoidNullaryFunctor {
function Short (line 1201) | short Short(short n) { return n; }
function Char (line 1202) | char Char(char ch) { return ch; }
function Unary (line 1206) | bool Unary(int x) { return x < 0; }
function VoidBinary (line 1210) | void VoidBinary(int, char) { g_done = true; }
function Ternary (line 1212) | int Ternary(int x, char y, short z) { return x + y + z; }
function SumOf4 (line 1214) | int SumOf4(int a, int b, int c, int d) { return a + b + c + d; }
class Foo (line 1216) | class Foo {
method Foo (line 1218) | Foo() : value_(123) {}
method Nullary (line 1220) | int Nullary() const { return value_; }
function TEST (line 1227) | TEST(InvokeWithoutArgsTest, Function) {
function TEST (line 1244) | TEST(InvokeWithoutArgsTest, Functor) {
function TEST (line 1262) | TEST(InvokeWithoutArgsTest, Method) {
function TEST (line 1270) | TEST(IgnoreResultTest, PolymorphicAction) {
function ReturnOne (line 1277) | int ReturnOne() {
function TEST (line 1282) | TEST(IgnoreResultTest, MonomorphicAction) {
function MyNonDefaultConstructible (line 1291) | MyNonDefaultConstructible ReturnMyNonDefaultConstructible(double /* x ...
method MyNonDefaultConstructible (line 369) | explicit MyNonDefaultConstructible(int a_value) : value_(a_value) {}
method value (line 371) | int value() const { return value_; }
function TEST (line 1296) | TEST(IgnoreResultTest, ActionReturningClass) {
function TEST (line 1304) | TEST(AssignTest, Int) {
function TEST (line 1311) | TEST(AssignTest, String) {
function TEST (line 1318) | TEST(AssignTest, CompatibleTypes) {
function TEST (line 1326) | TEST(DoAll, SupportsRefQualifiedActions) {
function TEST (line 1344) | TEST(DoAll, ProvidesLvalueReferencesToInitialActions) {
function TEST (line 1451) | TEST(DoAll, SupportsTypeErasedActions) {
function TEST (line 1480) | TEST(WithArgsTest, OneArg) {
function TEST (line 1487) | TEST(WithArgsTest, TwoArgs) {
type ConcatAll (line 1494) | struct ConcatAll {
function TEST (line 1503) | TEST(WithArgsTest, TenArgs) {
class SubtractAction (line 1512) | class SubtractAction : public ActionInterface<int(int, int)> {
method Perform (line 1514) | int Perform(const std::tuple<int, int>& args) override {
function TEST (line 1519) | TEST(WithArgsTest, NonInvokeAction) {
function TEST (line 1528) | TEST(WithArgsTest, Identity) {
function TEST (line 1535) | TEST(WithArgsTest, RepeatedArguments) {
function TEST (line 1542) | TEST(WithArgsTest, ReversedArgumentOrder) {
function TEST (line 1550) | TEST(WithArgsTest, ArgsOfCompatibleTypes) {
function TEST (line 1558) | TEST(WithArgsTest, VoidAction) {
function TEST (line 1565) | TEST(WithArgsTest, ReturnReference) {
function TEST (line 1572) | TEST(WithArgsTest, InnerActionWithConversion) {
function TEST (line 1586) | TEST(WithArgsTest, RefQualifiedInnerAction) {
class SetErrnoAndReturnTest (line 1601) | class SetErrnoAndReturnTest : public testing::Test {
method SetUp (line 1603) | void SetUp() override { errno = 0; }
method TearDown (line 1604) | void TearDown() override { errno = 0; }
function TEST_F (line 1607) | TEST_F(SetErrnoAndReturnTest, Int) {
function TEST_F (line 1613) | TEST_F(SetErrnoAndReturnTest, Ptr) {
function TEST_F (line 1620) | TEST_F(SetErrnoAndReturnTest, CompatibleTypes) {
function TEST (line 1631) | TEST(ByRefTest, IsCopyable) {
function TEST (line 1652) | TEST(ByRefTest, ConstValue) {
function TEST (line 1661) | TEST(ByRefTest, NonConstValue) {
function TEST (line 1674) | TEST(ByRefTest, ExplicitType) {
function TEST (line 1703) | TEST(ByRefTest, PrintsCorrectly) {
type UnaryConstructorClass (line 1711) | struct UnaryConstructorClass {
method UnaryConstructorClass (line 1712) | explicit UnaryConstructorClass(int v) : value(v) {}
function TEST (line 1717) | TEST(ReturnNewTest, Unary) {
function TEST (line 1724) | TEST(ReturnNewTest, UnaryWorksWhenMockMethodHasArgs) {
function TEST (line 1732) | TEST(ReturnNewTest, UnaryWorksWhenMockMethodReturnsPointerToConst) {
class TenArgConstructorClass (line 1740) | class TenArgConstructorClass {
method TenArgConstructorClass (line 1742) | TenArgConstructorClass(int a1, int a2, int a3, int a4, int a5, int a...
function TEST (line 1749) | TEST(ReturnNewTest, ConstructorThatTakes10Arguments) {
function UniquePtrSource (line 1758) | std::unique_ptr<int> UniquePtrSource() {
function VectorUniquePtrSource (line 1762) | std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
function TEST (line 1768) | TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
function TEST (line 1790) | TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) {
function TEST (line 1804) | TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
function TEST (line 1827) | TEST(MockMethodTest, CanTakeMoveOnlyValue) {
function TEST (line 1872) | TEST(MockMethodTest, ActionHasRvalueRefQualifiedCallOperator) {
function TEST (line 1898) | TEST(MockMethodTest, ActionHasMultipleCallOperators) {
function TEST (line 1927) | TEST(MockMethodTest, MoveOnlyAction) {
function TEST (line 1965) | TEST(MockMethodTest, ActionReturnsIgnoredValue) {
function TEST (line 1979) | TEST(MockMethodTest, WillOnceCanAcceptLvalueReference) {
type StaticAssertSingleArgument (line 1990) | struct StaticAssertSingleArgument {
method CheckArgs (line 1992) | static constexpr bool CheckArgs() {
function TEST (line 2007) | TEST(MockMethodTest, ActionSwallowsAllArguments) {
type ActionWithTemplatedConversionOperators (line 2017) | struct ActionWithTemplatedConversionOperators {
function TEST (line 2032) | TEST(MockMethodTest, ActionHasTemplatedConversionOperators) {
function Add (line 2044) | int Add(int val, int& ref, int* ptr) { // NOLINT
function Deref (line 2051) | int Deref(std::unique_ptr<int> ptr) { return *ptr; }
type Double (line 2053) | struct Double {
method T (line 2055) | T operator()(T t) {
function UniqueInt (line 2060) | std::unique_ptr<int> UniqueInt(int i) {
function TEST (line 2064) | TEST(FunctorActionTest, ActionFromFunction) {
function TEST (line 2075) | TEST(FunctorActionTest, ActionFromLambda) {
function TEST (line 2088) | TEST(FunctorActionTest, PolymorphicFunctor) {
function TEST (line 2095) | TEST(FunctorActionTest, TypeConversion) {
function TEST (line 2124) | TEST(FunctorActionTest, UnusedArguments) {
function TEST (line 2134) | TEST(MoveOnlyArgumentsTest, ReturningActions) {
function ACTION (line 2147) | ACTION(ReturnArity) { return std::tuple_size<args_type>::value; }
function TEST (line 2149) | TEST(ActionMacro, LargeArity) {
FILE: 3rd/googletest-1.12.1/googlemock/test/gmock-cardinalities_test.cc
class MockFoo (line 51) | class MockFoo {
method MockFoo (line 53) | MockFoo() {}
method MockFoo (line 57) | MockFoo(const MockFoo&) = delete;
method MockFoo (line 58) | MockFoo& operator=(const MockFoo&) = delete;
function TEST (line 62) | TEST(CardinalityTest, IsDefaultConstructable) { Cardinality c; }
function TEST (line 65) | TEST(CardinalityTest, IsCopyable) {
function TEST (line 79) | TEST(CardinalityTest, IsOverSaturatedByCallCountWorks) {
function TEST (line 88) | TEST(CardinalityTest, CanDescribeActualCallCount) {
function TEST (line 107) | TEST(AnyNumber, Works) {
function TEST (line 123) | TEST(AnyNumberTest, HasCorrectBounds) {
function TEST (line 131) | TEST(AtLeastTest, OnNegativeNumber) {
function TEST (line 139) | TEST(AtLeastTest, OnZero) {
function TEST (line 152) | TEST(AtLeastTest, OnPositiveNumber) {
function TEST (line 176) | TEST(AtLeastTest, HasCorrectBounds) {
function TEST (line 184) | TEST(AtMostTest, OnNegativeNumber) {
function TEST (line 192) | TEST(AtMostTest, OnZero) {
function TEST (line 205) | TEST(AtMostTest, OnPositiveNumber) {
function TEST (line 229) | TEST(AtMostTest, HasCorrectBounds) {
function TEST (line 237) | TEST(BetweenTest, OnNegativeStart) {
function TEST (line 245) | TEST(BetweenTest, OnNegativeEnd) {
function TEST (line 253) | TEST(BetweenTest, OnStartBiggerThanEnd) {
function TEST (line 262) | TEST(BetweenTest, OnZeroStartAndZeroEnd) {
function TEST (line 276) | TEST(BetweenTest, OnZeroStartAndNonZeroEnd) {
function TEST (line 293) | TEST(BetweenTest, OnSameStartAndEnd) {
function TEST (line 310) | TEST(BetweenTest, OnDifferentStartAndEnd) {
function TEST (line 330) | TEST(BetweenTest, HasCorrectBounds) {
function TEST (line 338) | TEST(ExactlyTest, OnNegativeNumber) {
function TEST (line 346) | TEST(ExactlyTest, OnZero) {
function TEST (line 359) | TEST(ExactlyTest, OnPositiveNumber) {
function TEST (line 380) | TEST(ExactlyTest, HasCorrectBounds) {
class EvenCardinality (line 389) | class EvenCardinality : public CardinalityInterface {
method IsSatisfiedByCallCount (line 393) | bool IsSatisfiedByCallCount(int call_count) const override {
method IsSaturatedByCallCount (line 399) | bool IsSaturatedByCallCount(int /* call_count */) const override {
method DescribeTo (line 404) | void DescribeTo(::std::ostream* ss) const override {
function TEST (line 409) | TEST(MakeCardinalityTest, ConstructsCardinalityFromInterface) {
FILE: 3rd/googletest-1.12.1/googlemock/test/gmock-function-mocker_test.cc
type testing (line 56) | namespace testing {
type gmock_function_mocker_test (line 57) | namespace gmock_function_mocker_test {
class TemplatedCopyable (line 74) | class TemplatedCopyable {
method TemplatedCopyable (line 76) | TemplatedCopyable() {}
method TemplatedCopyable (line 79) | TemplatedCopyable(const U& other) {}
class FooInterface (line 82) | class FooInterface {
class MockFoo (line 144) | class MockFoo : public FooInterface {
method MockFoo (line 146) | MockFoo() {}
method MockFoo (line 211) | MockFoo(const MockFoo&) = delete;
method MockFoo (line 212) | MockFoo& operator=(const MockFoo&) = delete;
class LegacyMockFoo (line 215) | class LegacyMockFoo : public FooInterface {
method LegacyMockFoo (line 217) | LegacyMockFoo() {}
method RefQualifiedConstRef (line 274) | int RefQualifiedConstRef() const& override { return 0; }
method RefQualifiedConstRefRef (line 275) | int RefQualifiedConstRefRef() const&& override { return 0; }
method RefQualifiedRef (line 276) | int RefQualifiedRef() & override { return 0; }
method RefQualifiedRefRef (line 277) | int RefQualifiedRefRef() && override { return 0; }
method RefQualifiedOverloaded (line 278) | int RefQualifiedOverloaded() const& override { return 0; }
method RefQualifiedOverloaded (line 279) | int RefQualifiedOverloaded() const&& override { return 0; }
method RefQualifiedOverloaded (line 280) | int RefQualifiedOverloaded() & override { return 0; }
method RefQualifiedOverloaded (line 281) | int RefQualifiedOverloaded() && override { return 0; }
method LegacyMockFoo (line 284) | LegacyMockFoo(const LegacyMockFoo&) = delete;
method LegacyMockFoo (line 285) | LegacyMockFoo& operator=(const LegacyMockFoo&) = delete;
class FunctionMockerTest (line 293) | class FunctionMockerTest : public testing::Test {
method FunctionMockerTest (line 295) | FunctionMockerTest() : foo_(&mock_foo_) {}
function TYPED_TEST (line 304) | TYPED_TEST(FunctionMockerTest, MocksVoidFunction) {
function TYPED_TEST (line 310) | TYPED_TEST(FunctionMockerTest, MocksNullaryFunction) {
function TYPED_TEST (line 320) | TYPED_TEST(FunctionMockerTest, MocksUnaryFunction) {
function TYPED_TEST (line 328) | TYPED_TEST(FunctionMockerTest, MocksBinaryFunction) {
function TYPED_TEST (line 335) | TYPED_TEST(FunctionMockerTest, MocksDecimalFunction) {
function TYPED_TEST (line 344) | TYPED_TEST(FunctionMockerTest, MocksFunctionWithNonConstReferenceArg...
function TYPED_TEST (line 353) | TYPED_TEST(FunctionMockerTest, MocksFunctionWithConstReferenceArgume...
function TYPED_TEST (line 362) | TYPED_TEST(FunctionMockerTest, MocksFunctionWithConstArgument) {
function TYPED_TEST (line 369) | TYPED_TEST(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentNum...
function TYPED_TEST (line 380) | TYPED_TEST(FunctionMockerTest, MocksFunctionsOverloadedOnArgumentTyp...
function TYPED_TEST (line 391) | TYPED_TEST(FunctionMockerTest, MocksFunctionsOverloadedOnConstnessOf...
function TYPED_TEST (line 400) | TYPED_TEST(FunctionMockerTest, MocksReturnTypeWithComma) {
function TYPED_TEST (line 409) | TYPED_TEST(FunctionMockerTest, MocksTypeWithTemplatedCopyCtor) {
function TYPED_TEST (line 417) | TYPED_TEST(FunctionMockerTest, MocksNullaryFunctionWithCallType) {
function TYPED_TEST (line 427) | TYPED_TEST(FunctionMockerTest, MocksUnaryFunctionWithCallType) {
function TYPED_TEST (line 438) | TYPED_TEST(FunctionMockerTest, MocksDecimalFunctionWithCallType) {
function TYPED_TEST (line 447) | TYPED_TEST(FunctionMockerTest, MocksFunctionsConstFunctionWithCallTy...
function TYPED_TEST (line 453) | TYPED_TEST(FunctionMockerTest, MocksReturnTypeWithCommaAndCallType) {
function TEST (line 462) | TEST(FunctionMockerTest, RefQualified) {
class MockB (line 496) | class MockB {
method MockB (line 498) | MockB() {}
method MockB (line 503) | MockB(const MockB&) = delete;
method MockB (line 504) | MockB& operator=(const MockB&) = delete;
class LegacyMockB (line 507) | class LegacyMockB {
method LegacyMockB (line 509) | LegacyMockB() {}
method LegacyMockB (line 514) | LegacyMockB(const LegacyMockB&) = delete;
method LegacyMockB (line 515) | LegacyMockB& operator=(const LegacyMockB&) = delete;
class ExpectCallTest (line 519) | class ExpectCallTest : public ::testing::Test {}
function TYPED_TEST (line 525) | TYPED_TEST(ExpectCallTest, UnmentionedFunctionCanBeCalledAnyNumberOf...
class StackInterface (line 543) | class StackInterface {
class MockStack (line 556) | class MockStack : public StackInterface<T> {
method MockStack (line 558) | MockStack() {}
method MockStack (line 570) | MockStack(const MockStack&) = delete;
method MockStack (line 571) | MockStack& operator=(const MockStack&) = delete;
class LegacyMockStack (line 575) | class LegacyMockStack : public StackInterface<T> {
method LegacyMockStack (line 577) | LegacyMockStack() {}
method LegacyMockStack (line 589) | LegacyMockStack(const LegacyMockStack&) = delete;
method LegacyMockStack (line 590) | LegacyMockStack& operator=(const LegacyMockStack&) = delete;
class TemplateMockTest (line 594) | class TemplateMockTest : public ::testing::Test {}
function TYPED_TEST (line 600) | TYPED_TEST(TemplateMockTest, Works) {
function TYPED_TEST (line 620) | TYPED_TEST(TemplateMockTest, MethodWithCommaInReturnTypeWorks) {
class StackInterfaceWithCallType (line 635) | class StackInterfaceWithCallType {
class MockStackWithCallType (line 648) | class MockStackWithCallType : public StackInterfaceWithCallType<T> {
method MockStackWithCallType (line 650) | MockStackWithCallType() {}
method MockStackWithCallType (line 660) | MockStackWithCallType(const MockStackWithCallType&) = delete;
method MockStackWithCallType (line 661) | MockStackWithCallType& operator=(const MockStackWithCallType&) = d...
class LegacyMockStackWithCallType (line 665) | class LegacyMockStackWithCallType : public StackInterfaceWithCallTyp...
method LegacyMockStackWithCallType (line 667) | LegacyMockStackWithCallType() {}
method LegacyMockStackWithCallType (line 675) | LegacyMockStackWithCallType(const LegacyMockStackWithCallType&) = ...
method LegacyMockStackWithCallType (line 676) | LegacyMockStackWithCallType& operator=(const LegacyMockStackWithCa...
class TemplateMockTestWithCallType (line 681) | class TemplateMockTestWithCallType : public ::testing::Test {}
function TYPED_TEST (line 689) | TYPED_TEST(TemplateMockTestWithCallType, Works) {
class MockOverloadedOnArgNumber (line 720) | class MockOverloadedOnArgNumber {
method MockOverloadedOnArgNumber (line 722) | MockOverloadedOnArgNumber() {}
method MockOverloadedOnArgNumber (line 727) | MockOverloadedOnArgNumber(const MockOverloadedOnArgNumber&) = delete;
method MockOverloadedOnArgNumber (line 728) | MockOverloadedOnArgNumber& operator=(const MockOverloadedOnArgNumb...
class LegacyMockOverloadedOnArgNumber (line 732) | class LegacyMockOverloadedOnArgNumber {
method LegacyMockOverloadedOnArgNumber (line 734) | LegacyMockOverloadedOnArgNumber() {}
method LegacyMockOverloadedOnArgNumber (line 739) | LegacyMockOverloadedOnArgNumber(const LegacyMockOverloadedOnArgNum...
method LegacyMockOverloadedOnArgNumber (line 741) | LegacyMockOverloadedOnArgNumber& operator=(
class OverloadedMockMethodTest (line 746) | class OverloadedMockMethodTest : public ::testing::Test {}
function TYPED_TEST (line 752) | TYPED_TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBo...
class MockOverloadedOnConstness (line 767) | class MockOverloadedOnConstness {
method MockOverloadedOnConstness (line 769) | MockOverloadedOnConstness() {}
method MockOverloadedOnConstness (line 774) | MockOverloadedOnConstness(const MockOverloadedOnConstness&) = delete;
method MockOverloadedOnConstness (line 775) | MockOverloadedOnConstness& operator=(const MockOverloadedOnConstne...
function TEST (line 779) | TEST(MockMethodOverloadedMockMethodTest, CanOverloadOnConstnessInMac...
function TEST (line 789) | TEST(MockMethodMockFunctionTest, WorksForVoidNullary) {
function TEST (line 795) | TEST(MockMethodMockFunctionTest, WorksForNonVoidNullary) {
function TEST (line 802) | TEST(MockMethodMockFunctionTest, WorksForVoidUnary) {
function TEST (line 808) | TEST(MockMethodMockFunctionTest, WorksForNonVoidBinary) {
function TEST (line 817) | TEST(MockMethodMockFunctionTest, WorksFor10Arguments) {
function TEST (line 828) | TEST(MockMethodMockFunctionTest, AsStdFunction) {
function TEST (line 837) | TEST(MockMethodMockFunctionTest, AsStdFunctionReturnsReference) {
function TEST (line 847) | TEST(MockMethodMockFunctionTest, AsStdFunctionWithReferenceParameter) {
function IsMockFunctionTemplateArgumentDeducedTo (line 858) | static constexpr bool IsMockFunctionTemplateArgumentDeducedTo(
class MockMethodMockFunctionSignatureTest (line 866) | class MockMethodMockFunctionSignatureTest : public Test {}
function TYPED_TEST (line 874) | TYPED_TEST(MockMethodMockFunctionSignatureTest,
function TYPED_TEST (line 881) | TYPED_TEST(MockMethodMockFunctionSignatureTest,
function TYPED_TEST (line 888) | TYPED_TEST(
type AlternateCallable (line 898) | struct AlternateCallable {}
function TYPED_TEST (line 900) | TYPED_TEST(MockMethodMockFunctionSignatureTest,
function TYPED_TEST (line 907) | TYPED_TEST(MockMethodMockFunctionSignatureTest,
type MockMethodSizes0 (line 915) | struct MockMethodSizes0 {
type MockMethodSizes1 (line 918) | struct MockMethodSizes1 {
type MockMethodSizes2 (line 921) | struct MockMethodSizes2 {
type MockMethodSizes3 (line 924) | struct MockMethodSizes3 {
type MockMethodSizes4 (line 927) | struct MockMethodSizes4 {
type LegacyMockMethodSizes0 (line 931) | struct LegacyMockMethodSizes0 {
type LegacyMockMethodSizes1 (line 934) | struct LegacyMockMethodSizes1 {
type LegacyMockMethodSizes2 (line 937) | struct LegacyMockMethodSizes2 {
type LegacyMockMethodSizes3 (line 940) | struct LegacyMockMethodSizes3 {
type LegacyMockMethodSizes4 (line 943) | struct LegacyMockMethodSizes4 {
function TEST (line 947) | TEST(MockMethodMockFunctionTest, MockMethodSizeOverhead) {
type MockMethodNoexceptSpecifier (line 964) | struct MockMethodNoexceptSpecifier {
function TEST (line 976) | TEST(MockMethodMockFunctionTest, NoexceptSpecifierPreserved) {
FILE: 3rd/googletest-1.12.1/googlemock/test/gmock-internal-utils_test.cc
type proto2 (line 63) | namespace proto2 {
class Message (line 64) | class Message
type testing (line 67) | namespace testing {
type internal (line 68) | namespace internal {
function TEST (line 72) | TEST(JoinAsKeyValueTupleTest, JoinsEmptyTuple) {
function TEST (line 76) | TEST(JoinAsKeyValueTupleTest, JoinsOneTuple) {
function TEST (line 80) | TEST(JoinAsKeyValueTupleTest, JoinsTwoTuple) {
function TEST (line 84) | TEST(JoinAsKeyValueTupleTest, JoinsTenTuple) {
function TEST (line 91) | TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) {
function TEST (line 97) | TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsDigits) {
function TEST (line 104) | TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsCamelCas...
function TEST (line 112) | TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContains_Separat...
function TEST (line 119) | TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) {
function TEST (line 125) | TEST(GetRawPointerTest, WorksForSmartPointers) {
function TEST (line 134) | TEST(GetRawPointerTest, WorksForRawPointers) {
function TEST (line 141) | TEST(GetRawPointerTest, WorksForStdReferenceWrapper) {
class Base (line 149) | class Base {}
class Derived (line 150) | class Derived : public Base {}
function TEST (line 152) | TEST(KindOfTest, Bool) {
function TEST (line 156) | TEST(KindOfTest, Integer) {
function TEST (line 176) | TEST(KindOfTest, FloatingPoint) {
function TEST (line 182) | TEST(KindOfTest, Other) {
function TEST (line 190) | TEST(LosslessArithmeticConvertibleTest, BoolToBool) {
function TEST (line 194) | TEST(LosslessArithmeticConvertibleTest, BoolToInteger) {
function TEST (line 201) | TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) {
function TEST (line 206) | TEST(LosslessArithmeticConvertibleTest, IntegerToBool) {
function TEST (line 211) | TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) {
function TEST (line 245) | TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) {
function TEST (line 254) | TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) {
function TEST (line 259) | TEST(LosslessArithmeticConvertibleTest, FloatingPointToInteger) {
function TEST (line 265) | TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) {
function TEST (line 290) | TEST(TupleMatchesTest, WorksForSize0) {
function TEST (line 297) | TEST(TupleMatchesTest, WorksForSize1) {
function TEST (line 305) | TEST(TupleMatchesTest, WorksForSize2) {
function TEST (line 316) | TEST(TupleMatchesTest, WorksForSize5) {
function TEST (line 331) | TEST(AssertTest, SucceedsOnTrue) {
function TEST (line 337) | TEST(AssertTest, FailsFatallyOnFalse) {
function TEST (line 345) | TEST(ExpectTest, SucceedsOnTrue) {
function TEST (line 351) | TEST(ExpectTest, FailsNonfatallyOnFalse) {
class LogIsVisibleTest (line 367) | class LogIsVisibleTest : public ::testing::Test {
method SetUp (line 369) | void SetUp() override { original_verbose_ = GMOCK_FLAG_GET(verbose...
method TearDown (line 371) | void TearDown() override { GMOCK_FLAG_SET(verbose, original_verbos...
function TEST_F (line 376) | TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) {
function TEST_F (line 382) | TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) {
function TEST_F (line 388) | TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) {
function TestLogWithSeverity (line 400) | void TestLogWithSeverity(const std::string& verbosity, LogSeverity s...
function TEST (line 420) | TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) {
type MockStackTraceGetter (line 429) | struct MockStackTraceGetter : testing::internal::OsStackTraceGetterI...
method CurrentStackTrace (line 430) | std::string CurrentStackTrace(int max_depth, int skip_count) overr...
method UponLeavingGTest (line 434) | void UponLeavingGTest() override {}
function TEST (line 439) | TEST(LogTest, NoSkippingStackFrameInOptMode) {
function TEST (line 478) | TEST(LogTest, AllLogsArePrintedWhenVerbosityIsInfo) {
function TEST (line 485) | TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsWarning) {
function TEST (line 492) | TEST(LogTest, NoLogsArePrintedWhenVerbosityIsError) {
function TEST (line 499) | TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) {
function GrabOutput (line 506) | std::string GrabOutput(void (*logger)(), const char* verbosity) {
class DummyMock (line 515) | class DummyMock {
function ExpectCallLogger (line 521) | void ExpectCallLogger() {
function TEST (line 528) | TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) {
function TEST (line 535) | TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) {
function TEST (line 541) | TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsError) {
function OnCallLogger (line 545) | void OnCallLogger() {
function TEST (line 551) | TEST(OnCallTest, LogsWhenVerbosityIsInfo) {
function TEST (line 558) | TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) {
function TEST (line 564) | TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) {
function OnCallAnyArgumentLogger (line 568) | void OnCallAnyArgumentLogger() {
function TEST (line 574) | TEST(OnCallTest, LogsAnythingArgument) {
function TEST (line 583) | TEST(StlContainerViewTest, WorksForStlContainer) {
function TEST (line 599) | TEST(StlContainerViewTest, WorksForStaticNativeArray) {
function TEST (line 625) | TEST(StlContainerViewTest, WorksForDynamicNativeArray) {
function TEST (line 658) | TEST(FunctionTest, Nullary) {
function TEST (line 668) | TEST(FunctionTest, Unary) {
function TEST (line 681) | TEST(FunctionTest, Binary) {
function TEST (line 698) | TEST(FunctionTest, LongArgumentList) {
function TEST (line 723) | TEST(Base64Unescape, InvalidString) {
function TEST (line 728) | TEST(Base64Unescape, ShortString) {
function TEST (line 734) | TEST(Base64Unescape, ShortStringWithPadding) {
function TEST (line 740) | TEST(Base64Unescape, ShortStringWithoutPadding) {
function TEST (line 746) | TEST(Base64Unescape, LongStringWithWhiteSpaces) {
FILE: 3rd/googletest-1.12.1/googlemock/test/gmock-matchers-arithmetic_test.cc
type testing (line 44) | namespace testing {
type gmock_matchers_test (line 45) | namespace gmock_matchers_test {
function TEST (line 52) | TEST(Eq2Test, MatchesEqualArguments) {
function TEST (line 59) | TEST(Eq2Test, CanDescribeSelf) {
function TEST (line 66) | TEST(Ge2Test, MatchesGreaterThanOrEqualArguments) {
function TEST (line 74) | TEST(Ge2Test, CanDescribeSelf) {
function TEST (line 81) | TEST(Gt2Test, MatchesGreaterThanArguments) {
function TEST (line 89) | TEST(Gt2Test, CanDescribeSelf) {
function TEST (line 96) | TEST(Le2Test, MatchesLessThanOrEqualArguments) {
function TEST (line 104) | TEST(Le2Test, CanDescribeSelf) {
function TEST (line 111) | TEST(Lt2Test, MatchesLessThanArguments) {
function TEST (line 119) | TEST(Lt2Test, CanDescribeSelf) {
function TEST (line 126) | TEST(Ne2Test, MatchesUnequalArguments) {
function TEST (line 134) | TEST(Ne2Test, CanDescribeSelf) {
function TEST (line 139) | TEST(PairMatchBaseTest, WorksWithMoveOnly) {
function TEST (line 149) | TEST(IsNan, FloatMatchesNan) {
function TEST (line 171) | TEST(IsNan, DoubleMatchesNan) {
function TEST (line 193) | TEST(IsNan, LongDoubleMatchesNan) {
function TEST (line 215) | TEST(IsNan, NotMatchesNan) {
function TEST (line 233) | TEST(IsNan, CanDescribeSelf) {
function TEST (line 245) | TEST(IsNan, CanDescribeSelfWithNot) {
function TEST (line 258) | TEST(FloatEq2Test, MatchesEqualArguments) {
function TEST (line 267) | TEST(FloatEq2Test, CanDescribeSelf) {
function TEST (line 274) | TEST(NanSensitiveFloatEqTest, MatchesEqualArgumentsWithNaN) {
function TEST (line 286) | TEST(NanSensitiveFloatEqTest, CanDescribeSelfWithNaNs) {
function TEST (line 293) | TEST(DoubleEq2Test, MatchesEqualArguments) {
function TEST (line 302) | TEST(DoubleEq2Test, CanDescribeSelf) {
function TEST (line 309) | TEST(NanSensitiveDoubleEqTest, MatchesEqualArgumentsWithNaN) {
function TEST (line 321) | TEST(NanSensitiveDoubleEqTest, CanDescribeSelfWithNaNs) {
function TEST (line 328) | TEST(FloatNear2Test, MatchesEqualArguments) {
function TEST (line 337) | TEST(FloatNear2Test, CanDescribeSelf) {
function TEST (line 344) | TEST(NanSensitiveFloatNearTest, MatchesNearbyArgumentsWithNaN) {
function TEST (line 357) | TEST(NanSensitiveFloatNearTest, CanDescribeSelfWithNaNs) {
function TEST (line 364) | TEST(DoubleNear2Test, MatchesEqualArguments) {
function TEST (line 373) | TEST(DoubleNear2Test, CanDescribeSelf) {
function TEST (line 380) | TEST(NanSensitiveDoubleNearTest, MatchesNearbyArgumentsWithNaN) {
function TEST (line 393) | TEST(NanSensitiveDoubleNearTest, CanDescribeSelfWithNaNs) {
function TEST (line 399) | TEST(NotTest, NegatesMatcher) {
function TEST (line 407) | TEST(NotTest, CanDescribeSelf) {
function TEST (line 413) | TEST(NotTest, NotMatcherSafelyCastsMonomorphicMatchers) {
function AllOfMatches (line 423) | void AllOfMatches(int num, const Matcher<int>& m) {
function TEST (line 436) | TEST(AllOfTest, MatchesWhenAllMatch) {
function TEST (line 489) | TEST(AllOfTest, CanDescribeSelf) {
function TEST (line 513) | TEST(AllOfTest, CanDescribeNegation) {
function TEST (line 543) | TEST(AllOfTest, AllOfMatcherSafelyCastsMonomorphicMatchers) {
function TEST_P (line 557) | TEST_P(AllOfTestP, ExplainsResult) {
function AnyOfMatches (line 602) | static void AnyOfMatches(int num, const Matcher<int>& m) {
function AnyOfStringMatches (line 611) | static void AnyOfStringMatches(int num, const Matcher<std::string>& ...
function TEST (line 625) | TEST(AnyOfTest, MatchesWhenAnyMatches) {
function TEST (line 667) | TEST(AnyOfTest, VariadicMatchesWhenAnyMatches) {
function TEST (line 686) | TEST(ConditionalTest, MatchesFirstIfCondition) {
function TEST (line 700) | TEST(ConditionalTest, MatchesSecondIfCondition) {
function TEST (line 715) | TEST(AnyOfTest, CanDescribeSelf) {
function TEST (line 736) | TEST(AnyOfTest, CanDescribeNegation) {
function TEST (line 759) | TEST(AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers) {
function TEST_P (line 773) | TEST_P(AnyOfTestP, ExplainsResult) {
function IsPositive (line 824) | int IsPositive(double x) { return x > 0 ? 1 : 0; }
class IsGreaterThan (line 828) | class IsGreaterThan {
method IsGreaterThan (line 830) | explicit IsGreaterThan(int threshold) : threshold_(threshold) {}
function ReferencesFooAndIsZero (line 843) | bool ReferencesFooAndIsZero(const int& n) { return (&n == &foo) && (...
function TEST (line 847) | TEST(TrulyTest, MatchesWhatSatisfiesThePredicate) {
function TEST (line 854) | TEST(TrulyTest, CanBeUsedWithFunctor) {
class ConvertibleToBool (line 861) | class ConvertibleToBool {
method ConvertibleToBool (line 863) | explicit ConvertibleToBool(int number) : number_(number) {}
function ConvertibleToBool (line 870) | ConvertibleToBool IsNotZero(int number) { return ConvertibleToBool(n...
method ConvertibleToBool (line 863) | explicit ConvertibleToBool(int number) : number_(number) {}
function TEST (line 875) | TEST(TrulyTest, PredicateCanReturnAClassConvertibleToBool) {
function TEST (line 882) | TEST(TrulyTest, CanDescribeSelf) {
function TEST (line 889) | TEST(TrulyTest, WorksForByRefArguments) {
function TEST (line 897) | TEST(TrulyTest, ExplainsFailures) {
function TEST (line 905) | TEST(MatchesTest, IsSatisfiedByWhatMatchesTheMatcher) {
function TEST (line 912) | TEST(MatchesTest, WorksOnByRefArguments) {
function TEST (line 920) | TEST(MatchesTest, WorksWithMatcherOnNonRefType) {
function TEST (line 929) | TEST(ValueTest, WorksWithPolymorphicMatcher) {
function TEST (line 934) | TEST(ValueTest, WorksWithMonomorphicMatcher) {
function TEST (line 945) | TEST(AllArgsTest, WorksForTuple) {
function TEST (line 950) | TEST(AllArgsTest, WorksForNonTuple) {
class AllArgsHelper (line 955) | class AllArgsHelper {
method AllArgsHelper (line 957) | AllArgsHelper() {}
method AllArgsHelper (line 962) | AllArgsHelper(const AllArgsHelper&) = delete;
method AllArgsHelper (line 963) | AllArgsHelper& operator=(const AllArgsHelper&) = delete;
function TEST (line 966) | TEST(AllArgsTest, WorksInWithClause) {
class OptionalMatchersHelper (line 976) | class OptionalMatchersHelper {
method OptionalMatchersHelper (line 978) | OptionalMatchersHelper() {}
method OptionalMatchersHelper (line 990) | OptionalMatchersHelper(const OptionalMatchersHelper&) = delete;
method OptionalMatchersHelper (line 991) | OptionalMatchersHelper& operator=(const OptionalMatchersHelper&) =...
function TEST (line 994) | TEST(AllArgsTest, WorksWithoutMatchers) {
class FloatingPointTest (line 1017) | class FloatingPointTest : public testing::Test {
method FloatingPointTest (line 1022) | FloatingPointTest()
method TestSize (line 1044) | void TestSize() { EXPECT_EQ(sizeof(RawType), sizeof(Bits)); }
method TestMatches (line 1048) | void TestMatches(
class FloatingPointNearTest (line 1124) | class FloatingPointNearTest : public FloatingPointTest<RawType> {
method TestNearMatches (line 1130) | void TestNearMatches(testing::internal::FloatingEqMatcher<RawType> (
function TEST_F (line 1208) | TEST_F(FloatTest, FloatEqApproximatelyMatchesFloats) { TestMatches(&...
function TEST_F (line 1210) | TEST_F(FloatTest, NanSensitiveFloatEqApproximatelyMatchesFloats) {
function TEST_F (line 1214) | TEST_F(FloatTest, FloatEqCannotMatchNaN) {
function TEST_F (line 1222) | TEST_F(FloatTest, NanSensitiveFloatEqCanMatchNaN) {
function TEST_F (line 1230) | TEST_F(FloatTest, FloatEqCanDescribeSelf) {
function TEST_F (line 1244) | TEST_F(FloatTest, NanSensitiveFloatEqCanDescribeSelf) {
function TEST_F (line 1262) | TEST_F(FloatNearTest, FloatNearMatches) { TestNearMatches(&FloatNear...
function TEST_F (line 1264) | TEST_F(FloatNearTest, NanSensitiveFloatNearApproximatelyMatchesFloat...
function TEST_F (line 1268) | TEST_F(FloatNearTest, FloatNearCanDescribeSelf) {
function TEST_F (line 1284) | TEST_F(FloatNearTest, NanSensitiveFloatNearCanDescribeSelf) {
function TEST_F (line 1300) | TEST_F(FloatNearTest, FloatNearCannotMatchNaN) {
function TEST_F (line 1308) | TEST_F(FloatNearTest, NanSensitiveFloatNearCanMatchNaN) {
function TEST_F (line 1319) | TEST_F(DoubleTest, DoubleEqApproximatelyMatchesDoubles) {
function TEST_F (line 1323) | TEST_F(DoubleTest, NanSensitiveDoubleEqApproximatelyMatchesDoubles) {
function TEST_F (line 1327) | TEST_F(DoubleTest, DoubleEqCannotMatchNaN) {
function TEST_F (line 1335) | TEST_F(DoubleTest, NanSensitiveDoubleEqCanMatchNaN) {
function TEST_F (line 1343) | TEST_F(DoubleTest, DoubleEqCanDescribeSelf) {
function TEST_F (line 1357) | TEST_F(DoubleTest, NanSensitiveDoubleEqCanDescribeSelf) {
function TEST_F (line 1375) | TEST_F(DoubleNearTest, DoubleNearMatches) { TestNearMatches(&DoubleN...
function TEST_F (line 1377) | TEST_F(DoubleNearTest, NanSensitiveDoubleNearApproximatelyMatchesDou...
function TEST_F (line 1381) | TEST_F(DoubleNearTest, DoubleNearCanDescribeSelf) {
function TEST_F (line 1397) | TEST_F(DoubleNearTest, ExplainsResultWhenMatchFails) {
function TEST_F (line 1411) | TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanDescribeSelf) {
function TEST_F (line 1427) | TEST_F(DoubleNearTest, DoubleNearCannotMatchNaN) {
function TEST_F (line 1435) | TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanMatchNaN) {
function TEST (line 1443) | TEST(NotTest, WorksOnMoveOnlyType) {
function TEST (line 1449) | TEST(AllOfTest, HugeMatcher) {
function TEST (line 1456) | TEST(AnyOfTest, HugeMatcher) {
type adl_test (line 1463) | namespace adl_test {
function AllOf (line 1478) | bool AllOf(const T1& /*t1*/, const T2& /*t2*/) {
function TEST (line 1482) | TEST(AllOfTest, DoesNotCallAllOfUnqualified) {
function AnyOf (line 1488) | bool AnyOf(const T1&, const T2&) {
function TEST (line 1492) | TEST(AnyOfTest, DoesNotCallAnyOfUnqualified) {
function TEST (line 1499) | TEST(AllOfTest, WorksOnMoveOnlyType) {
function TEST (line 1505) | TEST(AnyOfTest, WorksOnMoveOnlyType) {
FILE: 3rd/googletest-1.12.1/googlemock/test/gmock-matchers-comparisons_test.cc
type testing (line 44) | namespace testing {
type gmock_matchers_test (line 45) | namespace gmock_matchers_test {
function TEST_P (line 50) | TEST_P(MonotonicMatcherTestP, IsPrintable) {
function TEST (line 56) | TEST(MatchResultListenerTest, StreamingWorks) {
function TEST (line 72) | TEST(MatchResultListenerTest, CanAccessUnderlyingStream) {
function TEST (line 79) | TEST(MatchResultListenerTest, IsInterestedWorks) {
class EvenMatcherImpl (line 89) | class EvenMatcherImpl : public MatcherInterface<int> {
method MatchAndExplain (line 91) | bool MatchAndExplain(int x,
method DescribeTo (line 96) | void DescribeTo(ostream* os) const override { *os << "is an even n...
function TEST (line 104) | TEST(MatcherInterfaceTest, CanBeImplementedUsingPublishedAPI) {
class NewEvenMatcherImpl (line 110) | class NewEvenMatcherImpl : public MatcherInterface<int> {
method MatchAndExplain (line 112) | bool MatchAndExplain(int x, MatchResultListener* listener) const o...
method DescribeTo (line 124) | void DescribeTo(ostream* os) const override { *os << "is an even n...
function TEST (line 127) | TEST(MatcherInterfaceTest, CanBeImplementedUsingNewAPI) {
function TEST (line 138) | TEST(MatcherTest, CanBeDefaultConstructed) { Matcher<double> m; }
function TEST (line 141) | TEST(MatcherTest, CanBeConstructedFromMatcherInterface) {
function TEST (line 149) | TEST(MatcherTest, CanBeImplicitlyConstructedFromValue) {
function TEST (line 156) | TEST(MatcherTest, CanBeImplicitlyConstructedFromNULL) {
type Undefined (line 165) | struct Undefined {
function TEST (line 170) | TEST(MatcherTest, CanBeConstructedFromUndefinedVariable) {
function TEST (line 177) | TEST(MatcherTest, CanAcceptAbstractClass) { Matcher<const Undefined&...
function TEST (line 180) | TEST(MatcherTest, IsCopyable) {
function TEST (line 194) | TEST(MatcherTest, CanDescribeItself) {
function TEST_P (line 199) | TEST_P(MatcherTestP, MatchAndExplain) {
function TEST (line 212) | TEST(StringMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
function TEST (line 224) | TEST(StringMatcherTest, CanBeImplicitlyConstructedFromString) {
function TEST (line 237) | TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromCStringLit...
function TEST (line 249) | TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromString) {
function TEST (line 261) | TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromStringView) {
function TEST (line 274) | TEST(StringMatcherTest,
function TEST (line 289) | TEST(MakeMatcherTest, ConstructsMatcherFromMatcherInterface) {
class ReferencesBarOrIsZeroImpl (line 297) | class ReferencesBarOrIsZeroImpl {
method MatchAndExplain (line 300) | bool MatchAndExplain(const T& x, MatchResultListener* /* listener ...
method DescribeTo (line 305) | void DescribeTo(ostream* os) const { *os << "g_bar or zero"; }
method DescribeNegationTo (line 307) | void DescribeNegationTo(ostream* os) const {
function ReferencesBarOrIsZero (line 314) | PolymorphicMatcher<ReferencesBarOrIsZeroImpl> ReferencesBarOrIsZero() {
function TEST (line 318) | TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingOldAPI) {
class PolymorphicIsEvenImpl (line 336) | class PolymorphicIsEvenImpl {
method DescribeTo (line 338) | void DescribeTo(ostream* os) const { *os << "is even"; }
method DescribeNegationTo (line 340) | void DescribeNegationTo(ostream* os) const { *os << "is odd"; }
method MatchAndExplain (line 343) | bool MatchAndExplain(const T& x, MatchResultListener* listener) co...
function PolymorphicIsEven (line 355) | PolymorphicMatcher<PolymorphicIsEvenImpl> PolymorphicIsEven() {
function TEST (line 359) | TEST(MakePolymorphicMatcherTest, ConstructsMatcherUsingNewAPI) {
function TEST_P (line 386) | TEST_P(MatcherCastTestP, FromPolymorphicMatcher) {
class IntValue (line 398) | class IntValue {
method IntValue (line 402) | explicit IntValue(int a_value) : value_(a_value) {}
method value (line 404) | int value() const { return value_; }
function IsPositiveIntValue (line 411) | bool IsPositiveIntValue(const IntValue& foo) { return foo.value() > ...
function TEST (line 415) | TEST(MatcherCastTest, FromCompatibleType) {
function TEST (line 431) | TEST(MatcherCastTest, FromConstReferenceToNonReference) {
function TEST (line 439) | TEST(MatcherCastTest, FromReferenceToNonReference) {
function TEST (line 447) | TEST(MatcherCastTest, FromNonReferenceToConstReference) {
function TEST (line 455) | TEST(MatcherCastTest, FromNonReferenceToReference) {
function TEST (line 465) | TEST(MatcherCastTest, FromSameType) {
function TEST (line 474) | TEST(MatcherCastTest, FromAValue) {
function TEST (line 482) | TEST(MatcherCastTest, FromAnImplicitlyConvertibleValue) {
type NonImplicitlyConstructibleTypeWithOperatorEq (line 489) | struct NonImplicitlyConstructibleTypeWithOperatorEq {
function TEST (line 505) | TEST(MatcherCastTest, NonImplicitlyConstructibleTypeWithOperatorEq) {
type convertible_from_any (line 536) | namespace convertible_from_any {
type ConvertibleFromAny (line 538) | struct ConvertibleFromAny {
method ConvertibleFromAny (line 539) | ConvertibleFromAny(int a_value) : value(a_value) {}
method ConvertibleFromAny (line 541) | ConvertibleFromAny(const T& /*a_value*/) : value(-1) {
function ostream (line 551) | ostream& operator<<(ostream& os, const ConvertibleFromAny& a) {
function TEST (line 555) | TEST(MatcherCastTest, ConversionConstructorIsUsed) {
function TEST (line 561) | TEST(MatcherCastTest, FromConvertibleFromAny) {
function TEST (line 688) | TEST(SafeMatcherCastTest, ConversionConstructorIsUsed) {
function TEST (line 694) | TEST(SafeMatcherCastTest, FromConvertibleFromAny) {
type IntReferenceWrapper (line 571) | struct IntReferenceWrapper {
method IntReferenceWrapper (line 572) | IntReferenceWrapper(const int& a_value) : value(&a_value) {}
function TEST (line 580) | TEST(MatcherCastTest, ValueIsNotCopied) {
class Base (line 587) | class Base {
method Base (line 590) | Base() {}
method Base (line 593) | Base(const Base&) = delete;
method Base (line 594) | Base& operator=(const Base&) = delete;
class Derived (line 597) | class Derived : public Base {
method Derived (line 599) | Derived() : Base() {}
class OtherDerived (line 603) | class OtherDerived : public Base {}
function TEST_P (line 608) | TEST_P(SafeMatcherCastTestP, FromPolymorphicMatcher) {
function TEST (line 622) | TEST(SafeMatcherCastTest, FromLosslesslyConvertibleArithmeticType) {
function TEST (line 635) | TEST(SafeMatcherCastTest, FromBaseClass) {
function TEST (line 649) | TEST(SafeMatcherCastTest, FromConstReferenceToReference) {
function TEST (line 659) | TEST(SafeMatcherCastTest, FromNonReferenceToConstReference) {
function TEST (line 668) | TEST(SafeMatcherCastTest, FromNonReferenceToReference) {
function TEST (line 678) | TEST(SafeMatcherCastTest, FromSameType) {
type convertible_from_any (line 687) | namespace convertible_from_any {
type ConvertibleFromAny (line 538) | struct ConvertibleFromAny {
method ConvertibleFromAny (line 539) | ConvertibleFromAny(int a_value) : value(a_value) {}
method ConvertibleFromAny (line 541) | ConvertibleFromAny(const T& /*a_value*/) : value(-1) {
function ostream (line 551) | ostream& operator<<(ostream& os, const ConvertibleFromAny& a) {
function TEST (line 555) | TEST(MatcherCastTest, ConversionConstructorIsUsed) {
function TEST (line 561) | TEST(MatcherCastTest, FromConvertibleFromAny) {
function TEST (line 688) | TEST(SafeMatcherCastTest, ConversionConstructorIsUsed) {
function TEST (line 694) | TEST(SafeMatcherCastTest, FromConvertibleFromAny) {
function TEST (line 704) | TEST(SafeMatcherCastTest, ValueIsNotCopied) {
function TEST (line 711) | TEST(ExpectThat, TakesLiterals) {
function TEST (line 717) | TEST(ExpectThat, TakesFunctions) {
function TEST (line 727) | TEST(ATest, MatchesAnyValue) {
function TEST (line 741) | TEST(ATest, WorksForDerivedClass) {
function TEST (line 751) | TEST(ATest, CanDescribeSelf) { EXPECT_EQ("is anything", Describe(A<b...
function TEST (line 754) | TEST(AnTest, MatchesAnyValue) {
function TEST (line 769) | TEST(AnTest, CanDescribeSelf) { EXPECT_EQ("is anything", Describe(An...
function TEST (line 773) | TEST(UnderscoreTest, MatchesAnyValue) {
function TEST (line 788) | TEST(UnderscoreTest, CanDescribeSelf) {
function TEST (line 794) | TEST(EqTest, MatchesEqualValue) {
class Unprintable (line 806) | class Unprintable {
method Unprintable (line 808) | Unprintable() : c_('a') {}
method dummy_c (line 812) | char dummy_c() { return c_; }
function TEST (line 818) | TEST(EqTest, CanDescribeSelf) {
function TEST (line 825) | TEST(EqTest, IsPolymorphic) {
function TEST (line 836) | TEST(TypedEqTest, ChecksEqualityForGivenType) {
function TEST (line 847) | TEST(TypedEqTest, CanDescribeSelf) {
type Type (line 857) | struct Type {
method IsTypeOf (line 858) | static bool IsTypeOf(const T& /* v */) { return true; }
function TEST (line 864) | TEST(TypedEqTest, HasSpecifiedType) {
function TEST (line 871) | TEST(GeTest, ImplementsGreaterThanOrEqual) {
function TEST (line 879) | TEST(GeTest, CanDescribeSelf) {
function TEST (line 885) | TEST(GtTest, ImplementsGreaterThan) {
function TEST (line 893) | TEST(GtTest, CanDescribeSelf) {
function TEST (line 899) | TEST(LeTest, ImplementsLessThanOrEqual) {
function TEST (line 907) | TEST(LeTest, CanDescribeSelf) {
function TEST (line 913) | TEST(LtTest, ImplementsLessThan) {
function TEST (line 921) | TEST(LtTest, CanDescribeSelf) {
function TEST (line 927) | TEST(NeTest, ImplementsNotEqual) {
function TEST (line 935) | TEST(NeTest, CanDescribeSelf) {
class MoveOnly (line 940) | class MoveOnly {
method MoveOnly (line 942) | explicit MoveOnly(int i) : i_(i) {}
method MoveOnly (line 943) | MoveOnly(const MoveOnly&) = delete;
method MoveOnly (line 944) | MoveOnly(MoveOnly&&) = default;
method MoveOnly (line 945) | MoveOnly& operator=(const MoveOnly&) = delete;
method MoveOnly (line 946) | MoveOnly& operator=(MoveOnly&&) = default;
type MoveHelper (line 959) | struct MoveHelper {
function TEST (line 965) | TEST(ComparisonBaseTest, DISABLED_WorksWithMoveOnly) {
FILE: 3rd/googletest-1.12.1/googlemock/test/gmock-matchers-containers_test.cc
type testing (line 44) | namespace testing {
type gmock_matchers_test (line 45) | namespace gmock_matchers_test {
function MakeUniquePtrs (line 48) | std::vector<std::unique_ptr<int>> MakeUniquePtrs(const std::vector<i...
function OfType (line 54) | std::string OfType(const std::string& type_name) {
function TEST (line 62) | TEST(ContainsTest, WorksWithMoveOnly) {
function TEST (line 71) | TEST(ElementsAreTest, HugeMatcher) {
function TEST (line 80) | TEST(ElementsAreTest, HugeMatcherStr) {
function TEST (line 89) | TEST(ElementsAreTest, HugeMatcherUnordered) {
function TEST (line 99) | TEST(MatcherAssertionTest, WorksWhenMatcherIsSatisfied) {
function TEST (line 108) | TEST(MatcherAssertionTest, WorksWhenMatcherIsNotSatisfied) {
function TEST (line 129) | TEST(MatcherAssertionTest, WorksForByRefArguments) {
function TEST (line 145) | TEST(MatcherAssertionTest, WorksForMonomorphicMatcher) {
function TEST (line 164) | TEST(PointeeTest, RawPointer) {
function TEST (line 174) | TEST(PointeeTest, RawPointerToConst) {
function TEST (line 184) | TEST(PointeeTest, ReferenceToConstRawPointer) {
function TEST (line 194) | TEST(PointeeTest, ReferenceToNonConstRawPointer) {
function TEST (line 206) | TEST(PointeeTest, SmartPointer) {
function TEST (line 213) | TEST(PointeeTest, SmartPointerToConst) {
function TEST (line 223) | TEST(PointerTest, RawPointer) {
function TEST (line 234) | TEST(PointerTest, RawPointerToConst) {
function TEST (line 245) | TEST(PointerTest, SmartPointer) {
function TEST (line 253) | TEST(PointerTest, SmartPointerToConst) {
class ConstPropagatingPtr (line 267) | class ConstPropagatingPtr {
method ConstPropagatingPtr (line 271) | ConstPropagatingPtr() : val_() {}
method ConstPropagatingPtr (line 272) | explicit ConstPropagatingPtr(T* t) : val_(t) {}
method ConstPropagatingPtr (line 273) | ConstPropagatingPtr(const ConstPropagatingPtr& other) : val_(other...
method T (line 275) | T* get() { return val_; }
method T (line 276) | T& operator*() { return *val_; }
method T (line 278) | const T* get() const { return val_; }
method T (line 279) | const T& operator*() const { return *val_; }
function TEST (line 287) | TEST(PointeeTest, WorksWithConstPropagatingPointers) {
function TEST (line 299) | TEST(PointeeTest, NeverMatchesNull) {
function TEST (line 305) | TEST(PointeeTest, MatchesAgainstAValue) {
function TEST (line 315) | TEST(PointeeTest, CanDescribeSelf) {
function TEST_P (line 321) | TEST_P(PointeeTestP, CanExplainMatchResult) {
function TEST (line 332) | TEST(PointeeTest, AlwaysExplainsPointee) {
class Uncopyable (line 339) | class Uncopyable {
method Uncopyable (line 341) | Uncopyable() : value_(-1) {}
method Uncopyable (line 342) | explicit Uncopyable(int a_value) : value_(a_value) {}
method value (line 344) | int value() const { return value_; }
method set_value (line 345) | void set_value(int i) { value_ = i; }
method Uncopyable (line 349) | Uncopyable(const Uncopyable&) = delete;
method Uncopyable (line 350) | Uncopyable& operator=(const Uncopyable&) = delete;
function ValueIsPositive (line 354) | bool ValueIsPositive(const Uncopyable& x) { return x.value() > 0; }
type AStruct (line 361) | struct AStruct {
method AStruct (line 362) | AStruct() : x(0), y(1.0), z(5), p(nullptr) {}
method AStruct (line 363) | AStruct(const AStruct& rhs)
type DerivedStruct (line 373) | struct DerivedStruct : public AStruct {
function TEST (line 380) | TEST(FieldTest, WorksForNonConstField) {
function TEST (line 393) | TEST(FieldTest, WorksForConstField) {
function TEST (line 407) | TEST(FieldTest, WorksForUncopyableField) {
function TEST (line 417) | TEST(FieldTest, WorksForPointerField) {
function TEST (line 434) | TEST(FieldTest, WorksForByRefArgument) {
function TEST (line 445) | TEST(FieldTest, WorksForArgumentOfSubType) {
function TEST (line 458) | TEST(FieldTest, WorksForCompatibleMatcherType) {
function TEST (line 469) | TEST(FieldTest, CanDescribeSelf) {
function TEST (line 476) | TEST(FieldTest, CanDescribeSelfWithFieldName) {
function TEST_P (line 485) | TEST_P(FieldTestP, CanExplainMatchResult) {
function TEST_P (line 498) | TEST_P(FieldTestP, CanExplainMatchResultWithFieldName) {
function TEST (line 514) | TEST(FieldForPointerTest, WorksForPointerToConst) {
function TEST (line 524) | TEST(FieldForPointerTest, WorksForPointerToNonConst) {
function TEST (line 534) | TEST(FieldForPointerTest, WorksForReferenceToConstPointer) {
function TEST (line 544) | TEST(FieldForPointerTest, DoesNotMatchNull) {
function TEST (line 551) | TEST(FieldForPointerTest, WorksForArgumentOfSubType) {
function TEST (line 563) | TEST(FieldForPointerTest, CanDescribeSelf) {
function TEST (line 570) | TEST(FieldForPointerTest, CanDescribeSelfWithFieldName) {
function TEST_P (line 579) | TEST_P(FieldForPointerTestP, CanExplainMatchResult) {
function TEST_P (line 594) | TEST_P(FieldForPointerTestP, CanExplainMatchResultWithFieldName) {
class AClass (line 611) | class AClass {
method AClass (line 613) | AClass() : n_(0) {}
method n (line 616) | int n() const { return n_; }
method set_n (line 618) | void set_n(int new_n) { n_ = new_n; }
method set_s (line 625) | void set_s(const std::string& new_s) { s_ = new_s; }
class DerivedClass (line 640) | class DerivedClass : public AClass {
method k (line 642) | int k() const { return k_; }
function TEST (line 652) | TEST(PropertyTest, WorksForNonReferenceProperty) {
function TEST (line 668) | TEST(PropertyTest, WorksForReferenceToConstProperty) {
function TEST (line 685) | TEST(PropertyTest, WorksForRefQualifiedProperty) {
function TEST (line 702) | TEST(PropertyTest, WorksForReferenceToNonConstProperty) {
function TEST (line 715) | TEST(PropertyTest, WorksForByValueArgument) {
function TEST (line 728) | TEST(PropertyTest, WorksForArgumentOfSubType) {
function TEST (line 743) | TEST(PropertyTest, WorksForCompatibleMatcherType) {
function TEST (line 759) | TEST(PropertyTest, CanDescribeSelf) {
function TEST (line 767) | TEST(PropertyTest, CanDescribeSelfWithPropertyName) {
function TEST_P (line 776) | TEST_P(PropertyTestP, CanExplainMatchResult) {
function TEST_P (line 789) | TEST_P(PropertyTestP, CanExplainMatchResultWithPropertyName) {
function TEST (line 805) | TEST(PropertyForPointerTest, WorksForPointerToConst) {
function TEST (line 817) | TEST(PropertyForPointerTest, WorksForPointerToNonConst) {
function TEST (line 830) | TEST(PropertyForPointerTest, WorksForReferenceToConstPointer) {
function TEST (line 842) | TEST(PropertyForPointerTest, WorksForReferenceToNonConstProperty) {
function TEST (line 849) | TEST(PropertyForPointerTest, WorksForArgumentOfSubType) {
function TEST (line 863) | TEST(PropertyForPointerTest, CanDescribeSelf) {
function TEST (line 871) | TEST(PropertyForPointerTest, CanDescribeSelfWithPropertyDescription) {
function TEST_P (line 880) | TEST_P(PropertyForPointerTestP, CanExplainMatchResult) {
function TEST_P (line 896) | TEST_P(PropertyForPointerTestP, CanExplainMatchResultWithPropertyNam...
function IntToStringFunction (line 916) | std::string IntToStringFunction(int input) {
function TEST (line 922) | TEST(ResultOfTest, WorksForFunctionPointers) {
function TEST (line 930) | TEST(ResultOfTest, CanDescribeItself) {
function TEST (line 944) | TEST(ResultOfTest, CanDescribeItselfWithResultDescription) {
function IntFunction (line 954) | int IntFunction(int input) { return input == 42 ? 80 : 90; }
function TEST_P (line 956) | TEST_P(ResultOfTestP, CanExplainMatchResult) {
function TEST_P (line 967) | TEST_P(ResultOfTestP, CanExplainMatchResultWithResultDescription) {
function TEST (line 980) | TEST(ResultOfTest, WorksForNonReferenceResults) {
function Uncopyable (line 991) | Uncopyable& RefUncopyableFunction(Uncopyable& obj) { // NOLINT
method Uncopyable (line 341) | Uncopyable() : value_(-1) {}
method Uncopyable (line 342) | explicit Uncopyable(int a_value) : value_(a_value) {}
method value (line 344) | int value() const { return value_; }
method set_value (line 345) | void set_value(int i) { value_ = i; }
method Uncopyable (line 349) | Uncopyable(const Uncopyable&) = delete;
method Uncopyable (line 350) | Uncopyable& operator=(const Uncopyable&) = delete;
function TEST (line 995) | TEST(ResultOfTest, WorksForReferenceToNonConstResults) {
function TEST (line 1016) | TEST(ResultOfTest, WorksForReferenceToConstResults) {
function TEST (line 1027) | TEST(ResultOfTest, WorksForCompatibleMatcherTypes) {
function TEST (line 1037) | TEST(ResultOfDeathTest, DiesOnNullFunctionPointers) {
function TEST (line 1046) | TEST(ResultOfTest, WorksForFunctionReferences) {
type Functor (line 1054) | struct Functor {
function TEST (line 1058) | TEST(ResultOfTest, WorksForFunctors) {
type PolymorphicFunctor (line 1068) | struct PolymorphicFunctor {
function TEST (line 1075) | TEST(ResultOfTest, WorksForPolymorphicFunctors) {
function TEST (line 1087) | TEST(ResultOfTest, WorksForPolymorphicFunctorsIgnoringResultType) {
function TEST (line 1095) | TEST(ResultOfTest, WorksForLambdas) {
function TEST (line 1105) | TEST(ResultOfTest, WorksForNonCopyableArguments) {
type ReferencingFunctor (line 1117) | struct ReferencingFunctor {
method result_type (line 1119) | result_type operator()(const int& n) { return &n; }
function TEST (line 1122) | TEST(ResultOfTest, WorksForReferencingCallables) {
function TEST (line 1134) | TEST(SizeIsTest, ImplementsSizeIs) {
function TEST (line 1146) | TEST(SizeIsTest, WorksWithMap) {
function TEST (line 1158) | TEST(SizeIsTest, WorksWithReferences) {
function TEST (line 1166) | TEST(SizeIsTest, WorksWithMoveOnly) {
type MinimalistCustomType (line 1174) | struct MinimalistCustomType {
method size (line 1175) | int size() const { return 1; }
function TEST (line 1177) | TEST(SizeIsTest, WorksWithMinimalistCustomType) {
function TEST (line 1183) | TEST(SizeIsTest, CanDescribeSelf) {
function TEST (line 1189) | TEST(SizeIsTest, ExplainsResult) {
function TEST (line 1207) | TEST(WhenSortedByTest, WorksForEmptyContainer) {
function TEST (line 1213) | TEST(WhenSortedByTest, WorksForNonEmptyContainer) {
function TEST (line 1225) | TEST(WhenSortedByTest, WorksForNonVectorContainer) {
function TEST (line 1236) | TEST(WhenSortedByTest, WorksForNativeArray) {
function TEST (line 1245) | TEST(WhenSortedByTest, CanDescribeSelf) {
function TEST (line 1259) | TEST(WhenSortedByTest, ExplainsMatchResult) {
function TEST (line 1270) | TEST(WhenSortedTest, WorksForEmptyContainer) {
function TEST (line 1276) | TEST(WhenSortedTest, WorksForNonEmptyContainer) {
function TEST (line 1286) | TEST(WhenSortedTest, WorksForMapTypes) {
function TEST (line 1299) | TEST(WhenSortedTest, WorksForMultiMapTypes) {
function TEST (line 1315) | TEST(WhenSortedTest, WorksForPolymorphicMatcher) {
function TEST (line 1323) | TEST(WhenSortedTest, WorksForVectorConstRefMatcher) {
class Streamlike (line 1336) | class Streamlike {
class ConstIter (line 1338) | class ConstIter
method ConstIter (line 1361) | ConstIter(const Streamlike* s, typename std::list<value_type>::i...
method value_type (line 1364) | const value_type& operator*() const { return *pos_; }
method value_type (line 1365) | const value_type* operator->() const { return &*pos_; }
method ConstIter (line 1366) | ConstIter& operator++() {
class PostIncrProxy (line 1373) | class PostIncrProxy {
method PostIncrProxy (line 1375) | explicit PostIncrProxy(const value_type& value) : value_(value...
method value_type (line 1376) | value_type operator*() const { return value_; }
method PostIncrProxy (line 1381) | PostIncrProxy operator++(int) {
method PostIncrProxy (line 1375) | explicit PostIncrProxy(const value_type& value) : value_(value...
method value_type (line 1376) | value_type operator*() const { return value_; }
method Streamlike (line 1345) | Streamlike(InIter first, InIter last) : remainder_(first, last) {}
method const_iterator (line 1347) | const_iterator begin() const {
method const_iterator (line 1350) | const_iterator end() const { return const_iterator(this, remainder...
class ConstIter (line 1353) | class ConstIter {
method ConstIter (line 1361) | ConstIter(const Streamlike* s, typename std::list<value_type>::i...
method value_type (line 1364) | const value_type& operator*() const { return *pos_; }
method value_type (line 1365) | const value_type* operator->() const { return &*pos_; }
method ConstIter (line 1366) | ConstIter& operator++() {
class PostIncrProxy (line 1373) | class PostIncrProxy {
method PostIncrProxy (line 1375) | explicit PostIncrProxy(const value_type& value) : value_(value...
method value_type (line 1376) | value_type operator*() const { return value_; }
method PostIncrProxy (line 1381) | PostIncrProxy operator++(int) {
method PostIncrProxy (line 1375) | explicit PostIncrProxy(const value_type& value) : value_(value...
method value_type (line 1376) | value_type operator*() const { return value_; }
function TEST (line 1414) | TEST(StreamlikeTest, Iteration) {
function TEST (line 1427) | TEST(BeginEndDistanceIsTest, WorksWithForwardList) {
function TEST (line 1439) | TEST(BeginEndDistanceIsTest, WorksWithNonStdList) {
function TEST (line 1445) | TEST(BeginEndDistanceIsTest, CanDescribeSelf) {
function TEST (line 1452) | TEST(BeginEndDistanceIsTest, WorksWithMoveOnly) {
function TEST_P (line 1458) | TEST_P(BeginEndDistanceIsTestP, ExplainsResult) {
function TEST (line 1488) | TEST(WhenSortedTest, WorksForStreamlike) {
function TEST (line 1497) | TEST(WhenSortedTest, WorksForVectorConstRefMatcherOnStreamlike) {
function TEST (line 1505) | TEST(IsSupersetOfTest, WorksForNativeArray) {
function TEST (line 1516) | TEST(IsSupersetOfTest, WorksWithDuplicates) {
function TEST (line 1524) | TEST(IsSupersetOfTest, WorksForEmpty) {
function TEST (line 1542) | TEST(IsSupersetOfTest, WorksForStreamlike) {
function TEST (line 1556) | TEST(IsSupersetOfTest, TakesStlContainer) {
function TEST (line 1568) | TEST(IsSupersetOfTest, Describe) {
function TEST (line 1582) | TEST(IsSupersetOfTest, DescribeNegation) {
function TEST (line 1596) | TEST(IsSupersetOfTest, MatchAndExplain) {
function TEST (line 1619) | TEST(IsSupersetOfTest, WorksForRhsInitializerList) {
function TEST (line 1625) | TEST(IsSupersetOfTest, WorksWithMoveOnly) {
function TEST (line 1633) | TEST(IsSubsetOfTest, WorksForNativeArray) {
function TEST (line 1644) | TEST(IsSubsetOfTest, WorksWithDuplicates) {
function TEST (line 1652) | TEST(IsSubsetOfTest, WorksForEmpty) {
function TEST (line 1670) | TEST(IsSubsetOfTest, WorksForStreamlike) {
function TEST (line 1682) | TEST(IsSubsetOfTest, TakesStlContainer) {
function TEST (line 1695) | TEST(IsSubsetOfTest, Describe) {
function TEST (line 1710) | TEST(IsSubsetOfTest, DescribeNegation) {
function TEST (line 1724) | TEST(IsSubsetOfTest, MatchAndExplain) {
function TEST (line 1747) | TEST(IsSubsetOfTest, WorksForRhsInitializerList) {
function TEST (line 1753) | TEST(IsSubsetOfTest, WorksWithMoveOnly) {
function TEST (line 1764) | TEST(ElemensAreStreamTest, WorksForStreamlike) {
function TEST (line 1771) | TEST(ElemensAreArrayStreamTest, WorksForStreamlike) {
function TEST (line 1787) | TEST(ElementsAreTest, WorksWithUncopyable) {
function TEST (line 1794) | TEST(ElementsAreTest, WorksWithMoveOnly) {
function TEST (line 1803) | TEST(ElementsAreTest, TakesStlContainer) {
function TEST (line 1818) | TEST(UnorderedElementsAreArrayTest, SucceedsWhenExpected) {
function TEST (line 1828) | TEST(UnorderedElementsAreArrayTest, VectorBool) {
function TEST (line 1839) | TEST(UnorderedElementsAreArrayTest, WorksForStreamlike) {
function TEST (line 1858) | TEST(UnorderedElementsAreArrayTest, TakesStlContainer) {
function TEST (line 1871) | TEST(UnorderedElementsAreArrayTest, TakesInitializerList) {
function TEST (line 1877) | TEST(UnorderedElementsAreArrayTest, TakesInitializerListOfCStrings) {
function TEST (line 1883) | TEST(UnorderedElementsAreArrayTest, TakesInitializerListOfSameTypedM...
function TEST (line 1891) | TEST(UnorderedElementsAreArrayTest,
function TEST (line 1903) | TEST(UnorderedElementsAreArrayTest, WorksWithMoveOnly) {
class UnorderedElementsAreTest (line 1910) | class UnorderedElementsAreTest : public testing::Test {
function TEST_F (line 1915) | TEST_F(UnorderedElementsAreTest, WorksWithUncopyable) {
function TEST_F (line 1923) | TEST_F(UnorderedElementsAreTest, SucceedsWhenExpected) {
function TEST_F (line 1933) | TEST_F(UnorderedElementsAreTest, FailsWhenAnElementMatchesNoMatcher) {
function TEST_F (line 1946) | TEST_F(UnorderedElementsAreTest, WorksForStreamlike) {
function TEST_F (line 1957) | TEST_F(UnorderedElementsAreTest, WorksWithMoveOnly) {
function TEST_F (line 1969) | TEST_F(UnorderedElementsAreTest, Performance) {
function TEST_F (line 1985) | TEST_F(UnorderedElementsAreTest, PerformanceHalfStrict) {
function TEST_F (line 2001) | TEST_F(UnorderedElementsAreTest, FailMessageCountWrong) {
function TEST_F (line 2010) | TEST_F(UnorderedElementsAreTest, FailMessageCountWrongZero) {
function TEST_F (line 2018) | TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatchers) {
function TEST_F (line 2030) | TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedElements) {
function TEST_F (line 2042) | TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatcherAndEleme...
function EMString (line 2060) | static std::string EMString(int element, int matcher) {
function TEST_F (line 2066) | TEST_F(UnorderedElementsAreTest, FailMessageImperfectMatchOnly) {
function TEST_F (line 2094) | TEST_F(UnorderedElementsAreTest, Describe) {
function TEST_F (line 2106) | TEST_F(UnorderedElementsAreTest, DescribeNegation) {
function TEST_P (line 2124) | TEST_P(EachTestP, ExplainsMatchResultCorrectly) {
function TEST (line 2149) | TEST(EachTest, DescribesItselfCorrectly) {
function TEST (line 2157) | TEST(EachTest, MatchesVectorWhenAllElementsMatch) {
function TEST (line 2177) | TEST(EachTest, MatchesMapWhenAllElementsMatch) {
function TEST (line 2195) | TEST(EachTest, AcceptsMatcher) {
function TEST (line 2201) | TEST(EachTest, WorksForNativeArrayAsTuple) {
function TEST (line 2208) | TEST(EachTest, WorksWithMoveOnly) {
class IsHalfOfMatcher (line 2215) | class IsHalfOfMatcher {
method MatchAndExplain (line 2218) | bool MatchAndExplain(const std::tuple<T1, T2>& a_pair,
method DescribeTo (line 2229) | void DescribeTo(ostream* os) const {
method DescribeNegationTo (line 2233) | void DescribeNegationTo(ostream* os) const {
function IsHalfOf (line 2238) | PolymorphicMatcher<IsHalfOfMatcher> IsHalfOf() {
function TEST (line 2242) | TEST(PointwiseTest, DescribesSelf) {
function TEST (line 2259) | TEST(PointwiseTest, MakesCopyOfRhs) {
function TEST (line 2273) | TEST(PointwiseTest, WorksForLhsNativeArray) {
function TEST (line 2283) | TEST(PointwiseTest, WorksForRhsNativeArray) {
function TEST (line 2294) | TEST(PointwiseTest, WorksForVectorOfBool) {
function TEST (line 2303) | TEST(PointwiseTest, WorksForRhsInitializerList) {
function TEST (line 2309) | TEST(PointwiseTest, RejectsWrongSize) {
function TEST (line 2319) | TEST(PointwiseTest, RejectsWrongContent) {
function TEST (line 2329) | TEST(PointwiseTest, AcceptsCorrectContent) {
function TEST (line 2336) | TEST(PointwiseTest, AllowsMonomorphicInnerMatcher) {
function TEST (line 2355) | TEST(PointwiseTest, WorksWithMoveOnly) {
function TEST (line 2361) | TEST(UnorderedPointwiseTest, DescribesSelf) {
function TEST (line 2387) | TEST(UnorderedPointwiseTest, MakesCopyOfRhs) {
function TEST (line 2401) | TEST(UnorderedPointwiseTest, WorksForLhsNativeArray) {
function TEST (line 2411) | TEST(UnorderedPointwiseTest, WorksForRhsNativeArray) {
function TEST (line 2421) | TEST(UnorderedPointwiseTest, WorksForRhsInitializerList) {
function TEST (line 2427) | TEST(UnorderedPointwiseTest, RejectsWrongSize) {
function TEST (line 2438) | TEST(UnorderedPointwiseTest, RejectsWrongContent) {
function TEST (line 2448) | TEST(UnorderedPointwiseTest, AcceptsCorrectContentInSameOrder) {
function TEST (line 2454) | TEST(UnorderedPointwiseTest, AcceptsCorrectContentInDifferentOrder) {
function TEST (line 2460) | TEST(UnorderedPointwiseTest, AllowsMonomorphicInnerMatcher) {
function TEST (line 2472) | TEST(UnorderedPointwiseTest, WorksWithMoveOnly) {
function TEST (line 2479) | TEST(PointeeTest, WorksOnMoveOnlyType) {
class PredicateFormatterFromMatcherTest (line 2485) | class PredicateFormatterFromMatcherTest : public ::testing::Test {
type Behavior (line 2487) | enum Behavior { kInitialSuccess, kAlwaysFail, kFlaky }
class MockMatcher (line 2492) | class MockMatcher : public MatcherInterface<Behavior> {
method MatchAndExplain (line 2494) | bool MatchAndExplain(Behavior behavior,
method DescribeTo (line 2519) | void DescribeTo(ostream* os) const override { *os << "[DescribeT...
method DescribeNegationTo (line 2521) | void DescribeNegationTo(ostream* os) const override {
method AssertionResult (line 2526) | AssertionResult RunPredicateFormatter(Behavior behavior) {
function TEST_F (line 2534) | TEST_F(PredicateFormatterFromMatcherTest, ShortCircuitOnSuccess) {
function TEST_F (line 2541) | TEST_F(PredicateFormatterFromMatcherTest, NoShortCircuitOnFailure) {
function TEST_F (line 2551) | TEST_F(PredicateFormatterFromMatcherTest, DetectsFlakyShortCircuit) {
function TEST (line 2565) | TEST(ElementsAreTest, CanDescribeExpectingNoElement) {
function TEST (line 2570) | TEST(ElementsAreTest, CanDescribeExpectingOneElement) {
function TEST (line 2575) | TEST(ElementsAreTest, CanDescribeExpectingManyElements) {
function TEST (line 2584) | TEST(ElementsAreTest, CanDescribeNegationOfExpectingNoElement) {
function TEST (line 2589) | TEST(ElementsAreTest, CanDescribeNegationOfExpectingOneElement) {
function TEST (line 2597) | TEST(ElementsAreTest, CanDescribeNegationOfExpectingManyElements) {
function TEST (line 2606) | TEST(ElementsAreTest, DoesNotExplainTrivialMatch) {
function TEST_P (line 2615) | TEST_P(ElementsAreTestP, ExplainsNonTrivialMatch) {
function TEST (line 2627) | TEST(ElementsAreTest, CanExplainMismatchWrongSize) {
function TEST_P (line 2638) | TEST_P(ElementsAreTestP, CanExplainMismatchRightSize) {
function TEST (line 2651) | TEST(ElementsAreTest, MatchesOneElementVector) {
function TEST (line 2658) | TEST(ElementsAreTest, MatchesOneElementList) {
function TEST (line 2665) | TEST(ElementsAreTest, MatchesThreeElementVector) {
function TEST (line 2674) | TEST(ElementsAreTest, MatchesOneElementEqMatcher) {
function TEST (line 2681) | TEST(ElementsAreTest, MatchesOneElementAnyMatcher) {
function TEST (line 2688) | TEST(ElementsAreTest, MatchesOneElementValue) {
function TEST (line 2695) | TEST(ElementsAreTest, MatchesThreeElementsMixedMatchers) {
function TEST (line 2704) | TEST(ElementsAreTest, MatchesTenElementVector) {
function TEST (line 2714) | TEST(ElementsAreTest, DoesNotMatchWrongSize) {
function TEST (line 2723) | TEST(ElementsAreTest, DoesNotMatchWrongValue) {
function TEST (line 2731) | TEST(ElementsAreTest, DoesNotMatchWrongOrder) {
function TEST (line 2742) | TEST(ElementsAreTest, WorksForNestedContainer) {
function TEST (line 2756) | TEST(ElementsAreTest, WorksWithByRefElementMatchers) {
function TEST (line 2764) | TEST(ElementsAreTest, WorksWithContainerPointerUsingPointee) {
function TEST (line 2772) | TEST(ElementsAreTest, WorksWithNativeArrayPassedByReference) {
class NativeArrayPassedAsPointerAndSize (line 2779) | class NativeArrayPassedAsPointerAndSize {
method NativeArrayPassedAsPointerAndSize (line 2781) | NativeArrayPassedAsPointerAndSize() {}
method NativeArrayPassedAsPointerAndSize (line 2786) | NativeArrayPassedAsPointerAndSize(const NativeArrayPassedAsPointer...
method NativeArrayPassedAsPointerAndSize (line 2788) | NativeArrayPassedAsPointerAndSize& operator=(
function TEST (line 2792) | TEST(ElementsAreTest, WorksWithNativeArrayPassedAsPointerAndSize) {
function TEST (line 2803) | TEST(ElementsAreTest, WorksWithTwoDimensionalNativeArray) {
function TEST (line 2812) | TEST(ElementsAreTest, AcceptsStringLiteral) {
function TEST (line 2821) | TEST(ElementsAreTest, AcceptsArrayWithUnknownSize) {
function TEST (line 2834) | TEST(ElementsAreTest, MakesCopyOfArguments) {
function TEST (line 2852) | TEST(ElementsAreArrayTest, CanBeCreatedWithValueArray) {
function TEST (line 2862) | TEST(ElementsAreArrayTest, CanBeCreatedWithArraySize) {
function TEST (line 2873) | TEST(ElementsAreArrayTest, CanBeCreatedWithoutArraySize) {
function TEST (line 2883) | TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherArray) {
function TEST (line 2897) | TEST(ElementsAreArrayTest, CanBeCreatedWithVector) {
function TEST (line 2906) | TEST(ElementsAreArrayTest, TakesInitializerList) {
function TEST (line 2913) | TEST(ElementsAreArrayTest, TakesInitializerListOfCStrings) {
function TEST (line 2920) | TEST(ElementsAreArrayTest, TakesInitializerListOfSameTypedMatchers) {
function TEST (line 2926) | TEST(ElementsAreArrayTest, TakesInitializerListOfDifferentTypedMatch...
function TEST (line 2937) | TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherVector) {
function TEST (line 2948) | TEST(ElementsAreArrayTest, CanBeCreatedWithIteratorRange) {
function TEST (line 2963) | TEST(ElementsAreArrayTest, WorksWithNativeArray) {
function TEST (line 2972) | TEST(ElementsAreArrayTest, SourceLifeSpan) {
function TEST (line 2993) | TEST(ContainsTest, ListMatchesWhenElementIsInContainer) {
function TEST (line 3011) | TEST(ContainsTest, ListDoesNotMatchWhenElementIsNotInContainer) {
function TEST (line 3018) | TEST(ContainsTest, SetMatchesWhenElementIsInContainer) {
function TEST (line 3035) | TEST(ContainsTest, SetDoesNotMatchWhenElementIsNotInContainer) {
function TEST_P (line 3046) | TEST_P(ContainsTestP, ExplainsMatchResultCorrectly) {
function TEST (line 3061) | TEST(ContainsTest, DescribesItselfCorrectly) {
function TEST (line 3069) | TEST(ContainsTest, MapMatchesWhenElementIsInContainer) {
function TEST (line 3085) | TEST(ContainsTest, MapDoesNotMatchWhenElementIsNotInContainer) {
function TEST (line 3092) | TEST(ContainsTest, ArrayMatchesWhenElementIsInContainer) {
function TEST (line 3097) | TEST(ContainsTest, ArrayDoesNotMatchWhenElementIsNotInContainer) {
function TEST (line 3102) | TEST(ContainsTest, AcceptsMatcher) {
function TEST (line 3108) | TEST(ContainsTest, WorksForNativeArrayAsTuple) {
function TEST (line 3115) | TEST(ContainsTest, WorksForTwoDimensionalNativeArray) {
FILE: 3rd/googletest-1.12.1/googlemock/test/gmock-matchers-misc_test.cc
type testing (line 44) | namespace testing {
type gmock_matchers_test (line 45) | namespace gmock_matchers_test {
function TEST (line 48) | TEST(AddressTest, NonConst) {
function TEST (line 63) | TEST(AddressTest, Const) {
function TEST (line 74) | TEST(AddressTest, MatcherDoesntCopy) {
function TEST (line 81) | TEST(AddressTest, Describe) {
class NotCopyable (line 92) | class NotCopyable {
method NotCopyable (line 94) | explicit NotCopyable(int a_value) : value_(a_value) {}
method value (line 96) | int value() const { return value_; }
method NotCopyable (line 109) | NotCopyable(const NotCopyable&) = delete;
method NotCopyable (line 110) | NotCopyable& operator=(const NotCopyable&) = delete;
function TEST (line 113) | TEST(ByRefTest, AllowsNotCopyableConstValueInMatchers) {
function TEST (line 122) | TEST(ByRefTest, AllowsNotCopyableValueInMatchers) {
function TEST (line 131) | TEST(IsEmptyTest, ImplementsIsEmpty) {
function TEST (line 140) | TEST(IsEmptyTest, WorksWithString) {
function TEST (line 149) | TEST(IsEmptyTest, CanDescribeSelf) {
function TEST (line 155) | TEST(IsEmptyTest, ExplainsResult) {
function TEST (line 163) | TEST(IsEmptyTest, WorksWithMoveOnly) {
function TEST (line 169) | TEST(IsTrueTest, IsTrueIsFalse) {
class ContainerEqTest (line 210) | class ContainerEqTest : public testing::Test {}
function TYPED_TEST (line 218) | TYPED_TEST(ContainerEqTest, EqualsSelf) {
function TYPED_TEST (line 227) | TYPED_TEST(ContainerEqTest, ValueMissing) {
function TYPED_TEST (line 239) | TYPED_TEST(ContainerEqTest, ValueAdded) {
function TYPED_TEST (line 250) | TYPED_TEST(ContainerEqTest, ValueAddedAndRemoved) {
function TYPED_TEST (line 264) | TYPED_TEST(ContainerEqTest, DuplicateDifference) {
function TEST (line 278) | TEST(ContainerEqExtraTest, MultipleValuesMissing) {
function TEST (line 291) | TEST(ContainerEqExtraTest, MultipleValuesAdded) {
function TEST (line 303) | TEST(ContainerEqExtraTest, MultipleValuesAddedAndRemoved) {
function TEST (line 318) | TEST(ContainerEqExtraTest, MultiSetOfIntDuplicateDifference) {
function TEST (line 332) | TEST(ContainerEqExtraTest, WorksForMaps) {
function TEST (line 351) | TEST(ContainerEqExtraTest, WorksForNativeArray) {
function TEST (line 360) | TEST(ContainerEqExtraTest, WorksForTwoDimensionalNativeArray) {
function TEST (line 374) | TEST(ContainerEqExtraTest, WorksForNativeArrayAsTuple) {
function TEST (line 387) | TEST(ContainerEqExtraTest, CopiesNativeArrayParameter) {
class BacktrackingMaxBPMState (line 406) | class BacktrackingMaxBPMState {
method BacktrackingMaxBPMState (line 409) | explicit BacktrackingMaxBPMState(const Graph* g) : graph_(g) {}
method ElementMatcherPairs (line 411) | ElementMatcherPairs Compute() {
method PushMatch (line 428) | void PushMatch(size_t lhs, size_t rhs) {
method PopMatch (line 437) | void PopMatch() {
method RecurseInto (line 444) | bool RecurseInto(size_t irhs) {
function ElementMatcherPairs (line 482) | ElementMatcherPairs FindBacktrackingMaxBPM(const Graph& g) {
class BacktrackingBPMTest (line 486) | class BacktrackingBPMTest : public ::testing::Test {}
class BipartiteTest (line 490) | class BipartiteTest : public ::testing::TestWithParam<size_t> {}
function TEST_P (line 493) | TEST_P(BipartiteTest, Exhaustive) {
class BipartiteNonSquareTest (line 521) | class BipartiteNonSquareTest
function TEST_F (line 524) | TEST_F(BipartiteNonSquareTest, SimpleBacktracking) {
function TEST_P (line 544) | TEST_P(BipartiteNonSquareTest, Exhaustive) {
class BipartiteRandomTest (line 565) | class BipartiteRandomTest
function TEST_P (line 569) | TEST_P(BipartiteRandomTest, LargerNets) {
function TEST (line 601) | TEST(IsReadableTypeNameTest, ReturnsTrueForShortNames) {
function TEST (line 608) | TEST(IsReadableTypeNameTest, ReturnsTrueForLongNonTemplateNonFunctio...
function TEST (line 614) | TEST(IsReadableTypeNameTest, ReturnsFalseForLongTemplateNames) {
function TEST (line 620) | TEST(IsReadableTypeNameTest, ReturnsFalseForLongFunctionTypeNames) {
function TEST (line 626) | TEST(FormatMatcherDescriptionTest, WorksForEmptyDescription) {
function TEST_P (line 642) | TEST_P(MatcherTupleTestP, ExplainsMatchFailure) {
class SampleOptional (line 674) | class SampleOptional {
method SampleOptional (line 677) | explicit SampleOptional(T value)
method SampleOptional (line 679) | SampleOptional() : value_(), has_value_(false) {}
method T (line 681) | const T& operator*() const { return value_; }
function TEST (line 688) | TEST(OptionalTest, DescribesSelf) {
function TEST (line 693) | TEST(OptionalTest, ExplainsSelf) {
function TEST (line 699) | TEST(OptionalTest, MatchesNonEmptyOptional) {
function TEST (line 709) | TEST(OptionalTest, DoesNotMatchNullopt) {
function TEST (line 715) | TEST(OptionalTest, WorksWithMoveOnly) {
class SampleVariantIntString (line 720) | class SampleVariantIntString {
method SampleVariantIntString (line 722) | SampleVariantIntString(int i) : i_(i), has_int_(true) {}
method SampleVariantIntString (line 723) | SampleVariantIntString(const std::string& s) : s_(s), has_int_(fal...
method holds_alternative (line 726) | bool holds_alternative(const SampleVariantIntString& value) {
method T (line 731) | const T& get(const SampleVariantIntString& value) {
function TEST (line 744) | TEST(VariantTest, DescribesSelf) {
function TEST (line 750) | TEST(VariantTest, ExplainsSelf) {
function TEST (line 760) | TEST(VariantTest, FullMatch) {
function TEST (line 768) | TEST(VariantTest, TypeDoesNotMatch) {
function TEST (line 776) | TEST(VariantTest, InnerDoesNotMatch) {
class SampleAnyType (line 784) | class SampleAnyType {
method SampleAnyType (line 786) | explicit SampleAnyType(int i) : index_(0), i_(i) {}
method SampleAnyType (line 787) | explicit SampleAnyType(const std::string& s) : index_(1), s_(s) {}
method T (line 790) | const T* any_cast(const SampleAnyType* any) {
function TEST (line 805) | TEST(AnyWithTest, FullMatch) {
function TEST (line 810) | TEST(AnyWithTest, TestBadCastType) {
function TEST (line 815) | TEST(AnyWithTest, TestUseInContainers) {
function TEST (line 831) | TEST(AnyWithTest, TestCompare) {
function TEST (line 835) | TEST(AnyWithTest, DescribesSelf) {
function TEST (line 841) | TEST(AnyWithTest, ExplainsSelf) {
function TEST (line 852) | TEST(ArgsTest, AcceptsZeroTemplateArg) {
function TEST (line 858) | TEST(ArgsTest, AcceptsOneTemplateArg) {
function TEST (line 865) | TEST(ArgsTest, AcceptsTwoTemplateArgs) {
function TEST (line 873) | TEST(ArgsTest, AcceptsRepeatedTemplateArgs) {
function TEST (line 879) | TEST(ArgsTest, AcceptsDecreasingTemplateArgs) {
function TEST (line 889) | TEST(ArgsTest, AcceptsMoreTemplateArgsThanArityOfOriginalTuple) {
function TEST (line 894) | TEST(ArgsTest, CanBeNested) {
function TEST (line 900) | TEST(ArgsTest, CanMatchTupleByValue) {
function TEST (line 907) | TEST(ArgsTest, CanMatchTupleByReference) {
function TEST (line 917) | TEST(ArgsTest, AcceptsTenTemplateArgs) {
function TEST (line 926) | TEST(ArgsTest, DescirbesSelfCorrectly) {
function TEST (line 934) | TEST(ArgsTest, DescirbesNestedArgsCorrectly) {
function TEST (line 943) | TEST(ArgsTest, DescribesNegationCorrectly) {
function TEST (line 951) | TEST(ArgsTest, ExplainsMatchResultWithoutInnerExplanation) {
class LessThanMatcher (line 960) | class LessThanMatcher : public MatcherInterface<std::tuple<char, int...
method DescribeTo (line 962) | void DescribeTo(::std::ostream* /*os*/) const override {}
method MatchAndExplain (line 964) | bool MatchAndExplain(std::tuple<char, int> value,
function LessThan (line 975) | Matcher<std::tuple<char, int>> LessThan() {
function TEST (line 979) | TEST(ArgsTest, ExplainsMatchResultWithInnerExplanation) {
function TEST (line 995) | TEST(MatcherMacroTest, Works) {
function TEST (line 1039) | TEST(MatcherMacroTest, DescriptionCanReferenceNegationAndParameters) {
function TEST (line 1050) | TEST(MatcherMacroTest, CanExplainMatchResult) {
function TEST (line 1073) | TEST(MatcherMacroTest, CanReferenceArgType) {
type matcher_test (line 1083) | namespace matcher_test {
function TEST (line 1087) | TEST(MatcherMacroTest, WorksInNamespace) {
function TEST (line 1098) | TEST(MatcherMacroTest, CanBeComposedUsingValue) {
function TEST (line 1108) | TEST(MatcherPMacroTest, Works) {
function TEST (line 1122) | TEST(MatcherPMacroTest, GeneratesCorrectDescription) {
class UncopyableFoo (line 1134) | class UncopyableFoo {
method UncopyableFoo (line 1136) | explicit UncopyableFoo(char value) : value_(value) { (void)value_; }
method UncopyableFoo (line 1138) | UncopyableFoo(const UncopyableFoo&) = delete;
function TEST (line 1147) | TEST(MatcherPMacroTest, WorksWhenExplicitlyInstantiatedWithReference) {
function TEST (line 1173) | TEST(MatcherPnMacroTest, CanReferenceParamTypes) {
function TEST (line 1184) | TEST(MatcherPnMacroTest, WorksWhenExplicitlyInstantiatedWithReferenc...
function TEST (line 1201) | TEST(MatcherPnMacroTest,
function TEST (line 1221) | TEST(MatcherPnMacroTest, Works) {
function TEST (line 1258) | TEST(MatcherPnMacroTest, CanBeOverloadedOnNumberOfParameters) {
function TEST (line 1298) | TEST(MatcherPnMacroTest, WorksForDifferentParameterTypes) {
function TEST (line 1315) | TEST(MatcherPnMacroTest, SimpleTypePromotion) {
function TEST (line 1326) | TEST(MatcherPnMacroTest, TypesAreCorrect) {
function TEST (line 1376) | TEST(MatcherPnMacroTest, CanUseMatcherTypedParameterInValue) {
function TEST (line 1385) | TEST(ContainsTimes, ListMatchesWhenElementQuantityMatches) {
function TEST_P (line 1404) | TEST_P(ContainsTimesP, ExplainsMatchResultCorrectly) {
function TEST (line 1444) | TEST(ContainsTimes, DescribesItselfCorrectly) {
function TEST (line 1456) | TEST(AllOfArrayTest, BasicForms) {
function TEST (line 1498) | TEST(AllOfArrayTest, Matchers) {
function TEST (line 1511) | TEST(AnyOfArrayTest, BasicForms) {
function TEST (line 1551) | TEST(AnyOfArrayTest, Matchers) {
function TEST_P (line 1563) | TEST_P(AnyOfArrayTestP, ExplainsMatchResultCorrectly) {
function TEST (line 1602) | TEST(MatcherMacroTest, WorksOnMoveOnlyType) {
function TEST (line 1612) | TEST(MatcherPMacroTest, WorksOnMoveOnlyType) {
function TEST (line 1624) | TEST(ThrowsTest, Examples) {
function TEST (line 1634) | TEST(ThrowsTest, PrintsExceptionWhat) {
function TEST (line 1640) | TEST(ThrowsTest, DoesNotGenerateDuplicateCatchClauseWarning) {
function TEST (line 1645) | TEST(ThrowsTest, CallableExecutedExactlyOnce) {
function TEST (line 1678) | TEST(ThrowsTest, Describe) {
function TEST (line 1686) | TEST(ThrowsTest, Success) {
function TEST (line 1694) | TEST(ThrowsTest, FailWrongType) {
function TEST (line 1703) | TEST(ThrowsTest, FailWrongTypeNonStd) {
function TEST (line 1711) | TEST(ThrowsTest, FailNoThrow) {
class ThrowsPredicateTest (line 1718) | class ThrowsPredicateTest
function TEST_P (line 1721) | TEST_P(ThrowsPredicateTest, Describe) {
function TEST_P (line 1730) | TEST_P(ThrowsPredicateTest, Success) {
function TEST_P (line 1738) | TEST_P(ThrowsPredicateTest, FailWrongType) {
function TEST_P (line 1747) | TEST_P(ThrowsPredicateTest, FailWrongTypeNonStd) {
function TEST_P (line 1755) | TEST_P(ThrowsPredicateTest, FailNoThrow) {
function TEST (line 1768) | TEST(ThrowsPredicateCompilesTest, ExceptionMatcherAcceptsBroadType) {
function TEST (line 1788) | TEST(ThrowsPredicateCompilesTest, MessageMatcherAcceptsNonMatcher) {
FILE: 3rd/googletest-1.12.1/googlemock/test/gmock-matchers_test.h
function namespace (line 66) | namespace testing {
FILE: 3rd/googletest-1.12.1/googlemock/test/gmock-more-actions_test.cc
type testing (line 50) | namespace testing {
type gmock_more_actions_test (line 51) | namespace gmock_more_actions_test {
function Short (line 68) | inline short Short(short n) { return n; }
function Char (line 69) | inline char Char(char ch) { return ch; }
function Nullary (line 72) | int Nullary() { return 1; }
function Unary (line 76) | bool Unary(int x) { return x < 0; }
function ByConstRef (line 78) | bool ByConstRef(const std::string& s) { return s == "Hi"; }
function ReferencesGlobalDouble (line 81) | bool ReferencesGlobalDouble(const double& x) { return &x == &g_doubl...
type UnaryFunctor (line 83) | struct UnaryFunctor {
function Ternary (line 89) | int Ternary(int x, char y, short z) { return x + y + z; }
function SumOf4 (line 91) | int SumOf4(int a, int b, int c, int d) { return a + b + c + d; }
function SumOfFirst2 (line 93) | int SumOfFirst2(int a, int b, Unused, Unused) { return a + b; }
function SumOf5 (line 95) | int SumOf5(int a, int b, int c, int d, int e) { return a + b + c + d...
type SumOf5Functor (line 97) | struct SumOf5Functor {
function SumOf6 (line 103) | int SumOf6(int a, int b, int c, int d, int e, int f) {
type SumOf6Functor (line 107) | struct SumOf6Functor {
function Concat7 (line 113) | std::string Concat7(const char* s1, const char* s2, const char* s3,
function Concat8 (line 119) | std::string Concat8(const char* s1, const char* s2, const char* s3,
function Concat9 (line 125) | std::string Concat9(const char* s1, const char* s2, const char* s3,
function Concat10 (line 131) | std::string Concat10(const char* s1, const char* s2, const char* s3,
class Foo (line 138) | class Foo {
method Foo (line 140) | Foo() : value_(123) {}
method Nullary (line 142) | int Nullary() const { return value_; }
method Unary (line 144) | short Unary(long x) { return static_cast<short>(value_ + x); }
method Binary (line 146) | std::string Binary(const std::string& str, char c) const { return ...
method Ternary (line 148) | int Ternary(int x, bool y, char z) { return value_ + x + y * z; }
method SumOf4 (line 150) | int SumOf4(int a, int b, int c, int d) const {
method SumOfL
Condensed preview — 445 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (5,181K chars).
[
{
"path": ".dockerignore",
"chars": 48,
"preview": "# IDE\n.vscode/\n.idea/\n\n.DS_Store\n\n/bin\n/cmake*/\n"
},
{
"path": ".editorconfig",
"chars": 200,
"preview": "# EditorConfig is awesome: https://EditorConfig.org\n\nroot = true\n\n[*]\ncharset = utf-8\nend_of_line = lf\ntrim_trailing_whi"
},
{
"path": ".gitignore",
"chars": 307,
"preview": ".vs/\n.idea/\n.vscode/\n\n/cmake-build*\n\n# Prerequisites\n*.d\n\n# Compiled Object files\n*.slo\n*.lo\n*.o\n*.obj\n\n# Precompiled He"
},
{
"path": "3rd/benchmark-1.8.2/.clang-format",
"chars": 74,
"preview": "---\nLanguage: Cpp\nBasedOnStyle: Google\nPointerAlignment: Left\n...\n"
},
{
"path": "3rd/benchmark-1.8.2/.clang-tidy",
"chars": 250,
"preview": "---\nChecks: 'clang-analyzer-*,readability-redundant-*,performance-*'\nWarningsAsErrors: 'clang-analyzer-*,readab"
},
{
"path": "3rd/benchmark-1.8.2/.github/ISSUE_TEMPLATE/bug_report.md",
"chars": 637,
"preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: \"[BUG]\"\nlabels: ''\nassignees: ''\n\n---\n\n**Describe "
},
{
"path": "3rd/benchmark-1.8.2/.github/ISSUE_TEMPLATE/feature_request.md",
"chars": 599,
"preview": "---\nname: Feature request\nabout: Suggest an idea for this project\ntitle: \"[FR]\"\nlabels: ''\nassignees: ''\n\n---\n\n**Is your"
},
{
"path": "3rd/benchmark-1.8.2/.github/install_bazel.sh",
"chars": 424,
"preview": "if ! bazel version; then\n arch=$(uname -m)\n if [ \"$arch\" == \"aarch64\" ]; then\n arch=\"arm64\"\n fi\n echo \"Installing"
},
{
"path": "3rd/benchmark-1.8.2/.github/libcxx-setup.sh",
"chars": 860,
"preview": "#!/usr/bin/env bash\n\nset -e\n\n# Checkout LLVM sources\ngit clone --depth=1 https://github.com/llvm/llvm-project.git llvm-p"
},
{
"path": "3rd/benchmark-1.8.2/.github/workflows/bazel.yml",
"chars": 968,
"preview": "name: bazel\n\non:\n push: {}\n pull_request: {}\n\njobs:\n build_and_test_default:\n name: bazel.${{ matrix.os }}.${{ mat"
},
{
"path": "3rd/benchmark-1.8.2/.github/workflows/build-and-test-min-cmake.yml",
"chars": 1134,
"preview": "name: build-and-test-min-cmake\n\non:\n push:\n branches: [ main ]\n pull_request:\n branches: [ main ]\n\njobs:\n job:\n"
},
{
"path": "3rd/benchmark-1.8.2/.github/workflows/build-and-test-perfcounters.yml",
"chars": 1456,
"preview": "name: build-and-test-perfcounters\n\non:\n push:\n branches: [ main ]\n pull_request:\n branches: [ main ]\n\njobs:\n jo"
},
{
"path": "3rd/benchmark-1.8.2/.github/workflows/build-and-test.yml",
"chars": 3376,
"preview": "name: build-and-test\n\non:\n push:\n branches: [ main ]\n pull_request:\n branches: [ main ]\n\njobs:\n # TODO: add 32-"
},
{
"path": "3rd/benchmark-1.8.2/.github/workflows/clang-format-lint.yml",
"chars": 338,
"preview": "name: clang-format-lint\non:\n push: {}\n pull_request: {}\n\njobs:\n build:\n runs-on: ubuntu-latest\n\n steps:\n - u"
},
{
"path": "3rd/benchmark-1.8.2/.github/workflows/clang-tidy.yml",
"chars": 939,
"preview": "name: clang-tidy\n\non:\n push: {}\n pull_request: {}\n\njobs:\n job:\n name: run-clang-tidy\n runs-on: ubuntu-latest\n "
},
{
"path": "3rd/benchmark-1.8.2/.github/workflows/doxygen.yml",
"chars": 682,
"preview": "name: doxygen\n\non:\n push:\n branches: [main]\n pull_request:\n branches: [main]\n\njobs:\n build-and-deploy:\n name"
},
{
"path": "3rd/benchmark-1.8.2/.github/workflows/pylint.yml",
"chars": 517,
"preview": "name: pylint\n\non:\n push:\n branches: [ main ]\n pull_request:\n branches: [ main ]\n\njobs:\n pylint:\n\n runs-on: u"
},
{
"path": "3rd/benchmark-1.8.2/.github/workflows/sanitizer.yml",
"chars": 3236,
"preview": "name: sanitizer\n\non:\n push: {}\n pull_request: {}\n\nenv:\n UBSAN_OPTIONS: \"print_stacktrace=1\"\n\njobs:\n job:\n name: $"
},
{
"path": "3rd/benchmark-1.8.2/.github/workflows/test_bindings.yml",
"chars": 713,
"preview": "name: test-bindings\n\non:\n push:\n branches: [main]\n pull_request:\n branches: [main]\n\njobs:\n python_bindings:\n "
},
{
"path": "3rd/benchmark-1.8.2/.github/workflows/wheels.yml",
"chars": 2084,
"preview": "name: Build and upload Python wheels\n\non:\n workflow_dispatch:\n release:\n types:\n - published\n\njobs:\n build_sd"
},
{
"path": "3rd/benchmark-1.8.2/.gitignore",
"chars": 763,
"preview": "*.a\n*.so\n*.so.?*\n*.dll\n*.exe\n*.dylib\n*.cmake\n!/cmake/*.cmake\n!/test/AssemblyTests.cmake\n*~\n*.swp\n*.pyc\n__pycache__\n.DS_S"
},
{
"path": "3rd/benchmark-1.8.2/.travis.yml",
"chars": 6851,
"preview": "sudo: required\ndist: trusty\nlanguage: cpp\n\nmatrix:\n include:\n - compiler: gcc\n addons:\n apt:\n p"
},
{
"path": "3rd/benchmark-1.8.2/.ycm_extra_conf.py",
"chars": 3640,
"preview": "import os\nimport ycm_core\n\n# These are the compilation flags that will be used in case there's no\n# compilation database"
},
{
"path": "3rd/benchmark-1.8.2/AUTHORS",
"chars": 2595,
"preview": "# This is the official list of benchmark authors for copyright purposes.\n# This file is distinct from the CONTRIBUTORS f"
},
{
"path": "3rd/benchmark-1.8.2/BUILD.bazel",
"chars": 2102,
"preview": "licenses([\"notice\"])\n\nconfig_setting(\n name = \"qnx\",\n constraint_values = [\"@platforms//os:qnx\"],\n values = {\n "
},
{
"path": "3rd/benchmark-1.8.2/CMakeLists.txt",
"chars": 13449,
"preview": "# Require CMake 3.10. If available, use the policies up to CMake 3.22.\ncmake_minimum_required (VERSION 3.10...3.22)\n\npro"
},
{
"path": "3rd/benchmark-1.8.2/CONTRIBUTING.md",
"chars": 2485,
"preview": "# How to contribute #\n\nWe'd love to accept your patches and contributions to this project. There are\na just a few small"
},
{
"path": "3rd/benchmark-1.8.2/CONTRIBUTORS",
"chars": 3792,
"preview": "# People who have agreed to one of the CLAs and can contribute patches.\n# The AUTHORS file lists the copyright holders; "
},
{
"path": "3rd/benchmark-1.8.2/LICENSE",
"chars": 11358,
"preview": "\n Apache License\n Version 2.0, January 2004\n "
},
{
"path": "3rd/benchmark-1.8.2/MODULE.bazel",
"chars": 1484,
"preview": "module(name = \"com_github_google_benchmark\", version=\"1.8.2\")\n\nbazel_dep(name = \"bazel_skylib\", version = \"1.4.1\")\nbazel"
},
{
"path": "3rd/benchmark-1.8.2/README.md",
"chars": 7817,
"preview": "# Benchmark\n\n[](https://github."
},
{
"path": "3rd/benchmark-1.8.2/WORKSPACE",
"chars": 586,
"preview": "workspace(name = \"com_github_google_benchmark\")\n\nload(\"//:bazel/benchmark_deps.bzl\", \"benchmark_deps\")\n\nbenchmark_deps()"
},
{
"path": "3rd/benchmark-1.8.2/WORKSPACE.bzlmod",
"chars": 98,
"preview": "# This file marks the root of the Bazel workspace.\n# See MODULE.bazel for dependencies and setup.\n"
},
{
"path": "3rd/benchmark-1.8.2/_config.yml",
"chars": 43,
"preview": "theme: jekyll-theme-midnight\nmarkdown: GFM\n"
},
{
"path": "3rd/benchmark-1.8.2/appveyor.yml",
"chars": 1266,
"preview": "version: '{build}'\n\nimage: Visual Studio 2017\n\nconfiguration:\n - Debug\n - Release\n\nenvironment:\n matrix:\n - compil"
},
{
"path": "3rd/benchmark-1.8.2/bazel/benchmark_deps.bzl",
"chars": 2972,
"preview": "load(\"@bazel_tools//tools/build_defs/repo:http.bzl\", \"http_archive\")\nload(\"@bazel_tools//tools/build_defs/repo:git.bzl\","
},
{
"path": "3rd/benchmark-1.8.2/bindings/python/BUILD",
"chars": 68,
"preview": "exports_files(glob([\"*.BUILD\"]))\nexports_files([\"build_defs.bzl\"])\n\n"
},
{
"path": "3rd/benchmark-1.8.2/bindings/python/build_defs.bzl",
"chars": 743,
"preview": "_SHARED_LIB_SUFFIX = {\n \"//conditions:default\": \".so\",\n \"//:windows\": \".dll\",\n}\n\ndef py_extension(name, srcs, hdrs"
},
{
"path": "3rd/benchmark-1.8.2/bindings/python/google_benchmark/BUILD",
"chars": 744,
"preview": "load(\"//bindings/python:build_defs.bzl\", \"py_extension\")\n\npy_library(\n name = \"google_benchmark\",\n srcs = [\"__init"
},
{
"path": "3rd/benchmark-1.8.2/bindings/python/google_benchmark/__init__.py",
"chars": 4463,
"preview": "# Copyright 2020 Google Inc. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# "
},
{
"path": "3rd/benchmark-1.8.2/bindings/python/google_benchmark/benchmark.cc",
"chars": 7662,
"preview": "// Benchmark for Python.\n\n#include \"benchmark/benchmark.h\"\n\n#include \"nanobind/nanobind.h\"\n#include \"nanobind/operators."
},
{
"path": "3rd/benchmark-1.8.2/bindings/python/google_benchmark/example.py",
"chars": 3858,
"preview": "# Copyright 2020 Google Inc. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# "
},
{
"path": "3rd/benchmark-1.8.2/bindings/python/nanobind.BUILD",
"chars": 1573,
"preview": "\nconfig_setting(\n name = \"msvc_compiler\",\n flag_values = {\"@bazel_tools//tools/cpp:compiler\": \"msvc-cl\"},\n)\n\ncc_li"
},
{
"path": "3rd/benchmark-1.8.2/bindings/python/python_headers.BUILD",
"chars": 136,
"preview": "cc_library(\n name = \"python_headers\",\n hdrs = glob([\"**/*.h\"]),\n includes = [\".\"],\n visibility = [\"//visibil"
},
{
"path": "3rd/benchmark-1.8.2/bindings/python/requirements.txt",
"chars": 16,
"preview": "absl-py>=0.7.1\n\n"
},
{
"path": "3rd/benchmark-1.8.2/cmake/Config.cmake.in",
"chars": 144,
"preview": "@PACKAGE_INIT@\n\ninclude (CMakeFindDependencyMacro)\n\nfind_dependency (Threads)\n\ninclude(\"${CMAKE_CURRENT_LIST_DIR}/@targe"
},
{
"path": "3rd/benchmark-1.8.2/cmake/GoogleTest.cmake.in",
"chars": 2661,
"preview": "cmake_minimum_required(VERSION 2.8.12)\n\nproject(googletest-download NONE)\n\n# Enable ExternalProject CMake module\ninclude"
},
{
"path": "3rd/benchmark-1.8.2/cmake/benchmark.pc.in",
"chars": 295,
"preview": "prefix=@CMAKE_INSTALL_PREFIX@\nexec_prefix=${prefix}\nlibdir=@CMAKE_INSTALL_FULL_LIBDIR@\nincludedir=@CMAKE_INSTALL_FULL_IN"
},
{
"path": "3rd/benchmark-1.8.2/cmake/gnu_posix_regex.cpp",
"chars": 267,
"preview": "#include <gnuregex.h>\n#include <string>\nint main() {\n std::string str = \"test0159\";\n regex_t re;\n int ec = regcomp(&r"
},
{
"path": "3rd/benchmark-1.8.2/cmake/posix_regex.cpp",
"chars": 297,
"preview": "#include <regex.h>\n#include <string>\nint main() {\n std::string str = \"test0159\";\n regex_t re;\n int ec = regcomp(&re, "
},
{
"path": "3rd/benchmark-1.8.2/cmake/pthread_affinity.cpp",
"chars": 389,
"preview": "#include <pthread.h>\nint main() {\n cpu_set_t set;\n CPU_ZERO(&set);\n for (int i = 0; i < CPU_SETSIZE; ++i) {\n CPU_S"
},
{
"path": "3rd/benchmark-1.8.2/cmake/std_regex.cpp",
"chars": 259,
"preview": "#include <regex>\n#include <string>\nint main() {\n const std::string str = \"test0159\";\n std::regex re;\n re = std::regex"
},
{
"path": "3rd/benchmark-1.8.2/cmake/steady_clock.cpp",
"chars": 136,
"preview": "#include <chrono>\n\nint main() {\n typedef std::chrono::steady_clock Clock;\n Clock::time_point tp = Clock::now();\n "
},
{
"path": "3rd/benchmark-1.8.2/cmake/thread_safety_attributes.cpp",
"chars": 79,
"preview": "#define HAVE_THREAD_SAFETY_ATTRIBUTES\n#include \"../src/mutex.h\"\n\nint main() {}\n"
},
{
"path": "3rd/benchmark-1.8.2/docs/AssemblyTests.md",
"chars": 5324,
"preview": "# Assembly Tests\n\nThe Benchmark library provides a number of functions whose primary\npurpose in to affect assembly gener"
},
{
"path": "3rd/benchmark-1.8.2/docs/_config.yml",
"chars": 28,
"preview": "theme: jekyll-theme-minimal\n"
},
{
"path": "3rd/benchmark-1.8.2/docs/dependencies.md",
"chars": 543,
"preview": "# Build tool dependency policy\n\nWe follow the [Foundational C++ support policy](https://opensource.google/documentation/"
},
{
"path": "3rd/benchmark-1.8.2/docs/index.md",
"chars": 412,
"preview": "# Benchmark\n\n* [Assembly Tests](AssemblyTests.md)\n* [Dependencies](dependencies.md)\n* [Perf Counters](perf_counters.md)\n"
},
{
"path": "3rd/benchmark-1.8.2/docs/perf_counters.md",
"chars": 1567,
"preview": "<a name=\"perf-counters\" />\n\n# User-Requested Performance Counters\n\nWhen running benchmarks, the user may choose to reque"
},
{
"path": "3rd/benchmark-1.8.2/docs/platform_specific_build_instructions.md",
"chars": 1997,
"preview": "# Platform Specific Build Instructions\n\n## Building with GCC\n\nWhen the library is built using GCC it is necessary to lin"
},
{
"path": "3rd/benchmark-1.8.2/docs/python_bindings.md",
"chars": 1442,
"preview": "# Building and installing Python bindings\n\nPython bindings are available as wheels on [PyPI](https://pypi.org/project/go"
},
{
"path": "3rd/benchmark-1.8.2/docs/random_interleaving.md",
"chars": 647,
"preview": "<a name=\"interleaving\" />\n\n# Random Interleaving\n\n[Random Interleaving](https://github.com/google/benchmark/issues/1051)"
},
{
"path": "3rd/benchmark-1.8.2/docs/reducing_variance.md",
"chars": 3701,
"preview": "# Reducing Variance\n\n<a name=\"disabling-cpu-frequency-scaling\" />\n\n## Disabling CPU Frequency Scaling\n\nIf you see this e"
},
{
"path": "3rd/benchmark-1.8.2/docs/releasing.md",
"chars": 1351,
"preview": "# How to release\n\n* Make sure you're on main and synced to HEAD\n* Ensure the project builds and tests run\n * `paralle"
},
{
"path": "3rd/benchmark-1.8.2/docs/tools.md",
"chars": 12475,
"preview": "# Benchmark Tools\n\n## compare.py\n\nThe `compare.py` can be used to compare the result of benchmarks.\n\n### Dependencies\nTh"
},
{
"path": "3rd/benchmark-1.8.2/docs/user_guide.md",
"chars": 43746,
"preview": "# User Guide\n\n## Command Line\n\n[Output Formats](#output-formats)\n\n[Output Files](#output-files)\n\n[Running Benchmarks](#r"
},
{
"path": "3rd/benchmark-1.8.2/include/benchmark/benchmark.h",
"chars": 72385,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/include/benchmark/export.h",
"chars": 1481,
"preview": "#ifndef BENCHMARK_EXPORT_H\n#define BENCHMARK_EXPORT_H\n\n#if defined(_WIN32)\n#define EXPORT_ATTR __declspec(dllexport)\n#de"
},
{
"path": "3rd/benchmark-1.8.2/setup.py",
"chars": 5661,
"preview": "import contextlib\nimport os\nimport platform\nimport shutil\nimport sysconfig\nfrom pathlib import Path\nfrom typing import L"
},
{
"path": "3rd/benchmark-1.8.2/src/CMakeLists.txt",
"chars": 5153,
"preview": "# Allow the source files to find headers in src/\ninclude(GNUInstallDirs)\ninclude_directories(${PROJECT_SOURCE_DIR}/src)\n"
},
{
"path": "3rd/benchmark-1.8.2/src/arraysize.h",
"chars": 1108,
"preview": "#ifndef BENCHMARK_ARRAYSIZE_H_\n#define BENCHMARK_ARRAYSIZE_H_\n\n#include \"internal_macros.h\"\n\nnamespace benchmark {\nnames"
},
{
"path": "3rd/benchmark-1.8.2/src/benchmark.cc",
"chars": 27519,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/benchmark_api_internal.cc",
"chars": 3549,
"preview": "#include \"benchmark_api_internal.h\"\n\n#include <cinttypes>\n\n#include \"string_util.h\"\n\nnamespace benchmark {\nnamespace int"
},
{
"path": "3rd/benchmark-1.8.2/src/benchmark_api_internal.h",
"chars": 2923,
"preview": "#ifndef BENCHMARK_API_INTERNAL_H\n#define BENCHMARK_API_INTERNAL_H\n\n#include <cmath>\n#include <iosfwd>\n#include <limits>\n"
},
{
"path": "3rd/benchmark-1.8.2/src/benchmark_main.cc",
"chars": 702,
"preview": "// Copyright 2018 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/benchmark_name.cc",
"chars": 1715,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/benchmark_register.cc",
"chars": 15312,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/benchmark_register.h",
"chars": 3006,
"preview": "#ifndef BENCHMARK_REGISTER_H\n#define BENCHMARK_REGISTER_H\n\n#include <algorithm>\n#include <limits>\n#include <vector>\n\n#in"
},
{
"path": "3rd/benchmark-1.8.2/src/benchmark_runner.cc",
"chars": 18829,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/benchmark_runner.h",
"chars": 3576,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/check.cc",
"chars": 233,
"preview": "#include \"check.h\"\n\nnamespace benchmark {\nnamespace internal {\n\nstatic AbortHandlerT* handler = &std::abort;\n\nBENCHMARK_"
},
{
"path": "3rd/benchmark-1.8.2/src/check.h",
"chars": 3079,
"preview": "#ifndef CHECK_H_\n#define CHECK_H_\n\n#include <cmath>\n#include <cstdlib>\n#include <ostream>\n\n#include \"benchmark/export.h\""
},
{
"path": "3rd/benchmark-1.8.2/src/colorprint.cc",
"chars": 5396,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/colorprint.h",
"chars": 760,
"preview": "#ifndef BENCHMARK_COLORPRINT_H_\n#define BENCHMARK_COLORPRINT_H_\n\n#include <cstdarg>\n#include <iostream>\n#include <string"
},
{
"path": "3rd/benchmark-1.8.2/src/commandlineflags.cc",
"chars": 9819,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/commandlineflags.h",
"chars": 5044,
"preview": "#ifndef BENCHMARK_COMMANDLINEFLAGS_H_\n#define BENCHMARK_COMMANDLINEFLAGS_H_\n\n#include <cstdint>\n#include <map>\n#include "
},
{
"path": "3rd/benchmark-1.8.2/src/complexity.cc",
"chars": 8459,
"preview": "// Copyright 2016 Ismael Jimenez Martinez. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (th"
},
{
"path": "3rd/benchmark-1.8.2/src/complexity.h",
"chars": 1980,
"preview": "// Copyright 2016 Ismael Jimenez Martinez. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (th"
},
{
"path": "3rd/benchmark-1.8.2/src/console_reporter.cc",
"chars": 7141,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/counter.cc",
"chars": 2129,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/counter.h",
"chars": 1129,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/csv_reporter.cc",
"chars": 4527,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/cycleclock.h",
"chars": 9343,
"preview": "// ----------------------------------------------------------------------\n// CycleClock\n// A CycleClock tells you the"
},
{
"path": "3rd/benchmark-1.8.2/src/internal_macros.h",
"chars": 2978,
"preview": "#ifndef BENCHMARK_INTERNAL_MACROS_H_\n#define BENCHMARK_INTERNAL_MACROS_H_\n\n/* Needed to detect STL */\n#include <cstdlib>"
},
{
"path": "3rd/benchmark-1.8.2/src/json_reporter.cc",
"chars": 10142,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/log.h",
"chars": 2194,
"preview": "#ifndef BENCHMARK_LOG_H_\n#define BENCHMARK_LOG_H_\n\n#include <iostream>\n#include <ostream>\n\n// NOTE: this is also defined"
},
{
"path": "3rd/benchmark-1.8.2/src/mutex.h",
"chars": 4578,
"preview": "#ifndef BENCHMARK_MUTEX_H_\n#define BENCHMARK_MUTEX_H_\n\n#include <condition_variable>\n#include <mutex>\n\n#include \"check.h"
},
{
"path": "3rd/benchmark-1.8.2/src/perf_counters.cc",
"chars": 9276,
"preview": "// Copyright 2021 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/perf_counters.h",
"chars": 6964,
"preview": "// Copyright 2021 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/re.h",
"chars": 3893,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/reporter.cc",
"chars": 3710,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/statistics.cc",
"chars": 7243,
"preview": "// Copyright 2016 Ismael Jimenez Martinez. All rights reserved.\n// Copyright 2017 Roman Lebedev. All rights reserved.\n//"
},
{
"path": "3rd/benchmark-1.8.2/src/statistics.h",
"chars": 1499,
"preview": "// Copyright 2016 Ismael Jimenez Martinez. All rights reserved.\n// Copyright 2017 Roman Lebedev. All rights reserved.\n//"
},
{
"path": "3rd/benchmark-1.8.2/src/string_util.cc",
"chars": 8281,
"preview": "#include \"string_util.h\"\n\n#include <array>\n#ifdef BENCHMARK_STL_ANDROID_GNUSTL\n#include <cerrno>\n#endif\n#include <cmath>"
},
{
"path": "3rd/benchmark-1.8.2/src/string_util.h",
"chars": 2004,
"preview": "#ifndef BENCHMARK_STRING_UTIL_H_\n#define BENCHMARK_STRING_UTIL_H_\n\n#include <sstream>\n#include <string>\n#include <utilit"
},
{
"path": "3rd/benchmark-1.8.2/src/sysinfo.cc",
"chars": 26595,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/thread_manager.h",
"chars": 1599,
"preview": "#ifndef BENCHMARK_THREAD_MANAGER_H\n#define BENCHMARK_THREAD_MANAGER_H\n\n#include <atomic>\n\n#include \"benchmark/benchmark."
},
{
"path": "3rd/benchmark-1.8.2/src/thread_timer.h",
"chars": 2297,
"preview": "#ifndef BENCHMARK_THREAD_TIMER_H\n#define BENCHMARK_THREAD_TIMER_H\n\n#include \"check.h\"\n#include \"timers.h\"\n\nnamespace ben"
},
{
"path": "3rd/benchmark-1.8.2/src/timers.cc",
"chars": 9438,
"preview": "// Copyright 2015 Google Inc. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");"
},
{
"path": "3rd/benchmark-1.8.2/src/timers.h",
"chars": 1132,
"preview": "#ifndef BENCHMARK_TIMERS_H\n#define BENCHMARK_TIMERS_H\n\n#include <chrono>\n#include <string>\n\nnamespace benchmark {\n\n// Re"
},
{
"path": "3rd/benchmark-1.8.2/test/BUILD",
"chars": 2721,
"preview": "load(\"@rules_cc//cc:defs.bzl\", \"cc_library\", \"cc_test\")\n\nplatform(\n name = \"windows\",\n constraint_values = [\n "
},
{
"path": "3rd/benchmark-1.8.2/test/CMakeLists.txt",
"chars": 12724,
"preview": "# Enable the tests\n\nset(THREADS_PREFER_PTHREAD_FLAG ON)\n\nfind_package(Threads REQUIRED)\ninclude(CheckCXXCompilerFlag)\n\n#"
},
{
"path": "3rd/benchmark-1.8.2/test/args_product_test.cc",
"chars": 2229,
"preview": "#include <cassert>\n#include <iostream>\n#include <set>\n#include <vector>\n\n#include \"benchmark/benchmark.h\"\n\nclass ArgsPro"
},
{
"path": "3rd/benchmark-1.8.2/test/basic_test.cc",
"chars": 5341,
"preview": "\n#include \"benchmark/benchmark.h\"\n\n#define BASIC_BENCHMARK_TEST(x) BENCHMARK(x)->Arg(8)->Arg(512)->Arg(8192)\n\nvoid BM_em"
},
{
"path": "3rd/benchmark-1.8.2/test/benchmark_gtest.cc",
"chars": 5001,
"preview": "#include <map>\n#include <string>\n#include <vector>\n\n#include \"../src/benchmark_register.h\"\n#include \"benchmark/benchmark"
},
{
"path": "3rd/benchmark-1.8.2/test/benchmark_min_time_flag_iters_test.cc",
"chars": 1739,
"preview": "#include <cassert>\n#include <cstdlib>\n#include <cstring>\n#include <iostream>\n#include <string>\n#include <vector>\n\n#inclu"
},
{
"path": "3rd/benchmark-1.8.2/test/benchmark_min_time_flag_time_test.cc",
"chars": 2417,
"preview": "#include <cassert>\n#include <climits>\n#include <cmath>\n#include <cstdlib>\n#include <cstring>\n#include <iostream>\n#includ"
},
{
"path": "3rd/benchmark-1.8.2/test/benchmark_name_gtest.cc",
"chars": 2362,
"preview": "#include \"benchmark/benchmark.h\"\n#include \"gtest/gtest.h\"\n\nnamespace {\n\nusing namespace benchmark;\nusing namespace bench"
},
{
"path": "3rd/benchmark-1.8.2/test/benchmark_random_interleaving_gtest.cc",
"chars": 3443,
"preview": "#include <queue>\n#include <string>\n#include <vector>\n\n#include \"../src/commandlineflags.h\"\n#include \"../src/string_util."
},
{
"path": "3rd/benchmark-1.8.2/test/benchmark_setup_teardown_test.cc",
"chars": 4068,
"preview": "#include <atomic>\n#include <cassert>\n#include <cstdlib>\n#include <cstring>\n#include <iostream>\n#include <limits>\n#includ"
},
{
"path": "3rd/benchmark-1.8.2/test/benchmark_test.cc",
"chars": 8006,
"preview": "#include \"benchmark/benchmark.h\"\n\n#include <assert.h>\n#include <math.h>\n#include <stdint.h>\n\n#include <chrono>\n#include "
},
{
"path": "3rd/benchmark-1.8.2/test/clobber_memory_assembly_test.cc",
"chars": 1397,
"preview": "#include <benchmark/benchmark.h>\n\n#ifdef __clang__\n#pragma clang diagnostic ignored \"-Wreturn-type\"\n#endif\nBENCHMARK_DIS"
},
{
"path": "3rd/benchmark-1.8.2/test/commandlineflags_gtest.cc",
"chars": 6306,
"preview": "#include <cstdlib>\n\n#include \"../src/commandlineflags.h\"\n#include \"../src/internal_macros.h\"\n#include \"gmock/gmock.h\"\n#i"
},
{
"path": "3rd/benchmark-1.8.2/test/complexity_test.cc",
"chars": 8720,
"preview": "#undef NDEBUG\n#include <algorithm>\n#include <cassert>\n#include <cmath>\n#include <cstdlib>\n#include <vector>\n\n#include \"b"
},
{
"path": "3rd/benchmark-1.8.2/test/cxx03_test.cc",
"chars": 1613,
"preview": "#undef NDEBUG\n#include <cassert>\n#include <cstddef>\n\n#include \"benchmark/benchmark.h\"\n\n#if __cplusplus >= 201103L\n#error"
},
{
"path": "3rd/benchmark-1.8.2/test/diagnostics_test.cc",
"chars": 2267,
"preview": "// Testing:\n// State::PauseTiming()\n// State::ResumeTiming()\n// Test that CHECK's within these function diagnose whe"
},
{
"path": "3rd/benchmark-1.8.2/test/display_aggregates_only_test.cc",
"chars": 1767,
"preview": "\n#undef NDEBUG\n#include <cstdio>\n#include <string>\n\n#include \"benchmark/benchmark.h\"\n#include \"output_test.h\"\n\n// Ok thi"
},
{
"path": "3rd/benchmark-1.8.2/test/donotoptimize_assembly_test.cc",
"chars": 5294,
"preview": "#include <benchmark/benchmark.h>\n\n#ifdef __clang__\n#pragma clang diagnostic ignored \"-Wreturn-type\"\n#endif\nBENCHMARK_DIS"
},
{
"path": "3rd/benchmark-1.8.2/test/donotoptimize_test.cc",
"chars": 1557,
"preview": "#include <cstdint>\n\n#include \"benchmark/benchmark.h\"\n\nnamespace {\n#if defined(__GNUC__)\nstd::int64_t double_up(const std"
},
{
"path": "3rd/benchmark-1.8.2/test/filter_test.cc",
"chars": 2938,
"preview": "#include <algorithm>\n#include <cassert>\n#include <cmath>\n#include <cstdint>\n#include <cstdlib>\n#include <iostream>\n#incl"
},
{
"path": "3rd/benchmark-1.8.2/test/fixture_test.cc",
"chars": 1214,
"preview": "\n#include <cassert>\n#include <memory>\n\n#include \"benchmark/benchmark.h\"\n\n#define FIXTURE_BECHMARK_NAME MyFixture\n\nclass "
},
{
"path": "3rd/benchmark-1.8.2/test/internal_threading_test.cc",
"chars": 5632,
"preview": "\n#undef NDEBUG\n\n#include <chrono>\n#include <thread>\n\n#include \"../src/timers.h\"\n#include \"benchmark/benchmark.h\"\n#includ"
},
{
"path": "3rd/benchmark-1.8.2/test/link_main_test.cc",
"chars": 211,
"preview": "#include \"benchmark/benchmark.h\"\n\nvoid BM_empty(benchmark::State& state) {\n for (auto _ : state) {\n auto iterations "
},
{
"path": "3rd/benchmark-1.8.2/test/map_test.cc",
"chars": 1490,
"preview": "#include <cstdlib>\n#include <map>\n\n#include \"benchmark/benchmark.h\"\n\nnamespace {\n\nstd::map<int, int> ConstructRandomMap("
},
{
"path": "3rd/benchmark-1.8.2/test/memory_manager_test.cc",
"chars": 1734,
"preview": "#include <memory>\n\n#include \"../src/check.h\"\n#include \"benchmark/benchmark.h\"\n#include \"output_test.h\"\n\nclass TestMemory"
},
{
"path": "3rd/benchmark-1.8.2/test/min_time_parse_gtest.cc",
"chars": 951,
"preview": "#include \"../src/benchmark_runner.h\"\n#include \"gtest/gtest.h\"\n\nnamespace {\n\nTEST(ParseMinTimeTest, InvalidInput) {\n#if G"
},
{
"path": "3rd/benchmark-1.8.2/test/multiple_ranges_test.cc",
"chars": 2741,
"preview": "#include <cassert>\n#include <iostream>\n#include <set>\n#include <vector>\n\n#include \"benchmark/benchmark.h\"\n\nclass Multipl"
},
{
"path": "3rd/benchmark-1.8.2/test/options_test.cc",
"chars": 2336,
"preview": "#include <chrono>\n#include <thread>\n\n#include \"benchmark/benchmark.h\"\n\n#if defined(NDEBUG)\n#undef NDEBUG\n#endif\n#include"
},
{
"path": "3rd/benchmark-1.8.2/test/output_test.h",
"chars": 7935,
"preview": "#ifndef TEST_OUTPUT_TEST_H\n#define TEST_OUTPUT_TEST_H\n\n#undef NDEBUG\n#include <functional>\n#include <initializer_list>\n#"
},
{
"path": "3rd/benchmark-1.8.2/test/output_test_helper.cc",
"chars": 17928,
"preview": "#include <cstdio>\n#include <cstring>\n#include <fstream>\n#include <iostream>\n#include <map>\n#include <memory>\n#include <r"
},
{
"path": "3rd/benchmark-1.8.2/test/perf_counters_gtest.cc",
"chars": 11796,
"preview": "#include <random>\n#include <thread>\n\n#include \"../src/perf_counters.h\"\n#include \"gtest/gtest.h\"\n\n#ifndef GTEST_SKIP\nstru"
},
{
"path": "3rd/benchmark-1.8.2/test/perf_counters_test.cc",
"chars": 698,
"preview": "#undef NDEBUG\n\n#include \"../src/perf_counters.h\"\n\n#include \"benchmark/benchmark.h\"\n#include \"output_test.h\"\n\nstatic void"
},
{
"path": "3rd/benchmark-1.8.2/test/register_benchmark_test.cc",
"chars": 6052,
"preview": "\n#undef NDEBUG\n#include <cassert>\n#include <vector>\n\n#include \"../src/check.h\" // NOTE: check.h is for internal use onl"
},
{
"path": "3rd/benchmark-1.8.2/test/repetitions_test.cc",
"chars": 11594,
"preview": "\n#include \"benchmark/benchmark.h\"\n#include \"output_test.h\"\n\n// ========================================================="
},
{
"path": "3rd/benchmark-1.8.2/test/report_aggregates_only_test.cc",
"chars": 1506,
"preview": "\n#undef NDEBUG\n#include <cstdio>\n#include <string>\n\n#include \"benchmark/benchmark.h\"\n#include \"output_test.h\"\n\n// Ok thi"
},
{
"path": "3rd/benchmark-1.8.2/test/reporter_output_test.cc",
"chars": 56940,
"preview": "\n#undef NDEBUG\n#include <numeric>\n#include <utility>\n\n#include \"benchmark/benchmark.h\"\n#include \"output_test.h\"\n\n// ===="
},
{
"path": "3rd/benchmark-1.8.2/test/skip_with_error_test.cc",
"chars": 6646,
"preview": "\n#undef NDEBUG\n#include <cassert>\n#include <vector>\n\n#include \"../src/check.h\" // NOTE: check.h is for internal use onl"
},
{
"path": "3rd/benchmark-1.8.2/test/spec_arg_test.cc",
"chars": 2884,
"preview": "#include <algorithm>\n#include <cassert>\n#include <cstdint>\n#include <cstdlib>\n#include <cstring>\n#include <iostream>\n#in"
},
{
"path": "3rd/benchmark-1.8.2/test/spec_arg_verbosity_test.cc",
"chars": 1059,
"preview": "#include <string.h>\n\n#include <iostream>\n\n#include \"benchmark/benchmark.h\"\n\n// Tests that the user specified verbosity l"
},
{
"path": "3rd/benchmark-1.8.2/test/state_assembly_test.cc",
"chars": 1793,
"preview": "#include <benchmark/benchmark.h>\n\n#ifdef __clang__\n#pragma clang diagnostic ignored \"-Wreturn-type\"\n#endif\n\n// clang-for"
},
{
"path": "3rd/benchmark-1.8.2/test/statistics_gtest.cc",
"chars": 1364,
"preview": "//===---------------------------------------------------------------------===//\n// statistics_test - Unit tests for src/"
},
{
"path": "3rd/benchmark-1.8.2/test/string_util_gtest.cc",
"chars": 3761,
"preview": "//===---------------------------------------------------------------------===//\n// statistics_test - Unit tests for src/"
},
{
"path": "3rd/benchmark-1.8.2/test/templated_fixture_test.cc",
"chars": 482,
"preview": "\n#include <cassert>\n#include <memory>\n\n#include \"benchmark/benchmark.h\"\n\ntemplate <typename T>\nclass MyFixture : public "
},
{
"path": "3rd/benchmark-1.8.2/test/time_unit_gtest.cc",
"chars": 872,
"preview": "#include \"../include/benchmark/benchmark.h\"\n#include \"gtest/gtest.h\"\n\nnamespace benchmark {\nnamespace internal {\n\nnamesp"
},
{
"path": "3rd/benchmark-1.8.2/test/user_counters_tabular_test.cc",
"chars": 28444,
"preview": "\n#undef NDEBUG\n\n#include \"benchmark/benchmark.h\"\n#include \"output_test.h\"\n\n// @todo: <jpmag> this checks the full output"
},
{
"path": "3rd/benchmark-1.8.2/test/user_counters_test.cc",
"chars": 26624,
"preview": "\n#undef NDEBUG\n\n#include \"benchmark/benchmark.h\"\n#include \"output_test.h\"\n\n// =========================================="
},
{
"path": "3rd/benchmark-1.8.2/test/user_counters_thousands_test.cc",
"chars": 9678,
"preview": "\n#undef NDEBUG\n\n#include \"benchmark/benchmark.h\"\n#include \"output_test.h\"\n\n// =========================================="
},
{
"path": "3rd/benchmark-1.8.2/tools/BUILD.bazel",
"chars": 334,
"preview": "load(\"@tools_pip_deps//:requirements.bzl\", \"requirement\")\n\npy_library(\n name = \"gbench\",\n srcs = glob([\"gbench/*.p"
},
{
"path": "3rd/benchmark-1.8.2/tools/compare.py",
"chars": 18479,
"preview": "#!/usr/bin/env python3\n\nimport unittest\n\"\"\"\ncompare.py - versatile benchmark output compare tool\n\"\"\"\n\nimport argparse\nfr"
},
{
"path": "3rd/benchmark-1.8.2/tools/gbench/Inputs/test1_run1.json",
"chars": 2689,
"preview": "{\n \"context\": {\n \"date\": \"2016-08-02 17:44:46\",\n \"num_cpus\": 4,\n \"mhz_per_cpu\": 4228,\n \"cpu_scaling_enabled"
},
{
"path": "3rd/benchmark-1.8.2/tools/gbench/Inputs/test1_run2.json",
"chars": 2740,
"preview": "{\n \"context\": {\n \"date\": \"2016-08-02 17:44:46\",\n \"num_cpus\": 4,\n \"mhz_per_cpu\": 4228,\n \"cpu_scaling_enabled"
},
{
"path": "3rd/benchmark-1.8.2/tools/gbench/Inputs/test2_run.json",
"chars": 1551,
"preview": "{\n \"context\": {\n \"date\": \"2016-08-02 17:44:46\",\n \"num_cpus\": 4,\n \"mhz_per_cpu\": 4228,\n \"cpu_scaling_enabled"
},
{
"path": "3rd/benchmark-1.8.2/tools/gbench/Inputs/test3_run0.json",
"chars": 1266,
"preview": "{\n \"context\": {\n \"date\": \"2016-08-02 17:44:46\",\n \"num_cpus\": 4,\n \"mhz_per_cpu\": 4228,\n \"cpu_scaling_enabled"
},
{
"path": "3rd/benchmark-1.8.2/tools/gbench/Inputs/test3_run1.json",
"chars": 1270,
"preview": "{\n \"context\": {\n \"date\": \"2016-08-02 17:44:46\",\n \"num_cpus\": 4,\n \"mhz_per_cpu\": 4228,\n \"cpu_scaling_enabled"
},
{
"path": "3rd/benchmark-1.8.2/tools/gbench/Inputs/test4_run.json",
"chars": 2317,
"preview": "{\n \"benchmarks\": [\n {\n \"name\": \"99 family 0 instance 0 repetition 0\",\n \"run_type\": \"iteration\",\n \"fam"
},
{
"path": "3rd/benchmark-1.8.2/tools/gbench/Inputs/test4_run0.json",
"chars": 431,
"preview": "{\n \"context\": {\n \"date\": \"2016-08-02 17:44:46\",\n \"num_cpus\": 4,\n \"mhz_per_cpu\": 4228,\n \"cpu_scaling_enabled"
},
{
"path": "3rd/benchmark-1.8.2/tools/gbench/Inputs/test4_run1.json",
"chars": 432,
"preview": "{\n \"context\": {\n \"date\": \"2016-08-02 17:44:46\",\n \"num_cpus\": 4,\n \"mhz_per_cpu\": 4228,\n \"cpu_scaling_enabled"
},
{
"path": "3rd/benchmark-1.8.2/tools/gbench/__init__.py",
"chars": 194,
"preview": "\"\"\"Google Benchmark tooling\"\"\"\n\n__author__ = 'Eric Fiselier'\n__email__ = 'eric@efcs.ca'\n__versioninfo__ = (0, 5, 0)\n__ve"
},
{
"path": "3rd/benchmark-1.8.2/tools/gbench/report.py",
"chars": 46852,
"preview": "\"\"\"report.py - Utilities for reporting statistics about benchmark results\n\"\"\"\n\nimport unittest\nimport os\nimport re\nimpor"
},
{
"path": "3rd/benchmark-1.8.2/tools/gbench/util.py",
"chars": 6858,
"preview": "\"\"\"util.py - General utilities for running, loading, and processing benchmarks\n\"\"\"\nimport json\nimport os\nimport re\nimpor"
},
{
"path": "3rd/benchmark-1.8.2/tools/libpfm.BUILD.bazel",
"chars": 459,
"preview": "# Build rule for libpfm, which is required to collect performance counters for\n# BENCHMARK_ENABLE_LIBPFM builds.\n\nload(\""
},
{
"path": "3rd/benchmark-1.8.2/tools/requirements.txt",
"chars": 29,
"preview": "numpy == 1.25\nscipy == 1.5.4\n"
},
{
"path": "3rd/benchmark-1.8.2/tools/strip_asm.py",
"chars": 4419,
"preview": "#!/usr/bin/env python3\n\n\"\"\"\nstrip_asm.py - Cleanup ASM output for the specified file\n\"\"\"\n\nfrom argparse import ArgumentP"
},
{
"path": "3rd/googletest-1.12.1/.clang-format",
"chars": 116,
"preview": "# Run manually to reformat a file:\n# clang-format -i --style=file <file>\nLanguage: Cpp\nBasedOnStyle: Google\n"
},
{
"path": "3rd/googletest-1.12.1/.github/ISSUE_TEMPLATE/00-bug_report.md",
"chars": 1266,
"preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: 'bug'\nassignees: ''\n---\n\n**Describe the"
},
{
"path": "3rd/googletest-1.12.1/.github/ISSUE_TEMPLATE/10-feature_request.md",
"chars": 570,
"preview": "---\nname: Feature request\nabout: Propose a new feature\ntitle: ''\nlabels: 'enhancement'\nassignees: ''\n---\n\n**Does the fea"
},
{
"path": "3rd/googletest-1.12.1/.github/ISSUE_TEMPLATE/config.yml",
"chars": 28,
"preview": "blank_issues_enabled: false\n"
},
{
"path": "3rd/googletest-1.12.1/.github/workflows/gtest-ci.yml",
"chars": 599,
"preview": "name: ci\n\non:\n push:\n pull_request:\n\njobs:\n Linux:\n runs-on: ubuntu-latest\n steps:\n\n - uses: actions/checkou"
},
{
"path": "3rd/googletest-1.12.1/.gitignore",
"chars": 1561,
"preview": "# Ignore CI build directory\nbuild/\nxcuserdata\ncmake-build-debug/\n.idea/\nbazel-bin\nbazel-genfiles\nbazel-googletest\nbazel-"
},
{
"path": "3rd/googletest-1.12.1/BUILD.bazel",
"chars": 6426,
"preview": "# Copyright 2017 Google Inc.\n# All Rights Reserved.\n#\n#\n# Redistribution and use in source and binary forms, with or wit"
},
{
"path": "3rd/googletest-1.12.1/CMakeLists.txt",
"chars": 860,
"preview": "# Note: CMake support is community-based. The maintainers do not use CMake\n# internally.\n\ncmake_minimum_required(VERSION"
},
{
"path": "3rd/googletest-1.12.1/CONTRIBUTING.md",
"chars": 5682,
"preview": "# How to become a contributor and submit your own code\n\n## Contributor License Agreements\n\nWe'd love to accept your patc"
},
{
"path": "3rd/googletest-1.12.1/CONTRIBUTORS",
"chars": 2254,
"preview": "# This file contains a list of people who've made non-trivial\n# contribution to the Google C++ Testing Framework project"
},
{
"path": "3rd/googletest-1.12.1/LICENSE",
"chars": 1475,
"preview": "Copyright 2008, Google Inc.\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmod"
},
{
"path": "3rd/googletest-1.12.1/README.md",
"chars": 4720,
"preview": "# GoogleTest\n\n### Announcements\n\n#### Live at Head\n\nGoogleTest now follows the\n[Abseil Live at Head philosophy](https://"
},
{
"path": "3rd/googletest-1.12.1/WORKSPACE",
"chars": 1770,
"preview": "workspace(name = \"com_google_googletest\")\n\nload(\"@bazel_tools//tools/build_defs/repo:http.bzl\", \"http_archive\")\n\nhttp_ar"
},
{
"path": "3rd/googletest-1.12.1/ci/linux-presubmit.sh",
"chars": 4298,
"preview": "#!/bin/bash\n#\n# Copyright 2020, Google Inc.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms"
},
{
"path": "3rd/googletest-1.12.1/ci/macos-presubmit.sh",
"chars": 2608,
"preview": "#!/bin/bash\n#\n# Copyright 2020, Google Inc.\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms"
},
{
"path": "3rd/googletest-1.12.1/docs/_config.yml",
"chars": 18,
"preview": "title: GoogleTest\n"
},
{
"path": "3rd/googletest-1.12.1/docs/_data/navigation.yml",
"chars": 1200,
"preview": "nav:\n- section: \"Get Started\"\n items:\n - title: \"Supported Platforms\"\n url: \"/platforms.html\"\n - title: \"Quickstar"
},
{
"path": "3rd/googletest-1.12.1/docs/_layouts/default.html",
"chars": 2319,
"preview": "<!DOCTYPE html>\n<html lang=\"{{ site.lang | default: \"en-US\" }}\">\n <head>\n <meta charset=\"UTF-8\">\n <meta http-equi"
},
{
"path": "3rd/googletest-1.12.1/docs/_sass/main.scss",
"chars": 2915,
"preview": "// Styles for GoogleTest docs website on GitHub Pages.\n// Color variables are defined in\n// https://github.com/pages-the"
},
{
"path": "3rd/googletest-1.12.1/docs/advanced.md",
"chars": 87281,
"preview": "# Advanced googletest Topics\n\n## Introduction\n\nNow that you have read the [googletest Primer](primer.md) and learned how"
},
{
"path": "3rd/googletest-1.12.1/docs/assets/css/style.scss",
"chars": 56,
"preview": "---\n---\n\n@import \"jekyll-theme-primer\";\n@import \"main\";\n"
},
{
"path": "3rd/googletest-1.12.1/docs/community_created_documentation.md",
"chars": 342,
"preview": "# Community-Created Documentation\n\nThe following is a list, in no particular order, of links to documentation\ncreated by"
},
{
"path": "3rd/googletest-1.12.1/docs/faq.md",
"chars": 29898,
"preview": "# GoogleTest FAQ\n\n## Why should test suite names and test names not contain underscore?\n\n{: .callout .note}\nNote: Google"
},
{
"path": "3rd/googletest-1.12.1/docs/gmock_cheat_sheet.md",
"chars": 7376,
"preview": "# gMock Cheat Sheet\n\n## Defining a Mock Class\n\n### Mocking a Normal Class {#MockClass}\n\nGiven\n\n```cpp\nclass Foo {\n publi"
},
{
"path": "3rd/googletest-1.12.1/docs/gmock_cook_book.md",
"chars": 147137,
"preview": "# gMock Cookbook\n\nYou can find recipes for using gMock here. If you haven't yet, please read\n[the dummy guide](gmock_for"
},
{
"path": "3rd/googletest-1.12.1/docs/gmock_faq.md",
"chars": 14980,
"preview": "# Legacy gMock FAQ\n\n### When I call a method on my mock object, the method for the real object is invoked instead. What'"
},
{
"path": "3rd/googletest-1.12.1/docs/gmock_for_dummies.md",
"chars": 29194,
"preview": "# gMock for Dummies\n\n## What Is gMock?\n\nWhen you write a prototype or test, often it's not feasible or wise to rely on\nr"
}
]
// ... and 245 more files (download for full content)
About this extraction
This page contains the full source code of the ichenq/timerqueue-benchmark GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 445 files (4.7 MB), approximately 1.3M tokens, and a symbol index with 6158 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.