Showing preview only (1,067K chars total). Download the full file or copy to clipboard to get everything.
Repository: RedSpah/xxhash_cpp
Branch: master
Commit: 2aad76a18f7a
Files: 14
Total size: 1.0 MB
Directory structure:
gitextract_fzbi9j_9/
├── .circleci/
│ └── config.yml
├── .gitattributes
├── .github/
│ └── ISSUE_TEMPLATE/
│ └── bug_report.md
├── .gitignore
├── CMakeLists.txt
├── CODE_OF_CONDUCT.md
├── LICENSE
├── README.md
├── include/
│ └── xxhash.hpp
└── test/
├── CMakeLists.txt
├── catch.hpp
├── test_main.cpp
├── xxh3.h
└── xxhash.h
================================================
FILE CONTENTS
================================================
================================================
FILE: .circleci/config.yml
================================================
# Use the latest 2.1 version of CircleCI pipeline process engine.
# See: https://circleci.com/docs/2.0/configuration-reference
version: 2.1
orbs:
win: circleci/windows@4.1
# Define a job to be invoked later in a workflow.
# See: https://circleci.com/docs/2.0/configuration-reference/#jobs
jobs:
build-test:
executor: win/server-2019
steps:
- checkout
- run: choco install mingw -y
- run: choco install cmake -y
- run: mkdir build
- run: cd build; $env:Path+=";$Env:ProgramFiles\CMake\bin"; cmake -DCMAKE_BUILD_TYPE=Release -DXXH_CPP_USE_AVX2=ON ..; cmake --build . --config Release; ctest --output-on-failure -C Release
# Invoke jobs via workflows
# See: https://circleci.com/docs/2.0/configuration-reference/#workflows
workflows:
say-hello-workflow:
jobs:
- build-test
================================================
FILE: .gitattributes
================================================
###############################################################################
# Set default behavior to automatically normalize line endings.
###############################################################################
* text=auto
###############################################################################
# Set default behavior for command prompt diff.
#
# This is need for earlier builds of msysgit that does not have it on by
# default for csharp files.
# Note: This is only used by command line
###############################################################################
#*.cs diff=csharp
###############################################################################
# Set the merge driver for project and solution files
#
# Merging from the command prompt will add diff markers to the files if there
# are conflicts (Merging from VS is not affected by the settings below, in VS
# the diff markers are never inserted). Diff markers may cause the following
# file extensions to fail to load in VS. An alternative would be to treat
# these files as binary and thus will always conflict and require user
# intervention with every merge. To do so, just uncomment the entries below
###############################################################################
#*.sln merge=binary
#*.csproj merge=binary
#*.vbproj merge=binary
#*.vcxproj merge=binary
#*.vcproj merge=binary
#*.dbproj merge=binary
#*.fsproj merge=binary
#*.lsproj merge=binary
#*.wixproj merge=binary
#*.modelproj merge=binary
#*.sqlproj merge=binary
#*.wwaproj merge=binary
###############################################################################
# behavior for image files
#
# image files are treated as binary by default.
###############################################################################
#*.jpg binary
#*.png binary
#*.gif binary
###############################################################################
# diff behavior for common document formats
#
# Convert binary document formats to text before diffing them. This feature
# is only available from the command line. Turn it on by uncommenting the
# entries below.
###############################################################################
#*.doc diff=astextplain
#*.DOC diff=astextplain
#*.docx diff=astextplain
#*.DOCX diff=astextplain
#*.dot diff=astextplain
#*.DOT diff=astextplain
#*.pdf diff=astextplain
#*.PDF diff=astextplain
#*.rtf diff=astextplain
#*.RTF diff=astextplain
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug report
about: Create a report to help us improve
title: ''
labels: ''
assignees: ''
---
**Describe the bug**
A clear and concise description of what the bug is.
**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
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.
**Desktop (please complete the following information):**
- OS: [e.g. iOS]
- Browser [e.g. chrome, safari]
- Version [e.g. 22]
**Smartphone (please complete the following information):**
- Device: [e.g. iPhone6]
- OS: [e.g. iOS8.1]
- Browser [e.g. stock browser, safari]
- Version [e.g. 22]
**Additional context**
Add any other context about the problem here.
================================================
FILE: .gitignore
================================================
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.
# User-specific files
*.suo
*.user
*.userosscache
*.sln.docstates
# User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs
# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
x64/
x86/
bld/
[Bb]in/
[Oo]bj/
[Ll]og/
build/
# Visual Studio 2015 cache/options directory
.vs/
# Uncomment if you have tasks that create the project's static files in wwwroot
#wwwroot/
# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*
# NUNIT
*.VisualState.xml
TestResult.xml
# Build Results of an ATL Project
[Dd]ebugPS/
[Rr]eleasePS/
dlldata.c
# DNX
project.lock.json
project.fragment.lock.json
artifacts/
*_i.c
*_p.c
*_i.h
*.ilk
*.meta
*.obj
*.pch
*.pdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*.log
*.vspscc
*.vssscc
.builds
*.pidb
*.svclog
*.scc
# Chutzpah Test files
_Chutzpah*
# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opendb
*.opensdf
*.sdf
*.cachefile
*.VC.db
*.VC.VC.opendb
# Visual Studio profiler
*.psess
*.vsp
*.vspx
*.sap
# TFS 2012 Local Workspace
$tf/
# Guidance Automation Toolkit
*.gpState
# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
*.DotSettings.user
# JustCode is a .NET coding add-in
.JustCode
# TeamCity is a build add-in
_TeamCity*
# DotCover is a Code Coverage Tool
*.dotCover
# NCrunch
_NCrunch_*
.*crunch*.local.xml
nCrunchTemp_*
# MightyMoose
*.mm.*
AutoTest.Net/
# Web workbench (sass)
.sass-cache/
# Installshield output folder
[Ee]xpress/
# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html
# Click-Once directory
publish/
# Publish Web Output
*.[Pp]ublish.xml
*.azurePubxml
# TODO: Comment the next line if you want to checkin your web deploy settings
# but database connection strings (with potential passwords) will be unencrypted
#*.pubxml
*.publishproj
# Microsoft Azure Web App publish settings. Comment the next line if you want to
# checkin your Azure Web App publish settings, but sensitive information contained
# in these scripts will be unencrypted
PublishScripts/
# NuGet Packages
*.nupkg
# The packages folder can be ignored because of Package Restore
**/packages/*
# except build/, which is used as an MSBuild target.
!**/packages/build/
# Uncomment if necessary however generally it will be regenerated when needed
#!**/packages/repositories.config
# NuGet v3's project.json files produces more ignoreable files
*.nuget.props
*.nuget.targets
# Microsoft Azure Build Output
csx/
*.build.csdef
# Microsoft Azure Emulator
ecf/
rcf/
# Windows Store app package directories and files
AppPackages/
BundleArtifacts/
Package.StoreAssociation.xml
_pkginfo.txt
# Visual Studio cache files
# files ending in .cache can be ignored
*.[Cc]ache
# but keep track of directories ending in .cache
!*.[Cc]ache/
# Others
ClientBin/
~$*
*~
*.dbmdl
*.dbproj.schemaview
*.jfm
*.pfx
*.publishsettings
node_modules/
orleans.codegen.cs
# Since there are multiple workflows, uncomment next line to ignore bower_components
# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
#bower_components/
# RIA/Silverlight projects
Generated_Code/
# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm
# SQL Server files
*.mdf
*.ldf
# Business Intelligence projects
*.rdl.data
*.bim.layout
*.bim_*.settings
# Microsoft Fakes
FakesAssemblies/
# GhostDoc plugin setting file
*.GhostDoc.xml
# Node.js Tools for Visual Studio
.ntvs_analysis.dat
# Visual Studio 6 build log
*.plg
# Visual Studio 6 workspace options file
*.opt
# Visual Studio LightSwitch build output
**/*.HTMLClient/GeneratedArtifacts
**/*.DesktopClient/GeneratedArtifacts
**/*.DesktopClient/ModelManifest.xml
**/*.Server/GeneratedArtifacts
**/*.Server/ModelManifest.xml
_Pvt_Extensions
# Paket dependency manager
.paket/paket.exe
paket-files/
# FAKE - F# Make
.fake/
# JetBrains Rider
.idea/
*.sln.iml
# CodeRush
.cr/
# Python Tools for Visual Studio (PTVS)
__pycache__/
*.pyc
# Test files
*.o
*.exe
*.vcxproj
*.vcxproj.filters
*.cmake
*.cmake.in
*.sln
/xxhash
/xxhash_dev
/build
/xxhash_dev
*.tcl
CMakeCache.txt
/test/CMakeFiles
/CMakeFiles
================================================
FILE: CMakeLists.txt
================================================
cmake_minimum_required(VERSION 3.8)
project(xxhash_cpp
VERSION 0.8.1
LANGUAGES CXX
DESCRIPTION "C++ port of the xxhash library."
HOMEPAGE_URL "https://github.com/RedSpah/xxhash_cpp")
include(GNUInstallDirs)
add_library(${PROJECT_NAME} INTERFACE)
target_compile_features(${PROJECT_NAME} INTERFACE cxx_std_17)
target_include_directories(${PROJECT_NAME} INTERFACE
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64" AND APPLE)
find_path(SSE2NEON_HEADER sse2neon.h PATHS ${CMAKE_SOURCE_DIR}/../sse2neon)
target_include_directories(${PROJECT_NAME} INTERFACE ${SSE2NEON_HEADER})
endif()
if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
include(CTest)
endif()
if(BUILD_TESTING)
add_subdirectory(test)
endif()
install(TARGETS ${PROJECT_NAME}
EXPORT ${PROJECT_NAME}_Targets
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
include(CMakePackageConfigHelpers)
write_basic_package_version_file("${PROJECT_NAME}ConfigVersion.cmake"
VERSION ${PROJECT_VERSION}
COMPATIBILITY ExactVersion)
file(WRITE ${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake.in
"@PACKAGE_INIT@\n"
"include(\"\${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake\")\n"
"check_required_components(\"@PROJECT_NAME@\")\n"
)
configure_package_config_file(
"${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake.in"
"${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
INSTALL_DESTINATION
${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/cmake)
install(EXPORT ${PROJECT_NAME}_Targets
FILE ${PROJECT_NAME}Targets.cmake
NAMESPACE ${PROJECT_NAME}::
DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/cmake)
install(FILES "${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
"${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME}/cmake)
install(DIRECTORY ${PROJECT_SOURCE_DIR}/include DESTINATION include)
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Covenant Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as
contributors and maintainers pledge to making participation in our project and
our community a harassment-free experience for everyone, regardless of age, body
size, disability, ethnicity, sex characteristics, gender identity and expression,
level of experience, education, socio-economic status, nationality, personal
appearance, race, religion, or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment
include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or
advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic
address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable
behavior and are expected to take appropriate and fair corrective action in
response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or
reject comments, commits, code, wiki edits, issues, and other contributions
that are not aligned to this Code of Conduct, or to ban temporarily or
permanently any contributor for other behaviors that they deem inappropriate,
threatening, offensive, or harmful.
## Scope
This Code of Conduct applies both within project spaces and in public spaces
when an individual is representing the project or its community. Examples of
representing a project or community include using an official project e-mail
address, posting via an official social media account, or acting as an appointed
representative at an online or offline event. Representation of a project may be
further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported by contacting the project team at redspah@gmail.com. All
complaints will be reviewed and investigated and will result in a response that
is deemed necessary and appropriate to the circumstances. The project team is
obligated to maintain confidentiality with regard to the reporter of an incident.
Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good
faith may face temporary or permanent repercussions as determined by other
members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see
https://www.contributor-covenant.org/faq
================================================
FILE: LICENSE
================================================
BSD 2-Clause License
Copyright (c) 2012-2020, Yann Collet
Copyright (c) 2017-2020, Red Gavin
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: README.md
================================================
# xxhash_cpp
Port of the xxHash library to C++17.
[](https://dl.circleci.com/status-badge/redirect/gh/RedSpah/xxhash_cpp/tree/master)
Compatibility
----
| Compiler | Min. Version |
|----------------------|:-------------------:|
| MSVC (Visual Studio) | 19.1 (VS 2017.3 P2) |
| clang | 3.9 |
| gcc | 7 |
Example Usage
----
```cpp
// standalone hash
std::array<int, 4> input {322, 2137, 42069, 65536};
xxh::hash_t<32> hash = xxh::xxhash<32>(input);
// hash streaming
std::array<unsigned char, 512> buffer;
xxh::hash_state_t<64> hash_stream;
while (fill_buffer(buffer))
{
hash_stream.update(buffer);
}
xxh::hash_t<64> final_hash = hash_stream.digest();
```
The template argument specifies whether the algorithm will use the 32 or 64 bit version. Other values are not allowed. Typedefs `hash32_t`, `hash64_t`, `hash_state32_t` and `hash_state64_t` are provided.
`xxh::xxhash` and `xxh::hash_state_t::update` provide several convenient overloads, all accepting optional `seed` and `endianness` arguments:
* C-style `const void*` + `size_t` pair
* `const std::vector<T>&`
* `const std::basic_string<T>&`
* A pair of templated iterators
* `const std::array<T, N>&`
* `const std::initializer_list<T>&`
Build Instructions
----
The library is provided as a single standalone header, for static linking only. No build instructions are nessessary.
xxHash - Extremely fast hash algorithm
======================================
xxHash is an Extremely fast Hash algorithm, running at RAM speed limits.
It successfully completes the [SMHasher](http://code.google.com/p/smhasher/wiki/SMHasher) test suite
which evaluates collision, dispersion and randomness qualities of hash functions.
Code is highly portable, and hashes are identical on all platforms (little / big endian).
Benchmarks
-------------------------
The benchmark uses SMHasher speed test, compiled with Visual 2010 on a Windows Seven 32-bits box.
The reference system uses a Core 2 Duo @3GHz
| Name | Speed | Quality | Author |
|---------------|----------|:-------:|------------------|
| [xxHash] | 5.4 GB/s | 10 | Y.C. |
| MurmurHash 3a | 2.7 GB/s | 10 | Austin Appleby |
| SBox | 1.4 GB/s | 9 | Bret Mulvey |
| Lookup3 | 1.2 GB/s | 9 | Bob Jenkins |
| CityHash64 | 1.05 GB/s| 10 | Pike & Alakuijala|
| FNV | 0.55 GB/s| 5 | Fowler, Noll, Vo |
| CRC32 | 0.43 GB/s| 9 | |
| MD5-32 | 0.33 GB/s| 10 | Ronald L.Rivest |
| SHA1-32 | 0.28 GB/s| 10 | |
[xxHash]: http://www.xxhash.com
Q.Score is a measure of quality of the hash function.
It depends on successfully passing SMHasher test set.
10 is a perfect score.
Algorithms with a score < 5 are not listed on this table.
A more recent version, XXH64, has been created thanks to [Mathias Westerdahl](https://github.com/JCash),
which offers superior speed and dispersion for 64-bits systems.
Note however that 32-bits applications will still run faster using the 32-bits version.
SMHasher speed test, compiled using GCC 4.8.2, on Linux Mint 64-bits.
The reference system uses a Core i5-3340M @2.7GHz
| Version | Speed on 64-bits | Speed on 32-bits |
|------------|------------------|------------------|
| XXH64 | 13.8 GB/s | 1.9 GB/s |
| XXH32 | 6.8 GB/s | 6.0 GB/s |
### License
The library file `xxhash.hpp` is BSD licensed.
### Build modifiers
The following macros influence xxhash behavior. They are all disabled by default.
- `XXH_FORCE_NATIVE_FORMAT` : on big-endian systems : use native number representation,
resulting in system-specific results.
Breaks consistency with little-endian results.
- `XXH_CPU_LITTLE_ENDIAN` : if defined to 0, sets the native endianness to big endian,
if defined to 1, sets the native endianness to little endian,
if left undefined, the endianness is resolved at runtime,
before `main` is called, at the cost of endianness not being `constexpr`.
- `XXH_FORCE_MEMORY_ACCESS` : if defined to 2, enables unaligned reads as an optimization, this is not standard compliant,
if defined to 1, enables the use of `packed` attribute for optimization, only defined for gcc and icc
otherwise, uses the default fallback method (`memcpy`)
### Other languages
Beyond the C reference version,
xxHash is also available on many programming languages,
thanks to great contributors.
They are [listed here](http://www.xxhash.com/#other-languages).
================================================
FILE: include/xxhash.hpp
================================================
#pragma once
#include <cstdint>
#include <cstring>
#include <array>
#include <type_traits>
#include <vector>
#include <string>
/*
xxHash - Extremely Fast Hash algorithm
Header File
Copyright (C) 2012-2024, Yann Collet.
Copyright (C) 2017-2024, Red Gavin.
All rights reserved.
BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
You can contact the author at :
- xxHash source repository : https://github.com/Cyan4973/xxHash
- xxHash C++ port repository : https://github.com/RedSpah/xxhash_cpp
*/
/* Intrinsics
* Sadly has to be included in the global namespace or literally everything breaks
*/
#if (defined(__ARM_NEON) && defined(__APPLE__))
#include "sse2neon.h"
#else
#include <immintrin.h>
#endif
namespace xxh
{
/* *************************************
* Versioning
***************************************/
namespace version
{
constexpr int cpp_version_major = 0;
constexpr int cpp_version_minor = 8;
constexpr int cpp_version_release = 1;
}
constexpr uint32_t version_number()
{
return version::cpp_version_major * 10000 + version::cpp_version_minor * 100 + version::cpp_version_release;
}
/* *************************************
* Basic Types - Predefining uint128_t for intrin
***************************************/
namespace typedefs
{
struct alignas(16) uint128_t
{
uint64_t low64 = 0;
uint64_t high64 = 0;
bool operator==(const uint128_t & other)
{
return (low64 == other.low64 && high64 == other.high64);
}
bool operator>(const uint128_t & other)
{
return (high64 > other.high64 || low64 > other.low64);
}
bool operator>=(const uint128_t & other)
{
return (*this > other || *this == other);
}
bool operator<(const uint128_t & other)
{
return !(*this >= other);
}
bool operator<=(const uint128_t & other)
{
return !(*this > other);
}
bool operator!=(const uint128_t & other)
{
return !(*this == other);
}
uint128_t(uint64_t low, uint64_t high) : low64(low), high64(high) {}
uint128_t() {}
};
}
using uint128_t = typedefs::uint128_t;
/* *************************************
* Compiler / Platform Specific Features
***************************************/
namespace intrin
{
/*!XXH_CPU_LITTLE_ENDIAN :
* This is a CPU endian detection macro, will be
* automatically set to 1 (little endian) if it is left undefined.
* If compiling for a big endian system (why), XXH_CPU_LITTLE_ENDIAN has to be explicitly defined as 0.
*/
#ifndef XXH_CPU_LITTLE_ENDIAN
# define XXH_CPU_LITTLE_ENDIAN 1
#endif
/* Vectorization Detection
* NOTE: XXH_NEON and XXH_VSX aren't supported in this C++ port.
* The primary reason is that I don't have access to an ARM and PowerPC
* machines to test them, and the secondary reason is that I even doubt anyone writing
* code for such machines would bother using a C++ port rather than the original C version.
*/
#ifndef XXH_VECTOR /* can be predefined on command line */
# if defined(__AVX512F__)
# define XXH_VECTOR 3 /* AVX512 for Skylake and Icelake */
# elif defined(__AVX2__)
# define XXH_VECTOR 2 /* AVX2 for Haswell and Bulldozer */
# elif defined(__SSE2__) || defined(_M_AMD64) || defined(_M_X64) || (defined(_M_IX86_FP) && (_M_IX86_FP == 2))
# define XXH_VECTOR 1 /* SSE2 for Pentium 4 and all x86_64 */
# else
# define XXH_VECTOR 0 /* Portable scalar version */
# endif
#endif
constexpr int vector_mode = XXH_VECTOR;
#if XXH_VECTOR == 3 /* AVX512 for Skylake and Icelake */
constexpr int acc_align = 64;
using avx512_underlying = __m512i;
using avx2_underlying = __m256i;
using sse2_underlying = __m128i;
#elif XXH_VECTOR == 2 /* AVX2 for Haswell and Bulldozer */
constexpr int acc_align = 32;
using avx512_underlying = void;
using avx2_underlying = __m256i;
using sse2_underlying = __m128i;
#elif XXH_VECTOR == 1 /* SSE2 for Pentium 4 and all x86_64 */
using avx512_underlying = void;
using avx2_underlying = void; //std::array<__m128i, 2>;
using sse2_underlying = __m128i;
constexpr int acc_align = 16;
#else /* Portable scalar version */
using avx512_underlying = void;
using avx2_underlying = void; //std::array<uint64_t, 4>;
using sse2_underlying = void; //std::array<uint64_t, 2>;
constexpr int acc_align = 8;
#endif
/* Compiler Specifics
* Defines inline macros and includes specific compiler's instrinsics.
* */
#ifdef XXH_FORCE_INLINE /* First undefining the symbols in case they're already defined */
# undef XXH_FORCE_INLINE
#endif
#ifdef XXH_NO_INLINE
# undef XXH_NO_INLINE
#endif
#ifdef _MSC_VER /* Visual Studio */
# pragma warning(disable : 4127)
# define XXH_FORCE_INLINE static __forceinline
# define XXH_NO_INLINE static __declspec(noinline)
# include <intrin.h>
#elif defined(__GNUC__) /* Clang / GCC */
# define XXH_FORCE_INLINE static inline __attribute__((always_inline))
# define XXH_NO_INLINE static __attribute__((noinline))
#if (defined(__ARM_NEON) && defined(__APPLE__))
# include "sse2neon.h"
# else
# include <immintrin.h>
# endif
#else
# define XXH_FORCE_INLINE static inline
# define XXH_NO_INLINE static
#endif
/* Prefetch
* Can be disabled by defining XXH_NO_PREFETCH
*/
#if defined(XXH_NO_PREFETCH)
XXH_FORCE_INLINE void prefetch(const void* ptr) {}
#elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))
XXH_FORCE_INLINE void prefetch(const void* ptr) { _mm_prefetch((const char*)(ptr), _MM_HINT_T0); }
#elif defined(__GNUC__)
XXH_FORCE_INLINE void prefetch(const void* ptr) { __builtin_prefetch((ptr), 0, 3); }
#else
XXH_FORCE_INLINE void prefetch(const void* ptr) {}
#endif
/* Restrict
* Defines macro for restrict, which in C++ is sadly just a compiler extension (for now).
* Can be disabled by defining XXH_NO_RESTRICT
*/
#ifdef XXH_RESTRICT
# undef XXH_RESTRICT
#endif
#if (defined(__GNUC__) || defined(_MSC_VER)) && defined(__cplusplus) && !defined(XXH_NO_RESTRICT)
# define XXH_RESTRICT __restrict
#else
# define XXH_RESTRICT
#endif
/* Likely / Unlikely
* Defines macros for Likely / Unlikely, which are official in C++20, but sadly this library aims the previous standard.
* Not present on MSVC.
* Can be disabled by defining XXH_NO_BRANCH_HINTS
*/
#if ((defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__)) && !defined(XXH_NO_BRANCH_HINTS)
# define XXH_likely(x) __builtin_expect(x, 1)
# define XXH_unlikely(x) __builtin_expect(x, 0)
#else
# define XXH_likely(x) (x)
# define XXH_unlikely(x) (x)
#endif
/* _MM_PERM_ENUM type
* Defines the type for the parameters of the shuffle function, in a way that works with -fpedantic while not breaking non-x86 compatibility.
*/
#if defined(__i386__) || defined(__x86_64__) || defined(_M_X64)
using mm_perm_enum_t = _MM_PERM_ENUM;
#else
using mm_perm_enum_t = int;
#endif
namespace bit_ops
{
#if defined(_MSC_VER)
static inline uint32_t rotl32(uint32_t x, int32_t r) { return _rotl(x, r); }
static inline uint64_t rotl64(uint64_t x, int32_t r) { return _rotl64(x, r); }
static inline uint32_t rotr32(uint32_t x, int32_t r) { return _rotr(x, r); }
static inline uint64_t rotr64(uint64_t x, int32_t r) { return _rotr64(x, r); }
#else
static inline uint32_t rotl32(uint32_t x, int32_t r) { return ((x << r) | (x >> (32 - r))); }
static inline uint64_t rotl64(uint64_t x, int32_t r) { return ((x << r) | (x >> (64 - r))); }
static inline uint32_t rotr32(uint32_t x, int32_t r) { return ((x >> r) | (x << (32 - r))); }
static inline uint64_t rotr64(uint64_t x, int32_t r) { return ((x >> r) | (x << (64 - r))); }
#endif
#if defined(_MSC_VER) /* Visual Studio */
static inline uint32_t swap32(uint32_t x) { return _byteswap_ulong(x); }
static inline uint64_t swap64(uint64_t x) { return _byteswap_uint64(x); }
#elif defined(__GNUC__)
static inline uint32_t swap32(uint32_t x) { return __builtin_bswap32(x); }
static inline uint64_t swap64(uint64_t x) { return __builtin_bswap64(x); }
#else
static inline uint32_t swap32(uint32_t x) { return ((x << 24) & 0xff000000) | ((x << 8) & 0x00ff0000) | ((x >> 8) & 0x0000ff00) | ((x >> 24) & 0x000000ff); }
static inline uint64_t swap64(uint64_t x) { return ((x << 56) & 0xff00000000000000ULL) | ((x << 40) & 0x00ff000000000000ULL) | ((x << 24) & 0x0000ff0000000000ULL) | ((x << 8) & 0x000000ff00000000ULL) | ((x >> 8) & 0x00000000ff000000ULL) | ((x >> 24) & 0x0000000000ff0000ULL) | ((x >> 40) & 0x000000000000ff00ULL) | ((x >> 56) & 0x00000000000000ffULL); }
#endif
#if defined(_MSC_VER) && defined(_M_IX86) // Only for 32-bit MSVC.
XXH_FORCE_INLINE uint64_t mult32to64(uint32_t x, uint32_t y) { return __emulu(x, y); }
#else
XXH_FORCE_INLINE uint64_t mult32to64(uint32_t x, uint32_t y) { return (uint64_t)(uint32_t)(x) * (uint64_t)(uint32_t)(y); }
#endif
#if defined(__GNUC__) && !defined(__clang__) && defined(__i386__)
__attribute__((__target__("no-sse")))
#endif
static inline uint128_t mult64to128(uint64_t lhs, uint64_t rhs)
{
#if defined(__GNUC__) && !defined(__wasm__) \
&& defined(__SIZEOF_INT128__) \
|| (defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 128)
__uint128_t product = (__uint128_t)lhs * (__uint128_t)rhs;
uint128_t r128;
r128.low64 = (uint64_t)(product);
r128.high64 = (uint64_t)(product >> 64);
return r128;
#elif defined(_M_X64) || defined(_M_IA64)
#ifndef _MSC_VER
# pragma intrinsic(_umul128)
#endif
uint64_t product_high;
uint64_t const product_low = _umul128(lhs, rhs, &product_high);
uint128_t r128;
r128.low64 = product_low;
r128.high64 = product_high;
return r128;
#else
uint64_t const lo_lo = bit_ops::mult32to64(lhs & 0xFFFFFFFF, rhs & 0xFFFFFFFF);
uint64_t const hi_lo = bit_ops::mult32to64(lhs >> 32, rhs & 0xFFFFFFFF);
uint64_t const lo_hi = bit_ops::mult32to64(lhs & 0xFFFFFFFF, rhs >> 32);
uint64_t const hi_hi = bit_ops::mult32to64(lhs >> 32, rhs >> 32);
/* Now add the products together. These will never overflow. */
uint64_t const cross = (lo_lo >> 32) + (hi_lo & 0xFFFFFFFF) + lo_hi;
uint64_t const upper = (hi_lo >> 32) + (cross >> 32) + hi_hi;
uint64_t const lower = (cross << 32) | (lo_lo & 0xFFFFFFFF);
uint128_t r128;
r128.low64 = lower;
r128.high64 = upper;
return r128;
#endif
}
}
}
/* *************************************
* Basic Types - Everything else
***************************************/
namespace typedefs
{
/* *************************************
* Basic Types - Detail
***************************************/
template <size_t N>
struct hash_type
{
using type = void;
};
template <>
struct hash_type<32>
{
using type = uint32_t;
};
template <>
struct hash_type<64>
{
using type = uint64_t;
};
template <>
struct hash_type<128>
{
using type = uint128_t;
};
template <size_t N>
struct vec_type
{
using type = void;
};
template <>
struct vec_type<64>
{
using type = uint64_t;
};
template <>
struct vec_type<128>
{
using type = intrin::sse2_underlying;
};
template <>
struct vec_type<256>
{
using type = intrin::avx2_underlying;
};
template <>
struct vec_type<512>
{
using type = intrin::avx512_underlying;
};
/* Rationale
* On the surface level uint_type appears to be pointless,
* as it is just a copy of hash_type. They do use the same types,
* that is true, but the reasoning for the difference is aimed at humans,
* not the compiler, as a difference between values that are 'just' numbers,
* and those that represent actual hash values.
*/
template <size_t N>
struct uint_type
{
using type = void;
};
template <>
struct uint_type<32>
{
using type = uint32_t;
};
template <>
struct uint_type<64>
{
using type = uint64_t;
};
template <>
struct uint_type<128>
{
using type = uint128_t;
};
}
template <size_t N>
using hash_t = typename typedefs::hash_type<N>::type;
using hash32_t = hash_t<32>;
using hash64_t = hash_t<64>;
using hash128_t = hash_t<128>;
template <size_t N>
using vec_t = typename typedefs::vec_type<N>::type;
using vec64_t = vec_t<64>;
using vec128_t = vec_t<128>;
using vec256_t = vec_t<256>;
using vec512_t = vec_t<512>;
template <size_t N>
using uint_t = typename typedefs::uint_type<N>::type;
/* *************************************
* Bit Operations
***************************************/
namespace bit_ops
{
/* ****************************************
* Bit Operations
******************************************/
template <size_t N>
static inline uint_t<N> rotl(uint_t<N> n, int32_t r)
{
if constexpr (N == 32)
{
return intrin::bit_ops::rotl32(n, r);
}
if constexpr (N == 64)
{
return intrin::bit_ops::rotl64(n, r);
}
}
template <size_t N>
static inline uint_t<N> rotr(uint_t<N> n, int32_t r)
{
if constexpr (N == 32)
{
return intrin::bit_ops::rotr32(n, r);
}
if constexpr (N == 64)
{
return intrin::bit_ops::rotr64(n, r);
}
}
template <size_t N>
static inline uint_t<N> swap(uint_t<N> n)
{
if constexpr (N == 32)
{
return intrin::bit_ops::swap32(n);
}
if constexpr (N == 64)
{
return intrin::bit_ops::swap64(n);
}
}
template <size_t N = 64>
static inline vec_t<N> mul32to64(vec_t<N> x, vec_t<N> y)
{
if constexpr (N == 64)
{
return intrin::bit_ops::mult32to64(static_cast<uint32_t>(x), static_cast<uint32_t>(y));
}
else
{
return 0;
}
}
static inline uint128_t mul64to128(uint64_t x, uint64_t y)
{
return intrin::bit_ops::mult64to128(x, y);
}
static inline uint64_t mul128fold64(uint64_t x, uint64_t y)
{
uint128_t product = mul64to128(x, y);
return (product.low64 ^ product.high64);
}
}
/* *************************************
* Memory Functions
***************************************/
namespace mem_ops
{
/* *************************************
* Endianness
***************************************/
constexpr bool is_little_endian()
{
return (XXH_CPU_LITTLE_ENDIAN == 1);
}
/* *************************************
* Memory Access
***************************************/
template <size_t N>
static inline uint_t<N> read(const void* memPtr)
{
uint_t<N> val;
memcpy(&val, memPtr, sizeof(val));
return val;
}
template <size_t N>
static inline uint_t<N> readLE(const void* ptr)
{
if constexpr (is_little_endian())
{
return read<N>(ptr);
}
else
{
return bit_ops::swap<N>(read<N>(ptr));
}
}
template <size_t N>
static inline uint_t<N> readBE(const void* ptr)
{
if constexpr (is_little_endian())
{
return bit_ops::swap<N>(read<N>(ptr));
}
else
{
return read<N>(ptr);
}
}
template <size_t N>
static void writeLE(void* dst, uint_t<N> v)
{
if constexpr (!is_little_endian())
{
v = bit_ops::swap<N>(v);
}
memcpy(dst, &v, sizeof(v));
}
}
/* *************************************
* Vector Functions
***************************************/
namespace vec_ops
{
template <size_t N>
XXH_FORCE_INLINE vec_t<N> loadu(const vec_t<N>* input)
{
static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid template argument passed to xxh::vec_ops::loadu");
if constexpr (N == 128)
{
return _mm_loadu_si128(input);
}
if constexpr (N == 256)
{
return _mm256_loadu_si256(input);
}
if constexpr (N == 512)
{
return _mm512_loadu_si512(input);
}
if constexpr (N == 64)
{
return mem_ops::readLE<64>(input);
}
}
// 'xorv' instead of 'xor' because 'xor' is a weird wacky alternate operator expression thing.
template <size_t N>
XXH_FORCE_INLINE vec_t<N> xorv(vec_t<N> a, vec_t<N> b)
{
static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::xorv");
if constexpr (N == 128)
{
return _mm_xor_si128(a, b);
}
if constexpr (N == 256)
{
return _mm256_xor_si256(a, b);
}
if constexpr (N == 512)
{
return _mm512_xor_si512(a, b);
}
if constexpr (N == 64)
{
return a ^ b;
}
}
template <size_t N>
XXH_FORCE_INLINE vec_t<N> mul(vec_t<N> a, vec_t<N> b)
{
static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::mul");
if constexpr (N == 128)
{
return _mm_mul_epu32(a, b);
}
if constexpr (N == 256)
{
return _mm256_mul_epu32(a, b);
}
if constexpr (N == 512)
{
return _mm512_mul_epu32(a, b);
}
if constexpr (N == 64)
{
return a * b;
}
}
template <size_t N>
XXH_FORCE_INLINE vec_t<N> add(vec_t<N> a, vec_t<N> b)
{
static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::add");
if constexpr (N == 128)
{
return _mm_add_epi64(a, b);
}
if constexpr (N == 256)
{
return _mm256_add_epi64(a, b);
}
if constexpr (N == 512)
{
return _mm512_add_epi64(a, b);
}
if constexpr (N == 64)
{
return a + b;
}
}
template <size_t N, uint8_t S1, uint8_t S2, uint8_t S3, uint8_t S4>
XXH_FORCE_INLINE vec_t<N> shuffle(vec_t<N> a)
{
static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::shuffle");
if constexpr (N == 128)
{
return _mm_shuffle_epi32(a, static_cast<intrin::mm_perm_enum_t>(_MM_SHUFFLE(S1, S2, S3, S4)));
}
if constexpr (N == 256)
{
return _mm256_shuffle_epi32(a, static_cast<intrin::mm_perm_enum_t>(_MM_SHUFFLE(S1, S2, S3, S4)));
}
if constexpr (N == 512)
{
return _mm512_shuffle_epi32(a, static_cast<intrin::mm_perm_enum_t>(_MM_SHUFFLE(S1, S2, S3, S4)));
}
if constexpr (N == 64)
{
return a;
}
}
template <size_t N>
XXH_FORCE_INLINE vec_t<N> set1(int64_t a)
{
#if (defined(__ARM_NEON) && defined(__APPLE__))
static_assert(!(N != 128 && N != 64), "Invalid argument passed to xxh::vec_ops::set1");
#else
static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::set1");
if constexpr (N == 256)
{
return _mm256_set1_epi32(static_cast<int>(a));
}
if constexpr (N == 512)
{
return _mm512_set1_epi32(static_cast<int>(a));
}
#endif
if constexpr (N == 128)
{
return _mm_set1_epi32(static_cast<int>(a));
}
if constexpr (N == 64)
{
return a;
}
}
template <size_t N>
XXH_FORCE_INLINE vec_t<N> srli(vec_t<N> n, int a)
{
static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::srli");
if constexpr (N == 128)
{
return _mm_srli_epi64(n, a);
}
if constexpr (N == 256)
{
return _mm256_srli_epi64(n, a);
}
if constexpr (N == 512)
{
return _mm512_srli_epi64(n, a);
}
if constexpr (N == 64)
{
return n >> a;
}
}
template <size_t N>
XXH_FORCE_INLINE vec_t<N> slli(vec_t<N> n, int a)
{
static_assert(!(N != 128 && N != 256 && N != 64 && N != 512), "Invalid argument passed to xxh::vec_ops::slli");
if constexpr (N == 128)
{
return _mm_slli_epi64(n, a);
}
if constexpr (N == 256)
{
return _mm256_slli_epi64(n, a);
}
if constexpr (N == 512)
{
return _mm512_slli_epi64(n, a);
}
if constexpr (N == 64)
{
return n << a;
}
}
}
/* *************************************
* Canonical represenation
***************************************/
template <size_t bit_mode>
struct canonical_t
{
std::array<uint8_t, bit_mode / 8> digest{ 0 };
canonical_t(hash_t<bit_mode> hash)
{
if constexpr (bit_mode < 128)
{
if (mem_ops::is_little_endian())
{
hash = bit_ops::swap<bit_mode>(hash);
}
memcpy(digest.data(), &hash, sizeof(canonical_t<bit_mode>));
}
else
{
if (mem_ops::is_little_endian())
{
hash.low64 = bit_ops::swap<64>(hash.low64);
hash.high64 = bit_ops::swap<64>(hash.high64);
}
memcpy(digest.data(), &hash.high64, sizeof(hash.high64));
memcpy(digest.data() + sizeof(hash.high64), &hash.low64, sizeof(hash.low64));
}
}
hash_t<bit_mode> get_hash() const
{
if constexpr (bit_mode < 128)
{
return mem_ops::readBE<bit_mode>(&digest);
}
else
{
return { mem_ops::readBE<64>(&digest[8]), mem_ops::readBE<64>(&digest) };
}
}
};
using canonical32_t = canonical_t<32>;
using canonical64_t = canonical_t<64>;
using canonical128_t = canonical_t<128>;
template <size_t bit_mode>
inline hash_t<bit_mode> to_canonical(hash_t<bit_mode> hash)
{
static_assert(!(bit_mode != 128 && bit_mode != 64 && bit_mode != 32), "Canonical form can only be obtained from 32, 64 and 128 bit hashes.");
canonical_t<bit_mode> canon(hash);
hash_t<bit_mode> res;
memcpy(&res, &canon, bit_mode / 8);
return res;
}
/* *************************************
* Algorithm Implementation - xxhash
***************************************/
namespace detail
{
using namespace mem_ops;
using namespace bit_ops;
/* *************************************
* Constants
***************************************/
constexpr static std::array<uint32_t, 5> primes32 = { 2654435761U, 2246822519U, 3266489917U, 668265263U, 374761393U };
constexpr static std::array<uint64_t, 5> primes64 = { 11400714785074694791ULL, 14029467366897019727ULL, 1609587929392839161ULL, 9650029242287828579ULL, 2870177450012600261ULL };
template <size_t N>
constexpr uint_t<N> PRIME(uint64_t n)
{
if constexpr (N == 32)
{
return primes32[n - 1];
}
else
{
return primes64[n - 1];
}
}
/* *************************************
* Functions
***************************************/
template <size_t N>
XXH_FORCE_INLINE uint_t<N> avalanche(uint_t<N> hash)
{
if constexpr (N == 32)
{
hash ^= hash >> 15;
hash *= PRIME<32>(2);
hash ^= hash >> 13;
hash *= PRIME<32>(3);
hash ^= hash >> 16;
return hash;
}
else if constexpr (N == 64)
{
hash ^= hash >> 33;
hash *= PRIME<64>(2);
hash ^= hash >> 29;
hash *= PRIME<64>(3);
hash ^= hash >> 32;
return hash;
}
else return 0;
}
template <size_t N>
XXH_FORCE_INLINE uint_t<N> round(uint_t<N> seed, uint_t<N> input)
{
seed += input * PRIME<N>(2);
if constexpr (N == 32)
{
seed = rotl<N>(seed, 13);
}
else
{
seed = rotl<N>(seed, 31);
}
seed *= PRIME<N>(1);
return seed;
}
XXH_FORCE_INLINE uint64_t mergeRound64(hash64_t acc, uint64_t val)
{
val = round<64>(0, val);
acc ^= val;
acc = acc * PRIME<64>(1) + PRIME<64>(4);
return acc;
}
XXH_FORCE_INLINE void endian_align_sub_mergeround(hash64_t& hash_ret, uint64_t v1, uint64_t v2, uint64_t v3, uint64_t v4)
{
hash_ret = mergeRound64(hash_ret, v1);
hash_ret = mergeRound64(hash_ret, v2);
hash_ret = mergeRound64(hash_ret, v3);
hash_ret = mergeRound64(hash_ret, v4);
}
template <size_t N>
static inline hash_t<N> endian_align_sub_ending(hash_t<N> hash_ret, const uint8_t* p, const uint8_t* bEnd)
{
if constexpr (N == 32)
{
while ((p + 4) <= bEnd)
{
hash_ret += readLE<32>(p) * PRIME<32>(3);
hash_ret = rotl<32>(hash_ret, 17) * PRIME<32>(4);
p += 4;
}
while (p < bEnd)
{
hash_ret += (*p) * PRIME<32>(5);
hash_ret = rotl<32>(hash_ret, 11) * PRIME<32>(1);
p++;
}
return avalanche<32>(hash_ret);
}
else
{
while (p + 8 <= bEnd)
{
const uint64_t k1 = round<64>(0, readLE<64>(p));
hash_ret ^= k1;
hash_ret = rotl<64>(hash_ret, 27) * PRIME<64>(1) + PRIME<64>(4);
p += 8;
}
if (p + 4 <= bEnd)
{
hash_ret ^= static_cast<uint64_t>(readLE<32>(p))* PRIME<64>(1);
hash_ret = rotl<64>(hash_ret, 23) * PRIME<64>(2) + PRIME<64>(3);
p += 4;
}
while (p < bEnd)
{
hash_ret ^= (*p) * PRIME<64>(5);
hash_ret = rotl<64>(hash_ret, 11) * PRIME<64>(1);
p++;
}
return avalanche<64>(hash_ret);
}
}
template <size_t N>
static inline hash_t<N> endian_align(const void* input, size_t len, uint_t<N> seed)
{
static_assert(!(N != 32 && N != 64), "You can only call endian_align in 32 or 64 bit mode.");
const uint8_t* p = static_cast<const uint8_t*>(input);
const uint8_t* bEnd = p + len;
hash_t<N> hash_ret;
if (len >= (N / 2))
{
const uint8_t* const limit = bEnd - (N / 2);
uint_t<N> v1 = seed + PRIME<N>(1) + PRIME<N>(2);
uint_t<N> v2 = seed + PRIME<N>(2);
uint_t<N> v3 = seed + 0;
uint_t<N> v4 = seed - PRIME<N>(1);
do
{
v1 = round<N>(v1, readLE<N>(p));
p += (N / 8);
v2 = round<N>(v2, readLE<N>(p));
p += (N / 8);
v3 = round<N>(v3, readLE<N>(p));
p += (N / 8);
v4 = round<N>(v4, readLE<N>(p));
p += (N / 8);
}
while (p <= limit);
hash_ret = rotl<N>(v1, 1) + rotl<N>(v2, 7) + rotl<N>(v3, 12) + rotl<N>(v4, 18);
if constexpr (N == 64)
{
endian_align_sub_mergeround(hash_ret, v1, v2, v3, v4);
}
}
else
{
hash_ret = seed + PRIME<N>(5);
}
hash_ret += static_cast<hash_t<N>>(len);
return endian_align_sub_ending<N>(hash_ret, p, bEnd);
}
}
/* *************************************
* Algorithm Implementation - xxhash3
***************************************/
namespace detail3
{
using namespace vec_ops;
using namespace detail;
using namespace mem_ops;
using namespace bit_ops;
/* *************************************
* Enums
***************************************/
enum class vec_mode : uint8_t { scalar = 0, sse2 = 1, avx2 = 2, avx512 = 3 };
/* *************************************
* Constants
***************************************/
constexpr uint64_t secret_default_size = 192;
constexpr uint64_t secret_size_min = 136;
constexpr uint64_t secret_consume_rate = 8;
constexpr uint64_t stripe_len = 64;
constexpr uint64_t acc_nb = 8;
constexpr uint64_t prefetch_distance = 384;
constexpr uint64_t secret_lastacc_start = 7;
constexpr uint64_t secret_mergeaccs_start = 11;
constexpr uint64_t midsize_max = 240;
constexpr uint64_t midsize_startoffset = 3;
constexpr uint64_t midsize_lastoffset = 17;
constexpr vec_mode vector_mode = static_cast<vec_mode>(intrin::vector_mode);
constexpr uint64_t acc_align = intrin::acc_align;
constexpr std::array<uint64_t, 4> vector_bit_width { 64, 128, 256, 512 };
/* *************************************
* Defaults
***************************************/
alignas(64) constexpr uint8_t default_secret[secret_default_size] = {
0xb8, 0xfe, 0x6c, 0x39, 0x23, 0xa4, 0x4b, 0xbe, 0x7c, 0x01, 0x81, 0x2c, 0xf7, 0x21, 0xad, 0x1c,
0xde, 0xd4, 0x6d, 0xe9, 0x83, 0x90, 0x97, 0xdb, 0x72, 0x40, 0xa4, 0xa4, 0xb7, 0xb3, 0x67, 0x1f,
0xcb, 0x79, 0xe6, 0x4e, 0xcc, 0xc0, 0xe5, 0x78, 0x82, 0x5a, 0xd0, 0x7d, 0xcc, 0xff, 0x72, 0x21,
0xb8, 0x08, 0x46, 0x74, 0xf7, 0x43, 0x24, 0x8e, 0xe0, 0x35, 0x90, 0xe6, 0x81, 0x3a, 0x26, 0x4c,
0x3c, 0x28, 0x52, 0xbb, 0x91, 0xc3, 0x00, 0xcb, 0x88, 0xd0, 0x65, 0x8b, 0x1b, 0x53, 0x2e, 0xa3,
0x71, 0x64, 0x48, 0x97, 0xa2, 0x0d, 0xf9, 0x4e, 0x38, 0x19, 0xef, 0x46, 0xa9, 0xde, 0xac, 0xd8,
0xa8, 0xfa, 0x76, 0x3f, 0xe3, 0x9c, 0x34, 0x3f, 0xf9, 0xdc, 0xbb, 0xc7, 0xc7, 0x0b, 0x4f, 0x1d,
0x8a, 0x51, 0xe0, 0x4b, 0xcd, 0xb4, 0x59, 0x31, 0xc8, 0x9f, 0x7e, 0xc9, 0xd9, 0x78, 0x73, 0x64,
0xea, 0xc5, 0xac, 0x83, 0x34, 0xd3, 0xeb, 0xc3, 0xc5, 0x81, 0xa0, 0xff, 0xfa, 0x13, 0x63, 0xeb,
0x17, 0x0d, 0xdd, 0x51, 0xb7, 0xf0, 0xda, 0x49, 0xd3, 0x16, 0x55, 0x26, 0x29, 0xd4, 0x68, 0x9e,
0x2b, 0x16, 0xbe, 0x58, 0x7d, 0x47, 0xa1, 0xfc, 0x8f, 0xf8, 0xb8, 0xd1, 0x7a, 0xd0, 0x31, 0xce,
0x45, 0xcb, 0x3a, 0x8f, 0x95, 0x16, 0x04, 0x28, 0xaf, 0xd7, 0xfb, 0xca, 0xbb, 0x4b, 0x40, 0x7e,
};
constexpr std::array<uint64_t, 8> init_acc = { PRIME<32>(3), PRIME<64>(1), PRIME<64>(2), PRIME<64>(3), PRIME<64>(4), PRIME<32>(2), PRIME<64>(5), PRIME<32>(1) };
/* *************************************
* Functions
***************************************/
XXH_FORCE_INLINE hash_t<64> avalanche(hash_t<64> h64)
{
constexpr uint64_t avalanche_mul_prime = 0x165667919E3779F9ULL;
h64 ^= h64 >> 37;
h64 *= avalanche_mul_prime;
h64 ^= h64 >> 32;
return h64;
}
XXH_FORCE_INLINE hash_t<64> rrmxmx(hash_t<64> h64, uint64_t len)
{
h64 ^= rotl<64>(h64, 49) ^ rotl<64>(h64, 24);
h64 *= 0x9FB21C651E98DF25ULL;
h64 ^= (h64 >> 35) + len;
h64 *= 0x9FB21C651E98DF25ULL;
h64 ^= (h64 >> 28);
return h64;
}
XXH_FORCE_INLINE void combine_16(void* dest, hash128_t h128)
{
writeLE<64>(dest, readLE<64>(dest) ^ h128.low64);
writeLE<64>((uint8_t*)dest + 8, readLE<64>((uint8_t*)dest + 8) ^ h128.high64);
}
XXH_FORCE_INLINE void accumulate_512(void* XXH_RESTRICT acc, const void* XXH_RESTRICT input, const void* XXH_RESTRICT secret)
{
constexpr uint64_t bits = vector_bit_width[static_cast<uint8_t>(vector_mode)];
using vec_t = vec_t<bits>;
alignas(sizeof(vec_t)) vec_t* const xacc = static_cast<vec_t*>(acc);
const vec_t* const xinput = static_cast<const vec_t*>(input);
const vec_t* const xsecret = static_cast<const vec_t*>(secret);
for (size_t i = 0; i < stripe_len / sizeof(vec_t); i++)
{
vec_t const data_vec = loadu<bits>(xinput + i);
vec_t const key_vec = loadu<bits>(xsecret + i);
vec_t const data_key = xorv<bits>(data_vec, key_vec);
vec_t product = set1<bits>(0);
if constexpr (vector_mode == vec_mode::scalar)
{
product = mul32to64<bits>(srli<bits>(slli<bits>(data_key, 32),32), srli<bits>(data_key, 32));
xacc[i ^ 1] = add<bits>(xacc[i ^ 1], data_vec);
xacc[i] = add<bits>(xacc[i], product);
}
else
{
vec_t const data_key_lo = shuffle<bits, 0, 3, 0, 1>(data_key);
product = mul<bits>(data_key, data_key_lo);
vec_t const data_swap = shuffle<bits, 1, 0, 3, 2>(data_vec);
vec_t const sum = add<bits>(xacc[i], data_swap);
xacc[i] = add<bits>(sum, product);
}
}
}
XXH_FORCE_INLINE void scramble_acc(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)
{
constexpr uint64_t bits = vector_bit_width[static_cast<uint8_t>(vector_mode)];;
using vec_t = vec_t<bits>;
alignas(sizeof(vec_t)) vec_t* const xacc = (vec_t*)acc;
const vec_t* const xsecret = (const vec_t*)secret;
for (size_t i = 0; i < stripe_len / sizeof(vec_t); i++)
{
vec_t const acc_vec = xacc[i];
vec_t const shifted = srli<bits>(acc_vec, 47);
vec_t const data_vec = xorv<bits>(acc_vec, shifted);
vec_t const key_vec = loadu<bits>(xsecret + i);
vec_t const data_key = xorv<bits>(data_vec, key_vec);
if constexpr (vector_mode == vec_mode::scalar)
{
xacc[i] = mul<bits>(data_key, set1<bits>(PRIME<32>(1)));
}
else
{
vec_t const prime32 = set1<bits>(PRIME<32>(1));
vec_t const data_key_hi = shuffle<bits, 0, 3, 0, 1>(data_key);
vec_t const prod_lo = mul<bits>(data_key, prime32);
vec_t const prod_hi = mul<bits>(data_key_hi, prime32);
xacc[i] = add<bits>(prod_lo, vec_ops::slli<bits>(prod_hi, 32));
}
}
}
XXH_FORCE_INLINE void accumulate(uint64_t* XXH_RESTRICT acc, const uint8_t* XXH_RESTRICT input, const uint8_t* XXH_RESTRICT secret, size_t nbStripes)
{
for (size_t n = 0; n < nbStripes; n++)
{
const uint8_t* const in = input + n * stripe_len;
intrin::prefetch(in + prefetch_distance);
accumulate_512(acc, in, secret + n * secret_consume_rate);
}
}
XXH_FORCE_INLINE void hash_long_internal_loop(uint64_t* XXH_RESTRICT acc, const uint8_t* XXH_RESTRICT input, size_t len, const uint8_t* XXH_RESTRICT secret, size_t secretSize)
{
size_t const nb_rounds = (secretSize - stripe_len) / secret_consume_rate;
size_t const block_len = stripe_len * nb_rounds;
size_t const nb_blocks = (len-1) / block_len;
for (size_t n = 0; n < nb_blocks; n++)
{
accumulate(acc, input + n * block_len, secret, nb_rounds);
scramble_acc(acc, secret + secretSize - stripe_len);
}
/* last partial block */
size_t const nbStripes = ((len - 1) - (block_len * nb_blocks)) / stripe_len;
accumulate(acc, input + nb_blocks * block_len, secret, nbStripes);
/* last stripe */
const uint8_t* const p = input + len - stripe_len;
accumulate_512(acc, p, secret + secretSize - stripe_len - secret_lastacc_start);
}
XXH_FORCE_INLINE uint64_t mix_2_accs(const uint64_t* XXH_RESTRICT acc, const uint8_t* XXH_RESTRICT secret)
{
return mul128fold64(acc[0] ^ readLE<64>(secret), acc[1] ^ readLE<64>(secret + 8));
}
XXH_FORCE_INLINE uint64_t merge_accs(const uint64_t* XXH_RESTRICT acc, const uint8_t* XXH_RESTRICT secret, uint64_t start)
{
uint64_t result64 = start;
result64 += mix_2_accs(acc + 0, secret + 0);
result64 += mix_2_accs(acc + 2, secret + 16);
result64 += mix_2_accs(acc + 4, secret + 32);
result64 += mix_2_accs(acc + 6, secret + 48);
return avalanche(result64);
}
XXH_FORCE_INLINE void init_custom_secret(uint8_t* customSecret, uint64_t seed)
{
for (uint64_t i = 0; i < secret_default_size / 16; i++)
{
writeLE<64>(customSecret + i * 16, readLE<64>(default_secret + i * 16) + seed);
writeLE<64>(customSecret + i * 16 + 8, readLE<64>(default_secret + i * 16 + 8) - seed);
}
}
template <size_t N>
XXH_FORCE_INLINE hash_t<N> len_1to3(const uint8_t* input, size_t len, const uint8_t* secret, uint64_t seed)
{
if constexpr (N == 64)
{
uint8_t const c1 = input[0];
uint8_t const c2 = input[len >> 1];
uint8_t const c3 = input[len - 1];
uint32_t const combined = ((uint32_t)c1 << 16) | (((uint32_t)c2) << 24) | (((uint32_t)c3) << 0) | (((uint32_t)len) << 8);
uint64_t const bitflip = (readLE<32>(secret) ^ readLE<32>(secret + 4)) + seed;
uint64_t const keyed = (uint64_t)combined ^ bitflip;
return detail::avalanche<64>(keyed);
}
else
{
uint8_t const c1 = input[0];
uint8_t const c2 = input[len >> 1];
uint8_t const c3 = input[len - 1];
uint32_t const combinedl = ((uint32_t)c1 << 16) + (((uint32_t)c2) << 24) + (((uint32_t)c3) << 0) + (((uint32_t)len) << 8);
uint32_t const combinedh = rotl<32>(swap<32>(combinedl), 13);
uint64_t const bitflipl = (readLE<32>(secret) ^ readLE<32>(secret + 4)) + seed;
uint64_t const bitfliph = (readLE<32>(secret + 8) ^ readLE<32>(secret + 12)) - seed;
uint64_t const keyed_lo = (uint64_t)combinedl ^ bitflipl;
uint64_t const keyed_hi = (uint64_t)combinedh ^ bitfliph;
hash128_t const h128 = { detail::avalanche<64>(keyed_lo), detail::avalanche<64>(keyed_hi)};
return h128;
}
}
template <size_t N>
XXH_FORCE_INLINE hash_t<N> len_4to8(const uint8_t* input, size_t len, const uint8_t* secret, uint64_t seed)
{
constexpr uint64_t mix_constant = 0x9FB21C651E98DF25ULL;
seed ^= (uint64_t)swap<32>((uint32_t)seed) << 32;
if constexpr (N == 64)
{
uint32_t const input1 = readLE<32>(input);
uint32_t const input2 = readLE<32>(input + len - 4);
uint64_t const bitflip = (readLE<64>(secret + 8) ^ readLE<64>(secret + 16)) - seed;
uint64_t const input64 = input2 + ((uint64_t)input1 << 32);
uint64_t keyed = input64 ^ bitflip;
return rrmxmx(keyed, len);
}
else
{
uint32_t const input_lo = readLE<32>(input);
uint32_t const input_hi = readLE<32>(input + len - 4);
uint64_t const input_64 = input_lo + ((uint64_t)input_hi << 32);
uint64_t const bitflip = (readLE<64>(secret + 16) ^ readLE<64>(secret + 24)) + seed;
uint64_t const keyed = input_64 ^ bitflip;
uint128_t m128 = mul64to128(keyed, PRIME<64>(1) + (len << 2));
m128.high64 += (m128.low64 << 1);
m128.low64 ^= (m128.high64 >> 3);
m128.low64 ^= (m128.low64 >> 35);
m128.low64 *= mix_constant;
m128.low64 ^= (m128.low64 >> 28);
m128.high64 = avalanche(m128.high64);
return m128;
}
}
template <size_t N>
XXH_FORCE_INLINE hash_t<N> len_9to16(const uint8_t* input, size_t len, const uint8_t* secret, uint64_t seed)
{
if constexpr (N == 64)
{
uint64_t const bitflip1 = (readLE<64>(secret + 24) ^ readLE<64>(secret + 32)) + seed;
uint64_t const bitflip2 = (readLE<64>(secret + 40) ^ readLE<64>(secret + 48)) - seed;
uint64_t const input_lo = readLE<64>(input) ^ bitflip1;
uint64_t const input_hi = readLE<64>(input + len - 8) ^ bitflip2;
uint64_t const acc = len + swap<64>(input_lo) + input_hi + mul128fold64(input_lo, input_hi);
return avalanche(acc);
}
else
{
uint64_t const bitflipl = (readLE<64>(secret + 32) ^ readLE<64>(secret + 40)) - seed;
uint64_t const bitfliph = (readLE<64>(secret + 48) ^ readLE<64>(secret + 56)) + seed;
uint64_t const input_lo = readLE<64>(input);
uint64_t input_hi = readLE<64>(input + len - 8);
uint128_t m128 = mul64to128(input_lo ^ input_hi ^ bitflipl, PRIME<64>(1));
m128.low64 += (uint64_t)(len - 1) << 54;
input_hi ^= bitfliph;
if constexpr (sizeof(void*) < sizeof(uint64_t)) // 32-bit version
{
m128.high64 += (input_hi & 0xFFFFFFFF00000000) + mul32to64((uint32_t)input_hi, PRIME<32>(2));
}
else
{
m128.high64 += input_hi + mul32to64((uint32_t)input_hi, PRIME<32>(2) - 1);
}
m128.low64 ^= swap<64>(m128.high64);
hash128_t h128 = mul64to128(m128.low64, PRIME<64>(2));
h128.high64 += m128.high64 * PRIME<64>(2);
h128.low64 = avalanche(h128.low64);
h128.high64 = avalanche(h128.high64);
return h128;
}
}
template <size_t N>
XXH_FORCE_INLINE hash_t<N> len_0to16(const uint8_t* input, size_t len, const uint8_t* secret, uint64_t seed)
{
if (XXH_likely(len > 8))
{
return len_9to16<N>(input, len, secret, seed);
}
else if (XXH_likely(len >= 4))
{
return len_4to8<N>(input, len, secret, seed);
}
else if (len)
{
return len_1to3<N>(input, len, secret, seed);
}
else
{
if constexpr (N == 64)
{
return detail::avalanche<64>((seed) ^ (readLE<64>(secret + 56) ^ readLE<64>(secret + 64)));
}
else
{
uint64_t const bitflipl = readLE<64>(secret + 64) ^ readLE<64>(secret + 72);
uint64_t const bitfliph = readLE<64>(secret + 80) ^ readLE<64>(secret + 88);
return hash128_t(detail::avalanche<64>(( seed) ^ bitflipl), detail::avalanche<64>(( seed) ^ bitfliph));
}
}
}
template <size_t N>
XXH_FORCE_INLINE hash_t<N> hash_long_internal(const uint8_t* XXH_RESTRICT input, size_t len, const uint8_t* XXH_RESTRICT secret = default_secret, size_t secretSize = sizeof(default_secret))
{
alignas(acc_align) std::array<uint64_t, acc_nb> acc = init_acc;
if constexpr (N == 64)
{
hash_long_internal_loop(acc.data(), input, len, secret, secretSize);
/* converge into final hash */
return merge_accs(acc.data(), secret + secret_mergeaccs_start, (uint64_t)len * PRIME<64>(1));
}
else
{
hash_long_internal_loop(acc.data(), input, len, secret, secretSize);
/* converge into final hash */
uint64_t const low64 = merge_accs(acc.data(), secret + secret_mergeaccs_start, (uint64_t)len * PRIME<64>(1));
uint64_t const high64 = merge_accs(acc.data(), secret + secretSize - sizeof(acc) - secret_mergeaccs_start, ~((uint64_t)len * PRIME<64>(2)));
return hash128_t(low64, high64);
}
}
XXH_FORCE_INLINE uint64_t mix_16b(const uint8_t* XXH_RESTRICT input, const uint8_t* XXH_RESTRICT secret, uint64_t seed)
{
uint64_t const input_lo = readLE<64>(input);
uint64_t const input_hi = readLE<64>(input + 8);
return mul128fold64(input_lo ^ (readLE<64>(secret) + seed), input_hi ^ (readLE<64>(secret + 8) - seed));
}
XXH_FORCE_INLINE uint128_t mix_32b(uint128_t acc, const uint8_t* input1, const uint8_t* input2, const uint8_t* secret, uint64_t seed)
{
acc.low64 += mix_16b(input1, secret + 0, seed);
acc.low64 ^= readLE<64>(input2) + readLE<64>(input2 + 8);
acc.high64 += mix_16b(input2, secret + 16, seed);
acc.high64 ^= readLE<64>(input1) + readLE<64>(input1 + 8);
return acc;
}
template <size_t N>
XXH_FORCE_INLINE hash_t<N> len_17to128(const uint8_t* XXH_RESTRICT input, size_t len, const uint8_t* XXH_RESTRICT secret, uint64_t seed)
{
if constexpr (N == 64)
{
hash64_t acc = len * PRIME<64>(1);
if (len > 32)
{
if (len > 64)
{
if (len > 96)
{
acc += mix_16b(input + 48, secret + 96, seed);
acc += mix_16b(input + len - 64, secret + 112, seed);
}
acc += mix_16b(input + 32, secret + 64, seed);
acc += mix_16b(input + len - 48, secret + 80, seed);
}
acc += mix_16b(input + 16, secret + 32, seed);
acc += mix_16b(input + len - 32, secret + 48, seed);
}
acc += mix_16b(input + 0, secret + 0, seed);
acc += mix_16b(input + len - 16, secret + 16, seed);
return avalanche(acc);
}
else
{
hash128_t acc = { len * PRIME<64>(1), 0 };
if (len > 32)
{
if (len > 64)
{
if (len > 96)
{
acc = mix_32b(acc, input + 48, input + len - 64, secret + 96, seed);
}
acc = mix_32b(acc, input + 32, input + len - 48, secret + 64, seed);
}
acc = mix_32b(acc, input + 16, input + len - 32, secret + 32, seed);
}
acc = mix_32b(acc, input, input + len - 16, secret, seed);
uint64_t const low64 = acc.low64 + acc.high64;
uint64_t const high64 = (acc.low64 * PRIME<64>(1)) + (acc.high64 * PRIME<64>(4)) + ((len - seed) * PRIME<64>(2));
return { avalanche(low64), (uint64_t)0 - avalanche(high64) };
}
}
template <size_t N>
XXH_NO_INLINE hash_t<N> len_129to240(const uint8_t* XXH_RESTRICT input, size_t len, const uint8_t* XXH_RESTRICT secret, uint64_t seed)
{
if constexpr (N == 64)
{
uint64_t acc = len * PRIME<64>(1);
size_t const nbRounds = len / 16;
for (size_t i = 0; i < 8; i++)
{
acc += mix_16b(input + (i * 16), secret + (i * 16), seed);
}
acc = avalanche(acc);
for (size_t i = 8; i < nbRounds; i++)
{
acc += mix_16b(input + (i * 16), secret + ((i - 8) * 16) + midsize_startoffset, seed);
}
/* last bytes */
acc += mix_16b(input + len - 16, secret + secret_size_min - midsize_lastoffset, seed);
return avalanche(acc);
}
else
{
hash128_t acc;
uint64_t const nbRounds = len / 32;
acc.low64 = len * PRIME<64>(1);
acc.high64 = 0;
for (size_t i = 0; i < 4; i++)
{
acc = mix_32b(acc, input + (i * 32), input + (i * 32) + 16, secret + (i * 32), seed);
}
acc.low64 = avalanche(acc.low64);
acc.high64 = avalanche(acc.high64);
for (size_t i = 4; i < nbRounds; i++)
{
acc = mix_32b(acc, input + (i * 32), input + (i * 32) + 16, secret + midsize_startoffset + ((i - 4) * 32), seed);
}
/* last bytes */
acc = mix_32b(acc, input + len - 16, input + len - 32, secret + secret_size_min - midsize_lastoffset - 16, 0ULL - seed);
uint64_t const low64 = acc.low64 + acc.high64;
uint64_t const high64 = (acc.low64 * PRIME<64>(1)) + (acc.high64 * PRIME<64>(4)) + ((len - seed) * PRIME<64>(2));
return { avalanche(low64), (uint64_t)0 - avalanche(high64) };
}
}
template <size_t N>
XXH_NO_INLINE hash_t<N> xxhash3_impl(const void* XXH_RESTRICT input, size_t len, hash64_t seed, const void* XXH_RESTRICT secret = default_secret, size_t secretSize = secret_default_size, bool forceSeedUse = false)
{
alignas(64) uint8_t custom_secret[secret_default_size];
const void* short_secret = secret;
if (seed != 0 || forceSeedUse)
{
init_custom_secret(custom_secret, seed);
short_secret = default_secret;
}
if (len <= 16)
{
return len_0to16<N>(static_cast<const uint8_t*>(input), len, static_cast<const uint8_t*>(short_secret), seed);
}
else if (len <= 128)
{
return len_17to128<N>(static_cast<const uint8_t*>(input), len, static_cast<const uint8_t*>(short_secret), seed);
}
else if (len <= midsize_max)
{
return len_129to240<N>(static_cast<const uint8_t*>(input), len, static_cast<const uint8_t*>(short_secret), seed);
}
else
{
return hash_long_internal<N>(static_cast<const uint8_t*>(input), len, static_cast<const uint8_t*>(((seed == 0) ? secret : ((secret == default_secret) ? custom_secret : secret))), ((seed == 0) ? secretSize : ((secret == default_secret) ? secret_default_size : secretSize)));
}
}
XXH_NO_INLINE void generate_secret(void* secret_buffer, size_t secret_size, const void* custom_seed, size_t seed_size)
{
if (seed_size == 0)
{
custom_seed = default_secret;
seed_size = secret_default_size;
}
size_t pos = 0;
while (pos < secret_size)
{
size_t const copy_len = std::min(secret_size - pos, seed_size);
memcpy((uint8_t*)secret_buffer + pos, custom_seed, copy_len);
pos += copy_len;
}
size_t const nbseg16 = secret_size / 16;
canonical128_t scrambled(xxhash3_impl<128>(custom_seed, seed_size, 0));
for (size_t n = 0; n < nbseg16; n++)
{
hash128_t const h128 = xxhash3_impl<128>(&scrambled, sizeof(scrambled), n);
combine_16((uint8_t*)secret_buffer + n * 16, h128);
}
combine_16((uint8_t*)secret_buffer + secret_size - 16, scrambled.get_hash());
}
}
/* *************************************
* Public Access Point - xxhash
***************************************/
template <size_t bit_mode>
inline hash_t<bit_mode> xxhash(const void* input, size_t len, uint_t<bit_mode> seed = 0)
{
static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash can only be used in 32 and 64 bit modes.");
return detail::endian_align<bit_mode>(input, len, seed);
}
template <size_t bit_mode, typename T>
inline hash_t<bit_mode> xxhash(const std::basic_string<T>& input, uint_t<bit_mode> seed = 0)
{
static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash can only be used in 32 and 64 bit modes.");
return detail::endian_align<bit_mode>(static_cast<const void*>(input.data()), input.length() * sizeof(T), seed);
}
template <size_t bit_mode, typename ContiguousIterator>
inline hash_t<bit_mode> xxhash(ContiguousIterator begin, ContiguousIterator end, uint_t<bit_mode> seed = 0)
{
static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash can only be used in 32 and 64 bit modes.");
using T = typename std::decay_t<decltype(*end)>;
return detail::endian_align<bit_mode>(static_cast<const void*>(&*begin), (end - begin) * sizeof(T), seed);
}
template <size_t bit_mode, typename T>
inline hash_t<bit_mode> xxhash(const std::vector<T>& input, uint_t<bit_mode> seed = 0)
{
static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash can only be used in 32 and 64 bit modes.");
return detail::endian_align<bit_mode>(static_cast<const void*>(input.data()), input.size() * sizeof(T), seed);
}
template <size_t bit_mode, typename T, size_t AN>
inline hash_t<bit_mode> xxhash(const std::array<T, AN>& input, uint_t<bit_mode> seed = 0)
{
static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash can only be used in 32 and 64 bit modes.");
return detail::endian_align<bit_mode>(static_cast<const void*>(input.data()), AN * sizeof(T), seed);
}
template <size_t bit_mode, typename T>
inline hash_t<bit_mode> xxhash(const std::initializer_list<T>& input, uint_t<bit_mode> seed = 0)
{
static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash can only be used in 32 and 64 bit modes.");
return detail::endian_align<bit_mode>(static_cast<const void*>(input.begin()), input.size() * sizeof(T), seed);
}
/* *************************************
* Public Access Point - xxhash3
***************************************/
template <size_t bit_mode>
inline hash_t<bit_mode> xxhash3(const void* input, size_t len, uint64_t seed = 0)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(input, len, seed);
}
template <size_t bit_mode>
inline hash_t<bit_mode> xxhash3(const void* input, size_t len, const void* secret, size_t secretSize)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(input, len, 0, secret, secretSize);
}
template <size_t bit_mode>
inline hash_t<bit_mode> xxhash3(const void* input, size_t len, const void* secret, size_t secretSize, uint64_t seed)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(input, len, seed, secret, secretSize, true);
}
template <size_t bit_mode, typename T>
inline hash_t<bit_mode> xxhash3(const std::basic_string<T>& input, uint64_t seed = 0)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), input.length() * sizeof(T), seed);
}
template <size_t bit_mode, typename T>
inline hash_t<bit_mode> xxhash3(const std::basic_string<T>& input, const void* secret, size_t secretSize)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), input.length() * sizeof(T), 0, secret, secretSize);
}
template <size_t bit_mode, typename T>
inline hash_t<bit_mode> xxhash3(const std::basic_string<T>& input, const void* secret, size_t secretSize, uint64_t seed)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), input.length() * sizeof(T), seed, secret, secretSize, true);
}
template <size_t bit_mode, typename ContiguousIterator>
inline hash_t<bit_mode> xxhash3(ContiguousIterator begin, ContiguousIterator end, uint64_t seed = 0)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
using T = typename std::decay_t<decltype(*end)>;
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(&*begin), (end - begin) * sizeof(T), seed);
}
template <size_t bit_mode, typename ContiguousIterator>
inline hash_t<bit_mode> xxhash3(ContiguousIterator begin, ContiguousIterator end, const void* secret, size_t secretSize)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
using T = typename std::decay_t<decltype(*end)>;
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(&*begin), (end - begin) * sizeof(T), 0, secret, secretSize);
}
template <size_t bit_mode, typename ContiguousIterator>
inline hash_t<bit_mode> xxhash3(ContiguousIterator begin, ContiguousIterator end, const void* secret, size_t secretSize, uint64_t seed)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
using T = typename std::decay_t<decltype(*end)>;
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(&*begin), (end - begin) * sizeof(T), seed, secret, secretSize, true);
}
template <size_t bit_mode, typename T>
inline hash_t<bit_mode> xxhash3(const std::vector<T>& input, uint64_t seed = 0)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), input.size() * sizeof(T), seed);
}
template <size_t bit_mode, typename T>
inline hash_t<bit_mode> xxhash3(const std::vector<T>& input, const void* secret, size_t secretSize)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), input.size() * sizeof(T), 0, secret, secretSize);
}
template <size_t bit_mode, typename T>
inline hash_t<bit_mode> xxhash3(const std::vector<T>& input, const void* secret, size_t secretSize, uint64_t seed)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), input.size() * sizeof(T), seed, secret, secretSize, true);
}
template <size_t bit_mode, typename T, size_t AN>
inline hash_t<bit_mode> xxhash3(const std::array<T, AN>& input, uint64_t seed = 0)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), AN * sizeof(T), seed);
}
template <size_t bit_mode, typename T, size_t AN>
inline hash_t<bit_mode> xxhash3(const std::array<T, AN>& input, const void* secret, size_t secretSize)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), AN * sizeof(T), 0, secret, secretSize);
}
template <size_t bit_mode, typename T, size_t AN>
inline hash_t<bit_mode> xxhash3(const std::array<T, AN>& input, const void* secret, size_t secretSize, uint64_t seed)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.data()), AN * sizeof(T), seed, secret, secretSize, true);
}
template <size_t bit_mode, typename T>
inline hash_t<bit_mode> xxhash3(const std::initializer_list<T>& input, uint64_t seed = 0)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.begin()), input.size() * sizeof(T), seed);
}
template <size_t bit_mode, typename T>
inline hash_t<bit_mode> xxhash3(const std::initializer_list<T>& input, const void* secret, size_t secretSize)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.begin()), input.size() * sizeof(T), 0, secret, secretSize);
}
template <size_t bit_mode, typename T>
inline hash_t<bit_mode> xxhash3(const std::initializer_list<T>& input, const void* secret, size_t secretSize, uint64_t seed)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 can only be used in 64 and 128 bit modes.");
return detail3::xxhash3_impl<bit_mode>(static_cast<const void*>(input.begin()), input.size() * sizeof(T), seed, secret, secretSize, true);
}
/* *************************************
* Secret Generation Functions
***************************************/
inline void generate_secret(void* secret_buffer, size_t secret_size, const void* custom_seed = detail3::default_secret, size_t seed_length = 0)
{
detail3::generate_secret(secret_buffer, secret_size, custom_seed, seed_length);
}
template <typename T, size_t AN>
inline void generate_secret(void* secret_buffer, size_t secret_size, const std::array<T, AN>& custom_seed)
{
detail3::generate_secret(secret_buffer, secret_size, static_cast<const void*>(custom_seed.data()), AN * sizeof(T));
}
template <typename T>
inline void generate_secret(void* secret_buffer, size_t secret_size, const std::initializer_list<T>& custom_seed)
{
detail3::generate_secret(secret_buffer, secret_size, static_cast<const void*>(custom_seed.begin()), custom_seed.size() * sizeof(T));
}
template <typename T>
inline void generate_secret(void* secret_buffer, size_t secret_size, const std::vector<T>& custom_seed)
{
detail3::generate_secret(secret_buffer, secret_size, static_cast<const void*>(custom_seed.data()), custom_seed.size() * sizeof(T));
}
template <typename T>
inline void generate_secret(void* secret_buffer, size_t secret_size, const std::basic_string<T>& custom_seed)
{
detail3::generate_secret(secret_buffer, secret_size, static_cast<const void*>(custom_seed.data()), custom_seed.length() * sizeof(T));
}
template <typename ContiguousIterator>
inline void generate_secret(void* secret_buffer, size_t secret_size, ContiguousIterator begin, ContiguousIterator end)
{
using T = typename std::decay_t<decltype(*end)>;
detail3::generate_secret(secret_buffer, secret_size, static_cast<const void*>(&*begin), (end - begin) * sizeof(T));
}
inline void generate_secret_from_seed(void* secret_buffer, uint64_t seed = 0)
{
alignas(64) uint8_t custom_secret[detail3::secret_default_size];
detail3::init_custom_secret(custom_secret, seed);
memcpy(secret_buffer, custom_secret, detail3::secret_default_size);
}
/* *************************************
* Hash streaming - xxhash
***************************************/
template <size_t bit_mode>
class hash_state_t
{
uint64_t total_len = 0;
uint_t<bit_mode> v1 = 0, v2 = 0, v3 = 0, v4 = 0;
std::array<hash_t<bit_mode>, 4> mem = {0, 0, 0, 0};
uint32_t memsize = 0;
inline void update_impl(const void* input, size_t length)
{
const uint8_t* p = reinterpret_cast<const uint8_t*>(input);
const uint8_t* const bEnd = p + length;
total_len += length;
if (memsize + length < (bit_mode / 2))
{ /* fill in tmp buffer */
memcpy(reinterpret_cast<uint8_t*>(mem.data()) + memsize, input, length);
memsize += static_cast<uint32_t>(length);
return;
}
if (memsize > 0)
{ /* some data left from previous update */
memcpy(reinterpret_cast<uint8_t*>(mem.data()) + memsize, input, (bit_mode / 2) - memsize);
const uint_t<bit_mode>* ptr = mem.data();
v1 = detail::round<bit_mode>(v1, mem_ops::readLE<bit_mode>(ptr));
ptr++;
v2 = detail::round<bit_mode>(v2, mem_ops::readLE<bit_mode>(ptr));
ptr++;
v3 = detail::round<bit_mode>(v3, mem_ops::readLE<bit_mode>(ptr));
ptr++;
v4 = detail::round<bit_mode>(v4, mem_ops::readLE<bit_mode>(ptr));
p += (bit_mode / 2) - memsize;
memsize = 0;
}
while (p + (bit_mode / 2) <= bEnd)
{
v1 = detail::round<bit_mode>(v1, mem_ops::readLE<bit_mode>(p));
p += (bit_mode / 8);
v2 = detail::round<bit_mode>(v2, mem_ops::readLE<bit_mode>(p));
p += (bit_mode / 8);
v3 = detail::round<bit_mode>(v3, mem_ops::readLE<bit_mode>(p));
p += (bit_mode / 8);
v4 = detail::round<bit_mode>(v4, mem_ops::readLE<bit_mode>(p));
p += (bit_mode / 8);
}
if (p < bEnd)
{
memcpy(mem.data(), p, static_cast<size_t>(bEnd - p));
memsize = static_cast<uint32_t>(bEnd - p);
}
}
inline hash_t<bit_mode> digest_impl() const
{
const uint8_t* p = reinterpret_cast<const uint8_t*>(mem.data());
const uint8_t* const bEnd = reinterpret_cast<const uint8_t*>(mem.data()) + memsize;
hash_t<bit_mode> hash_ret;
if (total_len >= (bit_mode / 2))
{
hash_ret = bit_ops::rotl<bit_mode>(v1, 1) + bit_ops::rotl<bit_mode>(v2, 7) + bit_ops::rotl<bit_mode>(v3, 12) + bit_ops::rotl<bit_mode>(v4, 18);
if constexpr (bit_mode == 64)
{
detail::endian_align_sub_mergeround(hash_ret, v1, v2, v3, v4);
}
}
else
{
hash_ret = v3 + detail::PRIME<bit_mode>(5);
}
hash_ret += static_cast<hash_t<bit_mode>>(total_len);
return detail::endian_align_sub_ending<bit_mode>(hash_ret, p, bEnd);
}
public:
hash_state_t(uint_t<bit_mode> seed = 0)
{
static_assert(!(bit_mode != 32 && bit_mode != 64), "xxhash streaming can only be used in 32 and 64 bit modes.");
v1 = seed + detail::PRIME<bit_mode>(1) + detail::PRIME<bit_mode>(2);
v2 = seed + detail::PRIME<bit_mode>(2);
v3 = seed + 0;
v4 = seed - detail::PRIME<bit_mode>(1);
};
void reset(uint_t<bit_mode> seed = 0)
{
memset(this, 0, sizeof(hash_state_t<bit_mode>));
v1 = seed + detail::PRIME<bit_mode>(1) + detail::PRIME<bit_mode>(2);
v2 = seed + detail::PRIME<bit_mode>(2);
v3 = seed + 0;
v4 = seed - detail::PRIME<bit_mode>(1);
}
void update(const void* input, size_t length)
{
return update_impl(input, length);
}
template <typename T>
void update(const std::basic_string<T>& input)
{
return update_impl(static_cast<const void*>(input.data()), input.length() * sizeof(T));
}
template <typename ContiguousIterator>
void update(ContiguousIterator begin, ContiguousIterator end)
{
using T = typename std::decay_t<decltype(*end)>;
return update_impl(static_cast<const void*>(&*begin), (end - begin) * sizeof(T));
}
template <typename T>
void update(const std::vector<T>& input)
{
return update_impl(static_cast<const void*>(input.data()), input.size() * sizeof(T));
}
template <typename T, size_t AN>
void update(const std::array<T, AN>& input)
{
return update_impl(static_cast<const void*>(input.data()), AN * sizeof(T));
}
template <typename T>
void update(const std::initializer_list<T>& input)
{
return update_impl(static_cast<const void*>(input.begin()), input.size() * sizeof(T));
}
hash_t<bit_mode> digest() const
{
return digest_impl();
}
};
using hash_state32_t = hash_state_t<32>;
using hash_state64_t = hash_state_t<64>;
/* *************************************
* Hash streaming - xxhash3
***************************************/
template <size_t bit_mode>
class alignas(64) hash3_state_t
{
constexpr static int internal_buffer_size = 256;
constexpr static int internal_buffer_stripes = (internal_buffer_size / detail3::stripe_len);
alignas(64) uint64_t acc[8];
alignas(64) uint8_t customSecret[detail3::secret_default_size]; /* used to store a custom secret generated from the seed. Makes state larger. Design might change */
alignas(64) uint8_t buffer[internal_buffer_size];
uint32_t bufferedSize = 0;
uint32_t nbStripesPerBlock = 0;
uint32_t nbStripesSoFar = 0;
uint32_t secretLimit = 0;
uint32_t reserved32 = 0;
uint32_t reserved32_2 = 0;
uint64_t totalLen = 0;
uint64_t seed = 0;
bool useSeed = false;
uint64_t reserved64 = 0;
const uint8_t* secret = nullptr; /* note : there is some padding after, due to alignment on 64 bytes */
void consume_stripes(uint64_t* acc, uint32_t& nbStripesSoFar, size_t totalStripes, const uint8_t* input)
{
if (nbStripesPerBlock - nbStripesSoFar <= totalStripes) /* need a scrambling operation */
{
size_t const nbStripes = nbStripesPerBlock - nbStripesSoFar;
detail3::accumulate(acc, input, secret + (nbStripesSoFar * detail3::secret_consume_rate), nbStripes);
detail3::scramble_acc(acc, secret + secretLimit);
detail3::accumulate(acc, input + nbStripes * detail3::stripe_len, secret, totalStripes - nbStripes);
nbStripesSoFar = (uint32_t)(totalStripes - nbStripes);
}
else
{
detail3::accumulate(acc, input, secret + (nbStripesSoFar * detail3::secret_consume_rate), totalStripes);
nbStripesSoFar += (uint32_t)totalStripes;
}
}
void update_impl(const void* input_, size_t len)
{
const uint8_t* input = static_cast<const uint8_t*>(input_);
const uint8_t* const bEnd = input + len;
totalLen += len;
if (bufferedSize + len <= internal_buffer_size)
{ /* fill in tmp buffer */
memcpy(buffer + bufferedSize, input, len);
bufferedSize += (uint32_t)len;
return;
}
/* input now > XXH3_INTERNALBUFFER_SIZE */
if (bufferedSize > 0)
{ /* some input within internal buffer: fill then consume it */
size_t const loadSize = internal_buffer_size - bufferedSize;
memcpy(buffer + bufferedSize, input, loadSize);
input += loadSize;
consume_stripes(acc, nbStripesSoFar, internal_buffer_stripes, buffer);
bufferedSize = 0;
}
/* consume input by full buffer quantities */
if (input + internal_buffer_size <= bEnd)
{
const uint8_t* const limit = bEnd - internal_buffer_size;
do
{
consume_stripes(acc, nbStripesSoFar, internal_buffer_stripes, input);
input += internal_buffer_size;
}
while (input < limit);
memcpy(buffer + sizeof(buffer) - detail3::stripe_len, input - detail3::stripe_len, detail3::stripe_len);
}
if (input < bEnd)
{ /* some remaining input input : buffer it */
memcpy(buffer, input, (size_t)(bEnd - input));
bufferedSize = (uint32_t)(bEnd - input);
}
}
void digest_long(uint64_t* acc_)
{
memcpy(acc_, acc, sizeof(acc)); /* digest locally, state remains unaltered, and can continue ingesting more input afterwards */
if (bufferedSize >= detail3::stripe_len)
{
size_t const totalNbStripes = (bufferedSize - 1) / detail3::stripe_len;
uint32_t nbStripesSoFar = this->nbStripesSoFar;
consume_stripes(acc_, nbStripesSoFar, totalNbStripes, buffer);
/* one last partial stripe */
detail3::accumulate_512(acc_, buffer + bufferedSize - detail3::stripe_len, secret + secretLimit - detail3::secret_lastacc_start);
}
else
{ /* bufferedSize < STRIPE_LEN */
/* one last stripe */
uint8_t lastStripe[detail3::stripe_len];
size_t const catchupSize = detail3::stripe_len - bufferedSize;
memcpy(lastStripe, buffer + sizeof(buffer) - catchupSize, catchupSize);
memcpy(lastStripe + catchupSize, buffer, bufferedSize);
detail3::accumulate_512(acc_, lastStripe, secret + secretLimit - detail3::secret_lastacc_start);
}
}
void reset_internal(uint64_t seed_reset, const void* secret_reset, size_t secret_size)
{
memset(this, 0, sizeof(*this));
memcpy(acc, detail3::init_acc.data(), sizeof(detail3::init_acc));
seed = seed_reset;
useSeed = (seed != 0);
secret = (const uint8_t*)secret_reset;
secretLimit = (uint32_t)(secret_size - detail3::stripe_len);
nbStripesPerBlock = secretLimit / detail3::secret_consume_rate;
}
public:
hash3_state_t operator=(hash3_state_t& other)
{
memcpy(this, &other, sizeof(hash3_state_t));
}
hash3_state_t(uint64_t seed = 0)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 streaming can only be used in 64 and 128 bit modes.");
reset(seed);
}
hash3_state_t(const void* secret, size_t secretSize)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 streaming can only be used in 64 and 128 bit modes.");
reset(secret, secretSize);
}
hash3_state_t(const void* secret, size_t secretSize, uint64_t seed)
{
static_assert(!(bit_mode != 128 && bit_mode != 64), "xxhash3 streaming can only be used in 64 and 128 bit modes.");
reset(secret, secretSize, seed);
}
void reset(uint64_t seed = 0)
{
reset_internal(seed, detail3::default_secret, detail3::secret_default_size);
detail3::init_custom_secret(customSecret, seed);
secret = customSecret;
}
void reset(const void* secret, size_t secretSize)
{
reset_internal(0, secret, secretSize);
}
void reset(const void* secret, size_t secretSize, uint64_t seed)
{
reset_internal(seed, secret, secretSize);
useSeed = true;
}
void update(const void* input, size_t len)
{
return update_impl(static_cast<const void*>(input), len);
}
template <typename T>
void update(const std::basic_string<T>& input)
{
return update_impl(static_cast<const void*>(input.data()), input.length() * sizeof(T));
}
template <typename ContiguousIterator>
void update(ContiguousIterator begin, ContiguousIterator end)
{
using T = typename std::decay_t<decltype(*end)>;
return update_impl(static_cast<const void*>(&*begin), (end - begin) * sizeof(T));
}
template <typename T>
void update(const std::vector<T>& input)
{
return update_impl(static_cast<const void*>(input.data()), input.size() * sizeof(T));
}
template <typename T, size_t AN>
void update(const std::array<T, AN>& input)
{
return update_impl(static_cast<const void*>(input.data()), AN * sizeof(T));
}
template <typename T>
void update(const std::initializer_list<T>& input)
{
return update_impl(static_cast<const void*>(input.begin()), input.size() * sizeof(T));
}
hash_t<bit_mode> digest()
{
if (totalLen > detail3::midsize_max)
{
alignas(128) hash64_t acc[detail3::acc_nb];
digest_long(acc);
if constexpr (bit_mode == 64)
{
return detail3::merge_accs(acc, secret + detail3::secret_mergeaccs_start, (uint64_t)totalLen * detail::PRIME<64>(1));
}
else
{
uint64_t const low64 = detail3::merge_accs(acc, secret + detail3::secret_mergeaccs_start, (uint64_t)totalLen * detail::PRIME<64>(1));
uint64_t const high64 = detail3::merge_accs(acc, secret + secretLimit + detail3::stripe_len - sizeof(acc) - detail3::secret_mergeaccs_start, ~((uint64_t)totalLen * detail::PRIME<64>(2)));
return { low64, high64 };
}
}
else
{
if (useSeed)
{
return detail3::xxhash3_impl<bit_mode>(buffer, totalLen, seed);
}
return detail3::xxhash3_impl<bit_mode>(buffer, totalLen, seed, secret, secretLimit + detail3::stripe_len);
}
}
};
using hash3_state64_t = hash3_state_t<64>;
using hash3_state128_t = hash3_state_t<128>;
}
================================================
FILE: test/CMakeLists.txt
================================================
option(XXH_CPP_USE_AVX2 "Use AVX2 instructions for tests" OFF)
function(xxh_cpp_add_test name xxh_vector)
add_executable(${name} test_main.cpp)
target_link_libraries(${name} PRIVATE xxhash_cpp)
target_compile_definitions(${name} PRIVATE -DXXH_VECTOR=${xxh_vector})
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
target_compile_options(${name} PRIVATE -Wall -Wextra -pedantic -Werror)
elseif(MSVC)
target_compile_options(${name} PRIVATE /W3 /WX)
endif()
if(XXH_CPP_USE_AVX2)
if(MSVC)
target_compile_options(${name} PRIVATE /arch:AVX2)
else()
target_compile_options(${name} PRIVATE -mavx2)
endif()
endif()
add_test(NAME ${name} COMMAND ${name})
endfunction()
xxh_cpp_add_test(test_scalar 0)
xxh_cpp_add_test(test_sse2 1)
xxh_cpp_add_test(test_avx2 2)
================================================
FILE: test/catch.hpp
================================================
/*
* Catch v2.13.10
* Generated: 2022-10-16 11:01:23.452308
* ----------------------------------------------------------
* This file has been merged from multiple headers. Please don't edit it directly
* Copyright (c) 2022 Two Blue Cubes Ltd. All rights reserved.
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
// start catch.hpp
#define CATCH_VERSION_MAJOR 2
#define CATCH_VERSION_MINOR 13
#define CATCH_VERSION_PATCH 10
#ifdef __clang__
# pragma clang system_header
#elif defined __GNUC__
# pragma GCC system_header
#endif
// start catch_suppress_warnings.h
#ifdef __clang__
# ifdef __ICC // icpc defines the __clang__ macro
# pragma warning(push)
# pragma warning(disable: 161 1682)
# else // __ICC
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wpadded"
# pragma clang diagnostic ignored "-Wswitch-enum"
# pragma clang diagnostic ignored "-Wcovered-switch-default"
# endif
#elif defined __GNUC__
// Because REQUIREs trigger GCC's -Wparentheses, and because still
// supported version of g++ have only buggy support for _Pragmas,
// Wparentheses have to be suppressed globally.
# pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wunused-variable"
# pragma GCC diagnostic ignored "-Wpadded"
#endif
// end catch_suppress_warnings.h
#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
# define CATCH_IMPL
# define CATCH_CONFIG_ALL_PARTS
#endif
// In the impl file, we want to have access to all parts of the headers
// Can also be used to sanely support PCHs
#if defined(CATCH_CONFIG_ALL_PARTS)
# define CATCH_CONFIG_EXTERNAL_INTERFACES
# if defined(CATCH_CONFIG_DISABLE_MATCHERS)
# undef CATCH_CONFIG_DISABLE_MATCHERS
# endif
# if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
# define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
# endif
#endif
#if !defined(CATCH_CONFIG_IMPL_ONLY)
// start catch_platform.h
// See e.g.:
// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html
#ifdef __APPLE__
# include <TargetConditionals.h>
# if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \
(defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)
# define CATCH_PLATFORM_MAC
# elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)
# define CATCH_PLATFORM_IPHONE
# endif
#elif defined(linux) || defined(__linux) || defined(__linux__)
# define CATCH_PLATFORM_LINUX
#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
# define CATCH_PLATFORM_WINDOWS
#endif
// end catch_platform.h
#ifdef CATCH_IMPL
# ifndef CLARA_CONFIG_MAIN
# define CLARA_CONFIG_MAIN_NOT_DEFINED
# define CLARA_CONFIG_MAIN
# endif
#endif
// start catch_user_interfaces.h
namespace Catch {
unsigned int rngSeed();
}
// end catch_user_interfaces.h
// start catch_tag_alias_autoregistrar.h
// start catch_common.h
// start catch_compiler_capabilities.h
// Detect a number of compiler features - by compiler
// The following features are defined:
//
// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
// ****************
// Note to maintainers: if new toggles are added please document them
// in configuration.md, too
// ****************
// In general each macro has a _NO_<feature name> form
// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
// Many features, at point of detection, define an _INTERNAL_ macro, so they
// can be combined, en-mass, with the _NO_ forms later.
#ifdef __cplusplus
# if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
# define CATCH_CPP14_OR_GREATER
# endif
# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
# define CATCH_CPP17_OR_GREATER
# endif
#endif
// Only GCC compiler should be used in this block, so other compilers trying to
// mask themselves as GCC should be ignored.
#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__)
# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic pop" )
# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
#endif
#if defined(__clang__)
# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic pop" )
// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
// which results in calls to destructors being emitted for each temporary,
// without a matching initialization. In practice, this can result in something
// like `std::string::~string` being called on an uninitialized value.
//
// For example, this code will likely segfault under IBM XL:
// ```
// REQUIRE(std::string("12") + "34" == "1234")
// ```
//
// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
# if !defined(__ibmxl__) && !defined(__CUDACC__)
# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
# endif
# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
_Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
_Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
_Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
_Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
_Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
_Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
#endif // __clang__
////////////////////////////////////////////////////////////////////////////////
// Assume that non-Windows platforms support posix signals by default
#if !defined(CATCH_PLATFORM_WINDOWS)
#define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
#endif
////////////////////////////////////////////////////////////////////////////////
// We know some environments not to support full POSIX signals
#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
#define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
#endif
#ifdef __OS400__
# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
# define CATCH_CONFIG_COLOUR_NONE
#endif
////////////////////////////////////////////////////////////////////////////////
// Android somehow still does not support std::to_string
#if defined(__ANDROID__)
# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
# define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
#endif
////////////////////////////////////////////////////////////////////////////////
// Not all Windows environments support SEH properly
#if defined(__MINGW32__)
# define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
#endif
////////////////////////////////////////////////////////////////////////////////
// PS4
#if defined(__ORBIS__)
# define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
#endif
////////////////////////////////////////////////////////////////////////////////
// Cygwin
#ifdef __CYGWIN__
// Required for some versions of Cygwin to declare gettimeofday
// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
# define _BSD_SOURCE
// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
&& !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
# endif
#endif // __CYGWIN__
////////////////////////////////////////////////////////////////////////////////
// Visual C++
#if defined(_MSC_VER)
// Universal Windows platform does not support SEH
// Or console colours (or console at all...)
# if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
# define CATCH_CONFIG_COLOUR_NONE
# else
# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
# endif
# if !defined(__clang__) // Handle Clang masquerading for msvc
// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
# if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
# define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
# endif // MSVC_TRADITIONAL
// Only do this if we're not using clang on Windows, which uses `diagnostic push` & `diagnostic pop`
# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION __pragma( warning(pop) )
# endif // __clang__
#endif // _MSC_VER
#if defined(_REENTRANT) || defined(_MSC_VER)
// Enable async processing, as -pthread is specified or no additional linking is required
# define CATCH_INTERNAL_CONFIG_USE_ASYNC
#endif // _MSC_VER
////////////////////////////////////////////////////////////////////////////////
// Check if we are compiled with -fno-exceptions or equivalent
#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
# define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
#endif
////////////////////////////////////////////////////////////////////////////////
// DJGPP
#ifdef __DJGPP__
# define CATCH_INTERNAL_CONFIG_NO_WCHAR
#endif // __DJGPP__
////////////////////////////////////////////////////////////////////////////////
// Embarcadero C++Build
#if defined(__BORLANDC__)
#define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
#endif
////////////////////////////////////////////////////////////////////////////////
// Use of __COUNTER__ is suppressed during code analysis in
// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
// handled by it.
// Otherwise all supported compilers support COUNTER macro,
// but user still might want to turn it off
#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
#define CATCH_INTERNAL_CONFIG_COUNTER
#endif
////////////////////////////////////////////////////////////////////////////////
// RTX is a special version of Windows that is real time.
// This means that it is detected as Windows, but does not provide
// the same set of capabilities as real Windows does.
#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
#define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
#define CATCH_INTERNAL_CONFIG_NO_ASYNC
#define CATCH_CONFIG_COLOUR_NONE
#endif
#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
#endif
// Various stdlib support checks that require __has_include
#if defined(__has_include)
// Check if string_view is available and usable
#if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
# define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
#endif
// Check if optional is available and usable
# if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
# define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
# endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
// Check if byte is available and usable
# if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
# include <cstddef>
# if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0)
# define CATCH_INTERNAL_CONFIG_CPP17_BYTE
# endif
# endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
// Check if variant is available and usable
# if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
# if defined(__clang__) && (__clang_major__ < 8)
// work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
// fix should be in clang 8, workaround in libstdc++ 8.2
# include <ciso646>
# if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
# define CATCH_CONFIG_NO_CPP17_VARIANT
# else
# define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
# endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
# else
# define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
# endif // defined(__clang__) && (__clang_major__ < 8)
# endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
#endif // defined(__has_include)
#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
# define CATCH_CONFIG_COUNTER
#endif
#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
# define CATCH_CONFIG_WINDOWS_SEH
#endif
// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
# define CATCH_CONFIG_POSIX_SIGNALS
#endif
// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
# define CATCH_CONFIG_WCHAR
#endif
#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
# define CATCH_CONFIG_CPP11_TO_STRING
#endif
#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
# define CATCH_CONFIG_CPP17_OPTIONAL
#endif
#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
# define CATCH_CONFIG_CPP17_STRING_VIEW
#endif
#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
# define CATCH_CONFIG_CPP17_VARIANT
#endif
#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
# define CATCH_CONFIG_CPP17_BYTE
#endif
#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
# define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
#endif
#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
# define CATCH_CONFIG_NEW_CAPTURE
#endif
#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
# define CATCH_CONFIG_DISABLE_EXCEPTIONS
#endif
#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
# define CATCH_CONFIG_POLYFILL_ISNAN
#endif
#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
# define CATCH_CONFIG_USE_ASYNC
#endif
#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
# define CATCH_CONFIG_ANDROID_LOGWRITE
#endif
#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
# define CATCH_CONFIG_GLOBAL_NEXTAFTER
#endif
// Even if we do not think the compiler has that warning, we still have
// to provide a macro that can be used by the code.
#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
#endif
#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
#endif
// The goal of this macro is to avoid evaluation of the arguments, but
// still have the compiler warn on problems inside...
#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
# define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
#endif
#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
#elif defined(__clang__) && (__clang_major__ < 5)
# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
#endif
#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
#define CATCH_TRY if ((true))
#define CATCH_CATCH_ALL if ((false))
#define CATCH_CATCH_ANON(type) if ((false))
#else
#define CATCH_TRY try
#define CATCH_CATCH_ALL catch (...)
#define CATCH_CATCH_ANON(type) catch (type)
#endif
#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#endif
// end catch_compiler_capabilities.h
#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
#ifdef CATCH_CONFIG_COUNTER
# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
#else
# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
#endif
#include <iosfwd>
#include <string>
#include <cstdint>
// We need a dummy global operator<< so we can bring it into Catch namespace later
struct Catch_global_namespace_dummy {};
std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
namespace Catch {
struct CaseSensitive { enum Choice {
Yes,
No
}; };
class NonCopyable {
NonCopyable( NonCopyable const& ) = delete;
NonCopyable( NonCopyable && ) = delete;
NonCopyable& operator = ( NonCopyable const& ) = delete;
NonCopyable& operator = ( NonCopyable && ) = delete;
protected:
NonCopyable();
virtual ~NonCopyable();
};
struct SourceLineInfo {
SourceLineInfo() = delete;
SourceLineInfo( char const* _file, std::size_t _line ) noexcept
: file( _file ),
line( _line )
{}
SourceLineInfo( SourceLineInfo const& other ) = default;
SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
SourceLineInfo( SourceLineInfo&& ) noexcept = default;
SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
bool empty() const noexcept { return file[0] == '\0'; }
bool operator == ( SourceLineInfo const& other ) const noexcept;
bool operator < ( SourceLineInfo const& other ) const noexcept;
char const* file;
std::size_t line;
};
std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
// Bring in operator<< from global namespace into Catch namespace
// This is necessary because the overload of operator<< above makes
// lookup stop at namespace Catch
using ::operator<<;
// Use this in variadic streaming macros to allow
// >> +StreamEndStop
// as well as
// >> stuff +StreamEndStop
struct StreamEndStop {
std::string operator+() const;
};
template<typename T>
T const& operator + ( T const& value, StreamEndStop ) {
return value;
}
}
#define CATCH_INTERNAL_LINEINFO \
::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
// end catch_common.h
namespace Catch {
struct RegistrarForTagAliases {
RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
};
} // end namespace Catch
#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
// end catch_tag_alias_autoregistrar.h
// start catch_test_registry.h
// start catch_interfaces_testcase.h
#include <vector>
namespace Catch {
class TestSpec;
struct ITestInvoker {
virtual void invoke () const = 0;
virtual ~ITestInvoker();
};
class TestCase;
struct IConfig;
struct ITestCaseRegistry {
virtual ~ITestCaseRegistry();
virtual std::vector<TestCase> const& getAllTests() const = 0;
virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
};
bool isThrowSafe( TestCase const& testCase, IConfig const& config );
bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
}
// end catch_interfaces_testcase.h
// start catch_stringref.h
#include <cstddef>
#include <string>
#include <iosfwd>
#include <cassert>
namespace Catch {
/// A non-owning string class (similar to the forthcoming std::string_view)
/// Note that, because a StringRef may be a substring of another string,
/// it may not be null terminated.
class StringRef {
public:
using size_type = std::size_t;
using const_iterator = const char*;
private:
static constexpr char const* const s_empty = "";
char const* m_start = s_empty;
size_type m_size = 0;
public: // construction
constexpr StringRef() noexcept = default;
StringRef( char const* rawChars ) noexcept;
constexpr StringRef( char const* rawChars, size_type size ) noexcept
: m_start( rawChars ),
m_size( size )
{}
StringRef( std::string const& stdString ) noexcept
: m_start( stdString.c_str() ),
m_size( stdString.size() )
{}
explicit operator std::string() const {
return std::string(m_start, m_size);
}
public: // operators
auto operator == ( StringRef const& other ) const noexcept -> bool;
auto operator != (StringRef const& other) const noexcept -> bool {
return !(*this == other);
}
auto operator[] ( size_type index ) const noexcept -> char {
assert(index < m_size);
return m_start[index];
}
public: // named queries
constexpr auto empty() const noexcept -> bool {
return m_size == 0;
}
constexpr auto size() const noexcept -> size_type {
return m_size;
}
// Returns the current start pointer. If the StringRef is not
// null-terminated, throws std::domain_exception
auto c_str() const -> char const*;
public: // substrings and searches
// Returns a substring of [start, start + length).
// If start + length > size(), then the substring is [start, size()).
// If start > size(), then the substring is empty.
auto substr( size_type start, size_type length ) const noexcept -> StringRef;
// Returns the current start pointer. May not be null-terminated.
auto data() const noexcept -> char const*;
constexpr auto isNullTerminated() const noexcept -> bool {
return m_start[m_size] == '\0';
}
public: // iterators
constexpr const_iterator begin() const { return m_start; }
constexpr const_iterator end() const { return m_start + m_size; }
};
auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
return StringRef( rawChars, size );
}
} // namespace Catch
constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
return Catch::StringRef( rawChars, size );
}
// end catch_stringref.h
// start catch_preprocessor.hpp
#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
// MSVC needs more evaluations
#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
#else
#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__)
#endif
#define CATCH_REC_END(...)
#define CATCH_REC_OUT
#define CATCH_EMPTY()
#define CATCH_DEFER(id) id CATCH_EMPTY()
#define CATCH_REC_GET_END2() 0, CATCH_REC_END
#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
#define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
#define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
// and passes userdata as the first parameter to each invocation,
// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
#else
// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
#endif
#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
#else
#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
#endif
#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)
#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
#define INTERNAL_CATCH_TYPE_GEN\
template<typename...> struct TypeList {};\
template<typename...Ts>\
constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
template<template<typename...> class...> struct TemplateTypeList{};\
template<template<typename...> class...Cs>\
constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
template<typename...>\
struct append;\
template<typename...>\
struct rewrap;\
template<template<typename...> class, typename...>\
struct create;\
template<template<typename...> class, typename>\
struct convert;\
\
template<typename T> \
struct append<T> { using type = T; };\
template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
template< template<typename...> class L1, typename...E1, typename...Rest>\
struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
\
template< template<typename...> class Container, template<typename...> class List, typename...elems>\
struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
\
template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
#define INTERNAL_CATCH_NTTP_1(signature, ...)\
template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
\
template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
static void TestName()
#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
static void TestName()
#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
static void TestName()
#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
static void TestName()
#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
template<typename Type>\
void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
{\
Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
}
#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
{\
Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
}
#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
template<typename Type>\
void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
{\
Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
}
#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
{\
Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
}
#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
template<typename TestType> \
struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
void test();\
}
#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
void test();\
}
#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
template<typename TestType> \
void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_NTTP_0
#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
#else
#define INTERNAL_CATCH_NTTP_0(signature)
#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
#endif
// end catch_preprocessor.hpp
// start catch_meta.hpp
#include <type_traits>
namespace Catch {
template<typename T>
struct always_false : std::false_type {};
template <typename> struct true_given : std::true_type {};
struct is_callable_tester {
template <typename Fun, typename... Args>
true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
template <typename...>
std::false_type static test(...);
};
template <typename T>
struct is_callable;
template <typename Fun, typename... Args>
struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
// std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
// replaced with std::invoke_result here.
template <typename Func, typename... U>
using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U...>>>;
#else
// Keep ::type here because we still support C++11
template <typename Func, typename... U>
using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U...)>::type>::type>::type;
#endif
} // namespace Catch
namespace mpl_{
struct na;
}
// end catch_meta.hpp
namespace Catch {
template<typename C>
class TestInvokerAsMethod : public ITestInvoker {
void (C::*m_testAsMethod)();
public:
TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
void invoke() const override {
C obj;
(obj.*m_testAsMethod)();
}
};
auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
template<typename C>
auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
}
struct NameAndTags {
NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
StringRef name;
StringRef tags;
};
struct AutoReg : NonCopyable {
AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
~AutoReg();
};
} // end namespace Catch
#if defined(CATCH_CONFIG_DISABLE)
#define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
static void TestName()
#define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
namespace{ \
struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
void test(); \
}; \
} \
void TestName::test()
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... ) \
INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
namespace{ \
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
} \
} \
INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename TestType, __VA_ARGS__ )
#else
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
#endif
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ )
#else
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ ) )
#endif
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
#else
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
#endif
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
#else
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
#endif
#endif
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
static void TestName(); \
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
static void TestName()
#define INTERNAL_CATCH_TESTCASE( ... ) \
INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ), __VA_ARGS__ )
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
namespace{ \
struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
void test(); \
}; \
Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
} \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
void TestName::test()
#define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ), ClassName, __VA_ARGS__ )
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
namespace {\
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
INTERNAL_CATCH_TYPE_GEN\
INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
template<typename...Types> \
struct TestName{\
TestName(){\
int index = 0; \
constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
using expander = int[];\
(void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
}\
};\
static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
return 0;\
}();\
}\
}\
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename TestType, __VA_ARGS__ )
#else
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
#endif
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ )
#else
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ ) )
#endif
#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
template<typename TestType> static void TestFuncName(); \
namespace {\
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
INTERNAL_CATCH_TYPE_GEN \
INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature)) \
template<typename... Types> \
struct TestName { \
void reg_tests() { \
int index = 0; \
using expander = int[]; \
constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
(void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++)... };/* NOLINT */\
} \
}; \
static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
TestInit t; \
t.reg_tests(); \
return 0; \
}(); \
} \
} \
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
template<typename TestType> \
static void TestFuncName()
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename T,__VA_ARGS__)
#else
#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename T, __VA_ARGS__ ) )
#endif
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__)
#else
#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ ) )
#endif
#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
template<typename TestType> static void TestFunc(); \
namespace {\
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
INTERNAL_CATCH_TYPE_GEN\
template<typename... Types> \
struct TestName { \
void reg_tests() { \
int index = 0; \
using expander = int[]; \
(void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
} \
};\
static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
using TestInit = typename convert<TestName, TmplList>::type; \
TestInit t; \
t.reg_tests(); \
return 0; \
}(); \
}}\
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
template<typename TestType> \
static void TestFunc()
#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, TmplList )
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
namespace {\
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
INTERNAL_CATCH_TYPE_GEN\
INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
template<typename...Types> \
struct TestNameClass{\
TestNameClass(){\
int index = 0; \
constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
using expander = int[];\
(void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
}\
};\
static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
return 0;\
}();\
}\
}\
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
#else
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
#endif
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
#else
#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
#endif
#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
template<typename TestType> \
struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
void test();\
};\
namespace {\
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
INTERNAL_CATCH_TYPE_GEN \
INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
template<typename...Types>\
struct TestNameClass{\
void reg_tests(){\
int index = 0;\
using expander = int[];\
constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
(void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++)... };/* NOLINT */ \
}\
};\
static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
TestInit t;\
t.reg_tests();\
return 0;\
}(); \
}\
}\
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
template<typename TestType> \
void TestName<TestType>::test()
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
#else
#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
#endif
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
#else
#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
#endif
#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
template<typename TestType> \
struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
void test();\
};\
namespace {\
namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
INTERNAL_CATCH_TYPE_GEN\
template<typename...Types>\
struct TestNameClass{\
void reg_tests(){\
int index = 0;\
using expander = int[];\
(void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
}\
};\
static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
using TestInit = typename convert<TestNameClass, TmplList>::type;\
TestInit t;\
t.reg_tests();\
return 0;\
}(); \
}}\
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
template<typename TestType> \
void TestName<TestType>::test()
#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, TmplList )
// end catch_test_registry.h
// start catch_capture.hpp
// start catch_assertionhandler.h
// start catch_assertioninfo.h
// start catch_result_type.h
namespace Catch {
// ResultWas::OfType enum
struct ResultWas { enum OfType {
Unknown = -1,
Ok = 0,
Info = 1,
Warning = 2,
FailureBit = 0x10,
ExpressionFailed = FailureBit | 1,
ExplicitFailure = FailureBit | 2,
Exception = 0x100 | FailureBit,
ThrewException = Exception | 1,
DidntThrowException = Exception | 2,
FatalErrorCondition = 0x200 | FailureBit
}; };
bool isOk( ResultWas::OfType resultType );
bool isJustInfo( int flags );
// ResultDisposition::Flags enum
struct ResultDisposition { enum Flags {
Normal = 0x01,
ContinueOnFailure = 0x02, // Failures fail test, but execution continues
FalseTest = 0x04, // Prefix expression with !
SuppressFail = 0x08 // Failures are reported but do not fail the test
}; };
ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
bool shouldContinueOnFailure( int flags );
inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
bool shouldSuppressFailure( int flags );
} // end namespace Catch
// end catch_result_type.h
namespace Catch {
struct AssertionInfo
{
StringRef macroName;
SourceLineInfo lineInfo;
StringRef capturedExpression;
ResultDisposition::Flags resultDisposition;
// We want to delete this constructor but a compiler bug in 4.8 means
// the struct is then treated as non-aggregate
//AssertionInfo() = delete;
};
} // end namespace Catch
// end catch_assertioninfo.h
// start catch_decomposer.h
// start catch_tostring.h
#include <vector>
#include <cstddef>
#include <type_traits>
#include <string>
// start catch_stream.h
#include <iosfwd>
#include <cstddef>
#include <ostream>
namespace Catch {
std::ostream& cout();
std::ostream& cerr();
std::ostream& clog();
class StringRef;
struct IStream {
virtual ~IStream();
virtual std::ostream& stream() const = 0;
};
auto makeStream( StringRef const &filename ) -> IStream const*;
class ReusableStringStream : NonCopyable {
std::size_t m_index;
std::ostream* m_oss;
public:
ReusableStringStream();
~ReusableStringStream();
auto str() const -> std::string;
template<typename T>
auto operator << ( T const& value ) -> ReusableStringStream& {
*m_oss << value;
return *this;
}
auto get() -> std::ostream& { return *m_oss; }
};
}
// end catch_stream.h
// start catch_interfaces_enum_values_registry.h
#include <vector>
namespace Catch {
namespace Detail {
struct EnumInfo {
StringRef m_name;
std::vector<std::pair<int, StringRef>> m_values;
~EnumInfo();
StringRef lookup( int value ) const;
};
} // namespace Detail
struct IMutableEnumValuesRegistry {
virtual ~IMutableEnumValuesRegistry();
virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
template<typename E>
Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
std::vector<int> intValues;
intValues.reserve( values.size() );
for( auto enumValue : values )
intValues.push_back( static_cast<int>( enumValue ) );
return registerEnum( enumName, allEnums, intValues );
}
};
} // Catch
// end catch_interfaces_enum_values_registry.h
#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
#include <string_view>
#endif
#ifdef __OBJC__
// start catch_objc_arc.hpp
#import <Foundation/Foundation.h>
#ifdef __has_feature
#define CATCH_ARC_ENABLED __has_feature(objc_arc)
#else
#define CATCH_ARC_ENABLED 0
#endif
void arcSafeRelease( NSObject* obj );
id performOptionalSelector( id obj, SEL sel );
#if !CATCH_ARC_ENABLED
inline void arcSafeRelease( NSObject* obj ) {
[obj release];
}
inline id performOptionalSelector( id obj, SEL sel ) {
if( [obj respondsToSelector: sel] )
return [obj performSelector: sel];
return nil;
}
#define CATCH_UNSAFE_UNRETAINED
#define CATCH_ARC_STRONG
#else
inline void arcSafeRelease( NSObject* ){}
inline id performOptionalSelector( id obj, SEL sel ) {
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
#endif
if( [obj respondsToSelector: sel] )
return [obj performSelector: sel];
#ifdef __clang__
#pragma clang diagnostic pop
#endif
return nil;
}
#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
#define CATCH_ARC_STRONG __strong
#endif
// end catch_objc_arc.hpp
#endif
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
#endif
namespace Catch {
namespace Detail {
extern const std::string unprintableString;
std::string rawMemoryToString( const void *object, std::size_t size );
template<typename T>
std::string rawMemoryToString( const T& object ) {
return rawMemoryToString( &object, sizeof(object) );
}
template<typename T>
class IsStreamInsertable {
template<typename Stream, typename U>
static auto test(int)
-> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
template<typename, typename>
static auto test(...)->std::false_type;
public:
static const bool value = decltype(test<std::ostream, const T&>(0))::value;
};
template<typename E>
std::string convertUnknownEnumToString( E e );
template<typename T>
typename std::enable_if<
!std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
std::string>::type convertUnstreamable( T const& ) {
return Detail::unprintableString;
}
template<typename T>
typename std::enable_if<
!std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
std::string>::type convertUnstreamable(T const& ex) {
return ex.what();
}
template<typename T>
typename std::enable_if<
std::is_enum<T>::value
, std::string>::type convertUnstreamable( T const& value ) {
return convertUnknownEnumToString( value );
}
#if defined(_MANAGED)
//! Convert a CLR string to a utf8 std::string
template<typename T>
std::string clrReferenceToString( T^ ref ) {
if (ref == nullptr)
return std::string("null");
auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
cli::pin_ptr<System::Byte> p = &bytes[0];
return std::string(reinterpret_cast<char const *>(p), bytes->Length);
}
#endif
} // namespace Detail
// If we decide for C++14, change these to enable_if_ts
template <typename T, typename = void>
struct StringMaker {
template <typename Fake = T>
static
typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
convert(const Fake& value) {
ReusableStringStream rss;
// NB: call using the function-like syntax to avoid ambiguity with
// user-defined templated operator<< under clang.
rss.operator<<(value);
return rss.str();
}
template <typename Fake = T>
static
typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
convert( const Fake& value ) {
#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
return Detail::convertUnstreamable(value);
#else
return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
#endif
}
};
namespace Detail {
// This function dispatches all stringification requests inside of Catch.
// Should be preferably called fully qualified, like ::Catch::Detail::stringify
template <typename T>
std::string stringify(const T& e) {
return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
}
template<typename E>
std::string convertUnknownEnumToString( E e ) {
return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
}
#if defined(_MANAGED)
template <typename T>
std::string stringify( T^ e ) {
return ::Catch::StringMaker<T^>::convert(e);
}
#endif
} // namespace Detail
// Some predefined specializations
template<>
struct StringMaker<std::string> {
static std::string convert(const std::string& str);
};
#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
template<>
struct StringMaker<std::string_view> {
static std::string convert(std::string_view str);
};
#endif
template<>
struct StringMaker<char const *> {
static std::string convert(char const * str);
};
template<>
struct StringMaker<char *> {
static std::string convert(char * str);
};
#ifdef CATCH_CONFIG_WCHAR
template<>
struct StringMaker<std::wstring> {
static std::string convert(const std::wstring& wstr);
};
# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
template<>
struct StringMaker<std::wstring_view> {
static std::string convert(std::wstring_view str);
};
# endif
template<>
struct StringMaker<wchar_t const *> {
static std::string convert(wchar_t const * str);
};
template<>
struct StringMaker<wchar_t *> {
static std::string convert(wchar_t * str);
};
#endif
// TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
// while keeping string semantics?
template<int SZ>
struct StringMaker<char[SZ]> {
static std::string convert(char const* str) {
return ::Catch::Detail::stringify(std::string{ str });
}
};
template<int SZ>
struct StringMaker<signed char[SZ]> {
static std::string convert(signed char const* str) {
return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
}
};
template<int SZ>
struct StringMaker<unsigned char[SZ]> {
static std::string convert(unsigned char const* str) {
return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
}
};
#if defined(CATCH_CONFIG_CPP17_BYTE)
template<>
struct StringMaker<std::byte> {
static std::string convert(std::byte value);
};
#endif // defined(CATCH_CONFIG_CPP17_BYTE)
template<>
struct StringMaker<int> {
static std::string convert(int value);
};
template<>
struct StringMaker<long> {
static std::string convert(long value);
};
template<>
struct StringMaker<long long> {
static std::string convert(long long value);
};
template<>
struct StringMaker<unsigned int> {
static std::string convert(unsigned int value);
};
template<>
struct StringMaker<unsigned long> {
static std::string convert(unsigned long value);
};
template<>
struct StringMaker<unsigned long long> {
static std::string convert(unsigned long long value);
};
template<>
struct StringMaker<bool> {
static std::string convert(bool b);
};
template<>
struct StringMaker<char> {
static std::string convert(char c);
};
template<>
struct StringMaker<signed char> {
static std::string convert(signed char c);
};
template<>
struct StringMaker<unsigned char> {
static std::string convert(unsigned char c);
};
template<>
struct StringMaker<std::nullptr_t> {
static std::string convert(std::nullptr_t);
};
template<>
struct StringMaker<float> {
static std::string convert(float value);
static int precision;
};
template<>
struct StringMaker<double> {
static std::string convert(double value);
static int precision;
};
template <typename T>
struct StringMaker<T*> {
template <typename U>
static std::string convert(U* p) {
if (p) {
return ::Catch::Detail::rawMemoryToString(p);
} else {
return "nullptr";
}
}
};
template <typename R, typename C>
struct StringMaker<R C::*> {
static std::string convert(R C::* p) {
if (p) {
return ::Catch::Detail::rawMemoryToString(p);
} else {
return "nullptr";
}
}
};
#if defined(_MANAGED)
template <typename T>
struct StringMaker<T^> {
static std::string convert( T^ ref ) {
return ::Catch::Detail::clrReferenceToString(ref);
}
};
#endif
namespace Detail {
template<typename InputIterator, typename Sentinel = InputIterator>
std::string rangeToString(InputIterator first, Sentinel last) {
ReusableStringStream rss;
rss << "{ ";
if (first != last) {
rss << ::Catch::Detail::stringify(*first);
for (++first; first != last; ++first)
rss << ", " << ::Catch::Detail::stringify(*first);
}
rss << " }";
return rss.str();
}
}
#ifdef __OBJC__
template<>
struct StringMaker<NSString*> {
static std::string convert(NSString * nsstring) {
if (!nsstring)
return "nil";
return std::string("@") + [nsstring UTF8String];
}
};
template<>
struct StringMaker<NSObject*> {
static std::string convert(NSObject* nsObject) {
return ::Catch::Detail::stringify([nsObject description]);
}
};
namespace Detail {
inline std::string stringify( NSString* nsstring ) {
return StringMaker<NSString*>::convert( nsstring );
}
} // namespace Detail
#endif // __OBJC__
} // namespace Catch
//////////////////////////////////////////////////////
// Separate std-lib types stringification, so it can be selectively enabled
// This means that we do not bring in
#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
# define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
# define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
# define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
# define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
# define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
#endif
// Separate std::pair specialization
#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
#include <utility>
namespace Catch {
template<typename T1, typename T2>
struct StringMaker<std::pair<T1, T2> > {
static std::string convert(const std::pair<T1, T2>& pair) {
ReusableStringStream rss;
rss << "{ "
<< ::Catch::Detail::stringify(pair.first)
<< ", "
<< ::Catch::Detail::stringify(pair.second)
<< " }";
return rss.str();
}
};
}
#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
#include <optional>
namespace Catch {
template<typename T>
struct StringMaker<std::optional<T> > {
static std::string convert(const std::optional<T>& optional) {
ReusableStringStream rss;
if (optional.has_value()) {
rss << ::Catch::Detail::stringify(*optional);
} else {
rss << "{ }";
}
return rss.str();
}
};
}
#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
// Separate std::tuple specialization
#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
#include <tuple>
namespace Catch {
namespace Detail {
template<
typename Tuple,
std::size_t N = 0,
bool = (N < std::tuple_size<Tuple>::value)
>
struct TupleElementPrinter {
static void print(const Tuple& tuple, std::ostream& os) {
os << (N ? ", " : " ")
<< ::Catch::Detail::stringify(std::get<N>(tuple));
TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
}
};
template<
typename Tuple,
std::size_t N
>
struct TupleElementPrinter<Tuple, N, false> {
static void print(const Tuple&, std::ostream&) {}
};
}
template<typename ...Types>
struct StringMaker<std::tuple<Types...>> {
static std::string convert(const std::tuple<Types...>& tuple) {
ReusableStringStream rss;
rss << '{';
Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
rss << " }";
return rss.str();
}
};
}
#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
#include <variant>
namespace Catch {
template<>
struct StringMaker<std::monostate> {
static std::string convert(const std::monostate&) {
return "{ }";
}
};
template<typename... Elements>
struct StringMaker<std::variant<Elements...>> {
static std::string convert(const std::variant<Elements...>& variant) {
if (variant.valueless_by_exception()) {
return "{valueless variant}";
} else {
return std::visit(
[](const auto& value) {
return ::Catch::Detail::stringify(value);
},
variant
);
}
}
};
}
#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
namespace Catch {
// Import begin/ end from std here
using std::begin;
using std::end;
namespace detail {
template <typename...>
struct void_type {
using type = void;
};
template <typename T, typename = void>
struct is_range_impl : std::false_type {
};
template <typename T>
struct is_range_impl<T, typename void_type<decltype(begin(std::declval<T>()))>::type> : std::true_type {
};
} // namespace detail
template <typename T>
struct is_range : detail::is_range_impl<T> {
};
#if defined(_MANAGED) // Managed types are never ranges
template <typename T>
struct is_range<T^> {
static const bool value = false;
};
#endif
template<typename Range>
std::string rangeToString( Range const& range ) {
return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
}
// Handle vector<bool> specially
template<typename Allocator>
std::string rangeToString( std::vector<bool, Allocator> const& v ) {
ReusableStringStream rss;
rss << "{ ";
bool first = true;
for( bool b : v ) {
if( first )
first = false;
else
rss << ", ";
rss << ::Catch::Detail::stringify( b );
}
rss << " }";
return rss.str();
}
template<typename R>
struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
static std::string convert( R const& range ) {
return rangeToString( range );
}
};
template <typename T, int SZ>
struct StringMaker<T[SZ]> {
static std::string convert(T const(&arr)[SZ]) {
return rangeToString(arr);
}
};
} // namespace Catch
// Separate std::chrono::duration specialization
#if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
#include <ctime>
#include <ratio>
#include <chrono>
namespace Catch {
template <class Ratio>
struct ratio_string {
static std::string symbol();
};
template <class Ratio>
std::string ratio_string<Ratio>::symbol() {
Catch::ReusableStringStream rss;
rss << '[' << Ratio::num << '/'
<< Ratio::den << ']';
return rss.str();
}
template <>
struct ratio_string<std::atto> {
static std::string symbol();
};
template <>
struct ratio_string<std::femto> {
static std::string symbol();
};
template <>
struct ratio_string<std::pico> {
static std::string symbol();
};
template <>
struct ratio_string<std::nano> {
static std::string symbol();
};
template <>
struct ratio_string<std::micro> {
static std::string symbol();
};
template <>
struct ratio_string<std::milli> {
static std::string symbol();
};
////////////
// std::chrono::duration specializations
template<typename Value, typename Ratio>
struct StringMaker<std::chrono::duration<Value, Ratio>> {
static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
ReusableStringStream rss;
rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
return rss.str();
}
};
template<typename Value>
struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
ReusableStringStream rss;
rss << duration.count() << " s";
return rss.str();
}
};
template<typename Value>
struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
ReusableStringStream rss;
rss << duration.count() << " m";
return rss.str();
}
};
template<typename Value>
struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
ReusableStringStream rss;
rss << duration.count() << " h";
return rss.str();
}
};
////////////
// std::chrono::time_point specialization
// Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
template<typename Clock, typename Duration>
struct StringMaker<std::chrono::time_point<Clock, Duration>> {
static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
}
};
// std::chrono::time_point<system_clock> specialization
template<typename Duration>
struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
auto converted = std::chrono::system_clock::to_time_t(time_point);
#ifdef _MSC_VER
std::tm timeInfo = {};
gmtime_s(&timeInfo, &converted);
#else
std::tm* timeInfo = std::gmtime(&converted);
#endif
auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
char timeStamp[timeStampSize];
const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
#ifdef _MSC_VER
std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
#else
std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
#endif
return std::string(timeStamp);
}
};
}
#endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
namespace Catch { \
template<> struct StringMaker<enumName> { \
static std::string convert( enumName value ) { \
static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
} \
}; \
}
#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
#ifdef _MSC_VER
#pragma warning(pop)
#endif
// end catch_tostring.h
#include <iosfwd>
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
#pragma warning(disable:4018) // more "signed/unsigned mismatch"
#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
#pragma warning(disable:4180) // qualifier applied to function type has no meaning
#pragma warning(disable:4800) // Forcing result to true or false
#endif
namespace Catch {
struct ITransientExpression {
auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
auto getResult() const -> bool { return m_result; }
virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
ITransientExpression( bool isBinaryExpression, bool result )
: m_isBinaryExpression( isBinaryExpression ),
m_result( result )
{}
// We don't actually need a virtual destructor, but many static analysers
// complain if it's not here :-(
virtual ~ITransientExpression();
bool m_isBinaryExpression;
bool m_result;
};
void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
template<typename LhsT, typename RhsT>
class BinaryExpr : public ITransientExpression {
LhsT m_lhs;
StringRef m_op;
RhsT m_rhs;
void streamReconstructedExpression( std::ostream &os ) const override {
formatReconstructedExpression
( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
}
public:
BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
: ITransientExpression{ true, comparisonResult },
m_lhs( lhs ),
m_op( op ),
m_rhs( rhs )
{}
template<typename T>
auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
static_assert(always_false<T>::value,
"chained comparisons are not supported inside assertions, "
"wrap the expression inside parentheses, or decompose it");
}
template<typename T>
auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
static_assert(always_false<T>::value,
"chained comparisons are not supported inside assertions, "
"wrap the expression inside parentheses, or decompose it");
}
template<typename T>
auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
static_assert(always_false<T>::value,
"chained comparisons are not supported inside assertions, "
"wrap the expression inside parentheses, or decompose it");
}
template<typename T>
auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
static_assert(always_false<T>::value,
"chained comparisons are not supported inside assertions, "
"wrap the expression inside parentheses, or decompose it");
}
template<typename T>
auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
static_assert(always_false<T>::value,
"chained comparisons are not supported inside assertions, "
"wrap the expression inside parentheses, or decompose it");
}
template<typename T>
auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
static_assert(always_false<T>::value,
"chained comparisons are not supported inside assertions, "
"wrap the expression inside parentheses, or decompose it");
}
template<typename T>
auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
static_assert(always_false<T>::value,
"chained comparisons are not supported inside assertions, "
"wrap the expression inside parentheses, or decompose it");
}
template<typename T>
auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
static_assert(always_false<T>::value,
"chained comparisons are not supported inside assertions, "
"wrap the expression inside parentheses, or decompose it");
}
};
template<typename LhsT>
class UnaryExpr : public ITransientExpression {
LhsT m_lhs;
void streamReconstructedExpression( std::ostream &os ) const override {
os << Catch::Detail::stringify( m_lhs );
}
public:
explicit UnaryExpr( LhsT lhs )
: ITransientExpression{ false, static_cast<bool>(lhs) },
m_lhs( lhs )
{}
};
// Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
template<typename LhsT, typename RhsT>
auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
template<typename T>
auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
template<typename T>
auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
template<typename T>
auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
template<typename T>
auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
template<typename LhsT, typename RhsT>
auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
template<typename T>
auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
template<typename T>
auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
template<typename T>
auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
template<typename T>
auto compareNotEqual( long lhs, T* const&
gitextract_fzbi9j_9/
├── .circleci/
│ └── config.yml
├── .gitattributes
├── .github/
│ └── ISSUE_TEMPLATE/
│ └── bug_report.md
├── .gitignore
├── CMakeLists.txt
├── CODE_OF_CONDUCT.md
├── LICENSE
├── README.md
├── include/
│ └── xxhash.hpp
└── test/
├── CMakeLists.txt
├── catch.hpp
├── test_main.cpp
├── xxh3.h
└── xxhash.h
Copy disabled (too large)
Download .txt
Showing preview only (376,789K chars total). Download the full file to get everything.
SYMBOL INDEX (1826 symbols across 4 files)
FILE: include/xxhash.hpp
type version (line 57) | namespace version
function version_number (line 64) | constexpr uint32_t version_number()
type typedefs (line 74) | namespace typedefs
type uint128_t (line 76) | struct alignas(16) uint128_t
method uint128_t (line 111) | uint128_t(uint64_t low, uint64_t high) : low64(low), high64(high) {}
method uint128_t (line 113) | uint128_t() {}
function XXH_FORCE_INLINE (line 213) | XXH_FORCE_INLINE void prefetch(const void* ptr) {}
function XXH_FORCE_INLINE (line 215) | XXH_FORCE_INLINE void prefetch(const void* ptr) { _mm_prefetch((const ch...
function XXH_FORCE_INLINE (line 217) | XXH_FORCE_INLINE void prefetch(const void* ptr) { __builtin_prefetch((pt...
function XXH_FORCE_INLINE (line 219) | XXH_FORCE_INLINE void prefetch(const void* ptr) {}
type bit_ops (line 261) | namespace bit_ops
function rotl32 (line 264) | static inline uint32_t rotl32(uint32_t x, int32_t r) { return _rotl(x,...
function rotl64 (line 265) | static inline uint64_t rotl64(uint64_t x, int32_t r) { return _rotl64(...
function rotr32 (line 266) | static inline uint32_t rotr32(uint32_t x, int32_t r) { return _rotr(x,...
function rotr64 (line 267) | static inline uint64_t rotr64(uint64_t x, int32_t r) { return _rotr64(...
function rotl32 (line 269) | static inline uint32_t rotl32(uint32_t x, int32_t r) { return ((x << r...
function rotl64 (line 270) | static inline uint64_t rotl64(uint64_t x, int32_t r) { return ((x << r...
function rotr32 (line 271) | static inline uint32_t rotr32(uint32_t x, int32_t r) { return ((x >> r...
function rotr64 (line 272) | static inline uint64_t rotr64(uint64_t x, int32_t r) { return ((x >> r...
function swap32 (line 277) | static inline uint32_t swap32(uint32_t x) { return _byteswap_ulong(x); }
function swap64 (line 278) | static inline uint64_t swap64(uint64_t x) { return _byteswap_uint64(x); }
function swap32 (line 280) | static inline uint32_t swap32(uint32_t x) { return __builtin_bswap32(x...
function swap64 (line 281) | static inline uint64_t swap64(uint64_t x) { return __builtin_bswap64(x...
function swap32 (line 283) | static inline uint32_t swap32(uint32_t x) { return ((x << 24) & 0xff00...
function swap64 (line 284) | static inline uint64_t swap64(uint64_t x) { return ((x << 56) & 0xff00...
function XXH_FORCE_INLINE (line 289) | XXH_FORCE_INLINE uint64_t mult32to64(uint32_t x, uint32_t y) { return ...
function XXH_FORCE_INLINE (line 291) | XXH_FORCE_INLINE uint64_t mult32to64(uint32_t x, uint32_t y) { return ...
function uint128_t (line 296) | __attribute__((__target__("no-sse")))
type typedefs (line 348) | namespace typedefs
type hash_type (line 355) | struct hash_type
type hash_type<32> (line 361) | struct hash_type<32>
type hash_type<64> (line 367) | struct hash_type<64>
type hash_type<128> (line 373) | struct hash_type<128>
type vec_type (line 380) | struct vec_type
type vec_type<64> (line 386) | struct vec_type<64>
type vec_type<128> (line 392) | struct vec_type<128>
type vec_type<256> (line 398) | struct vec_type<256>
type vec_type<512> (line 404) | struct vec_type<512>
type uint_type (line 417) | struct uint_type
type uint_type<32> (line 423) | struct uint_type<32>
type uint_type<64> (line 429) | struct uint_type<64>
type uint_type<128> (line 435) | struct uint_type<128>
type bit_ops (line 463) | namespace bit_ops
function rotl (line 470) | static inline uint_t<N> rotl(uint_t<N> n, int32_t r)
function rotr (line 484) | static inline uint_t<N> rotr(uint_t<N> n, int32_t r)
function swap (line 498) | static inline uint_t<N> swap(uint_t<N> n)
function mul32to64 (line 512) | static inline vec_t<N> mul32to64(vec_t<N> x, vec_t<N> y)
function uint128_t (line 524) | static inline uint128_t mul64to128(uint64_t x, uint64_t y)
function mul128fold64 (line 529) | static inline uint64_t mul128fold64(uint64_t x, uint64_t y)
type mem_ops (line 542) | namespace mem_ops
function is_little_endian (line 549) | constexpr bool is_little_endian()
function read (line 560) | static inline uint_t<N> read(const void* memPtr)
function readLE (line 569) | static inline uint_t<N> readLE(const void* ptr)
function readBE (line 582) | static inline uint_t<N> readBE(const void* ptr)
function writeLE (line 595) | static void writeLE(void* dst, uint_t<N> v)
type vec_ops (line 611) | namespace vec_ops
function XXH_FORCE_INLINE (line 614) | XXH_FORCE_INLINE vec_t<N> loadu(const vec_t<N>* input)
function XXH_FORCE_INLINE (line 643) | XXH_FORCE_INLINE vec_t<N> xorv(vec_t<N> a, vec_t<N> b)
function XXH_FORCE_INLINE (line 670) | XXH_FORCE_INLINE vec_t<N> mul(vec_t<N> a, vec_t<N> b)
function XXH_FORCE_INLINE (line 697) | XXH_FORCE_INLINE vec_t<N> add(vec_t<N> a, vec_t<N> b)
function XXH_FORCE_INLINE (line 724) | XXH_FORCE_INLINE vec_t<N> shuffle(vec_t<N> a)
function XXH_FORCE_INLINE (line 751) | XXH_FORCE_INLINE vec_t<N> set1(int64_t a)
function XXH_FORCE_INLINE (line 782) | XXH_FORCE_INLINE vec_t<N> srli(vec_t<N> n, int a)
function XXH_FORCE_INLINE (line 809) | XXH_FORCE_INLINE vec_t<N> slli(vec_t<N> n, int a)
type canonical_t (line 840) | struct canonical_t
method canonical_t (line 844) | canonical_t(hash_t<bit_mode> hash)
method get_hash (line 868) | hash_t<bit_mode> get_hash() const
function to_canonical (line 886) | inline hash_t<bit_mode> to_canonical(hash_t<bit_mode> hash)
type detail (line 901) | namespace detail
function PRIME (line 915) | constexpr uint_t<N> PRIME(uint64_t n)
function XXH_FORCE_INLINE (line 933) | XXH_FORCE_INLINE uint_t<N> avalanche(uint_t<N> hash)
function XXH_FORCE_INLINE (line 957) | XXH_FORCE_INLINE uint_t<N> round(uint_t<N> seed, uint_t<N> input)
function XXH_FORCE_INLINE (line 974) | XXH_FORCE_INLINE uint64_t mergeRound64(hash64_t acc, uint64_t val)
function XXH_FORCE_INLINE (line 982) | XXH_FORCE_INLINE void endian_align_sub_mergeround(hash64_t& hash_ret...
function endian_align_sub_ending (line 991) | static inline hash_t<N> endian_align_sub_ending(hash_t<N> hash_ret, ...
function endian_align (line 1041) | static inline hash_t<N> endian_align(const void* input, size_t len, ...
type detail3 (line 1093) | namespace detail3
type vec_mode (line 1105) | enum class vec_mode : uint8_t { scalar = 0, sse2 = 1, avx2 = 2, avx5...
function XXH_FORCE_INLINE (line 1155) | XXH_FORCE_INLINE hash_t<64> avalanche(hash_t<64> h64)
function XXH_FORCE_INLINE (line 1165) | XXH_FORCE_INLINE hash_t<64> rrmxmx(hash_t<64> h64, uint64_t len)
function XXH_FORCE_INLINE (line 1175) | XXH_FORCE_INLINE void combine_16(void* dest, hash128_t h128)
function XXH_FORCE_INLINE (line 1181) | XXH_FORCE_INLINE void accumulate_512(void* XXH_RESTRICT acc, const v...
function XXH_FORCE_INLINE (line 1216) | XXH_FORCE_INLINE void scramble_acc(void* XXH_RESTRICT acc, const voi...
function XXH_FORCE_INLINE (line 1249) | XXH_FORCE_INLINE void accumulate(uint64_t* XXH_RESTRICT acc, const u...
function XXH_FORCE_INLINE (line 1260) | XXH_FORCE_INLINE void hash_long_internal_loop(uint64_t* XXH_RESTRICT...
function XXH_FORCE_INLINE (line 1283) | XXH_FORCE_INLINE uint64_t mix_2_accs(const uint64_t* XXH_RESTRICT ac...
function XXH_FORCE_INLINE (line 1288) | XXH_FORCE_INLINE uint64_t merge_accs(const uint64_t* XXH_RESTRICT ac...
function XXH_FORCE_INLINE (line 1300) | XXH_FORCE_INLINE void init_custom_secret(uint8_t* customSecret, uint...
function XXH_FORCE_INLINE (line 1310) | XXH_FORCE_INLINE hash_t<N> len_1to3(const uint8_t* input, size_t len...
function XXH_FORCE_INLINE (line 1340) | XXH_FORCE_INLINE hash_t<N> len_4to8(const uint8_t* input, size_t len...
function XXH_FORCE_INLINE (line 1377) | XXH_FORCE_INLINE hash_t<N> len_9to16(const uint8_t* input, size_t le...
function XXH_FORCE_INLINE (line 1422) | XXH_FORCE_INLINE hash_t<N> len_0to16(const uint8_t* input, size_t le...
function XXH_FORCE_INLINE (line 1453) | XXH_FORCE_INLINE hash_t<N> hash_long_internal(const uint8_t* XXH_RES...
function XXH_FORCE_INLINE (line 1476) | XXH_FORCE_INLINE uint64_t mix_16b(const uint8_t* XXH_RESTRICT input,...
function XXH_FORCE_INLINE (line 1484) | XXH_FORCE_INLINE uint128_t mix_32b(uint128_t acc, const uint8_t* inp...
function XXH_FORCE_INLINE (line 1495) | XXH_FORCE_INLINE hash_t<N> len_17to128(const uint8_t* XXH_RESTRICT i...
function XXH_NO_INLINE (line 1553) | XXH_NO_INLINE hash_t<N> len_129to240(const uint8_t* XXH_RESTRICT inp...
function XXH_NO_INLINE (line 1610) | XXH_NO_INLINE hash_t<N> xxhash3_impl(const void* XXH_RESTRICT input,...
function XXH_NO_INLINE (line 1641) | XXH_NO_INLINE void generate_secret(void* secret_buffer, size_t secre...
function xxhash (line 1675) | inline hash_t<bit_mode> xxhash(const void* input, size_t len, uint_t<b...
function xxhash (line 1682) | inline hash_t<bit_mode> xxhash(const std::basic_string<T>& input, uint...
function xxhash (line 1689) | inline hash_t<bit_mode> xxhash(ContiguousIterator begin, ContiguousIte...
function xxhash (line 1697) | inline hash_t<bit_mode> xxhash(const std::vector<T>& input, uint_t<bit...
function xxhash (line 1704) | inline hash_t<bit_mode> xxhash(const std::array<T, AN>& input, uint_t<...
function xxhash (line 1711) | inline hash_t<bit_mode> xxhash(const std::initializer_list<T>& input, ...
function xxhash3 (line 1723) | inline hash_t<bit_mode> xxhash3(const void* input, size_t len, uint64_...
function xxhash3 (line 1730) | inline hash_t<bit_mode> xxhash3(const void* input, size_t len, const v...
function xxhash3 (line 1737) | inline hash_t<bit_mode> xxhash3(const void* input, size_t len, const v...
function xxhash3 (line 1744) | inline hash_t<bit_mode> xxhash3(const std::basic_string<T>& input, uin...
function xxhash3 (line 1751) | inline hash_t<bit_mode> xxhash3(const std::basic_string<T>& input, con...
function xxhash3 (line 1758) | inline hash_t<bit_mode> xxhash3(const std::basic_string<T>& input, con...
function xxhash3 (line 1765) | inline hash_t<bit_mode> xxhash3(ContiguousIterator begin, ContiguousIt...
function xxhash3 (line 1773) | inline hash_t<bit_mode> xxhash3(ContiguousIterator begin, ContiguousIt...
function xxhash3 (line 1781) | inline hash_t<bit_mode> xxhash3(ContiguousIterator begin, ContiguousIt...
function xxhash3 (line 1789) | inline hash_t<bit_mode> xxhash3(const std::vector<T>& input, uint64_t ...
function xxhash3 (line 1796) | inline hash_t<bit_mode> xxhash3(const std::vector<T>& input, const voi...
function xxhash3 (line 1803) | inline hash_t<bit_mode> xxhash3(const std::vector<T>& input, const voi...
function xxhash3 (line 1810) | inline hash_t<bit_mode> xxhash3(const std::array<T, AN>& input, uint64...
function xxhash3 (line 1817) | inline hash_t<bit_mode> xxhash3(const std::array<T, AN>& input, const ...
function xxhash3 (line 1824) | inline hash_t<bit_mode> xxhash3(const std::array<T, AN>& input, const ...
function xxhash3 (line 1831) | inline hash_t<bit_mode> xxhash3(const std::initializer_list<T>& input,...
function xxhash3 (line 1838) | inline hash_t<bit_mode> xxhash3(const std::initializer_list<T>& input,...
function xxhash3 (line 1845) | inline hash_t<bit_mode> xxhash3(const std::initializer_list<T>& input,...
function generate_secret (line 1856) | inline void generate_secret(void* secret_buffer, size_t secret_size, c...
function generate_secret (line 1862) | inline void generate_secret(void* secret_buffer, size_t secret_size, c...
function generate_secret (line 1868) | inline void generate_secret(void* secret_buffer, size_t secret_size, c...
function generate_secret (line 1874) | inline void generate_secret(void* secret_buffer, size_t secret_size, c...
function generate_secret (line 1880) | inline void generate_secret(void* secret_buffer, size_t secret_size, c...
function generate_secret (line 1886) | inline void generate_secret(void* secret_buffer, size_t secret_size, C...
function generate_secret_from_seed (line 1892) | inline void generate_secret_from_seed(void* secret_buffer, uint64_t se...
class hash_state_t (line 1905) | class hash_state_t
method update_impl (line 1912) | inline void update_impl(const void* input, size_t length)
method digest_impl (line 1963) | inline hash_t<bit_mode> digest_impl() const
method hash_state_t (line 1990) | hash_state_t(uint_t<bit_mode> seed = 0)
method reset (line 1999) | void reset(uint_t<bit_mode> seed = 0)
method update (line 2008) | void update(const void* input, size_t length)
method update (line 2014) | void update(const std::basic_string<T>& input)
method update (line 2020) | void update(ContiguousIterator begin, ContiguousIterator end)
method update (line 2027) | void update(const std::vector<T>& input)
method update (line 2033) | void update(const std::array<T, AN>& input)
method update (line 2039) | void update(const std::initializer_list<T>& input)
method digest (line 2044) | hash_t<bit_mode> digest() const
class hash3_state_t (line 2059) | class alignas(64) hash3_state_t
method consume_stripes (line 2080) | void consume_stripes(uint64_t* acc, uint32_t& nbStripesSoFar, size_t...
method update_impl (line 2098) | void update_impl(const void* input_, size_t len)
method digest_long (line 2145) | void digest_long(uint64_t* acc_)
method reset_internal (line 2170) | void reset_internal(uint64_t seed_reset, const void* secret_reset, s...
method hash3_state_t (line 2183) | hash3_state_t operator=(hash3_state_t& other)
method hash3_state_t (line 2188) | hash3_state_t(uint64_t seed = 0)
method hash3_state_t (line 2194) | hash3_state_t(const void* secret, size_t secretSize)
method hash3_state_t (line 2200) | hash3_state_t(const void* secret, size_t secretSize, uint64_t seed)
method reset (line 2206) | void reset(uint64_t seed = 0)
method reset (line 2213) | void reset(const void* secret, size_t secretSize)
method reset (line 2218) | void reset(const void* secret, size_t secretSize, uint64_t seed)
method update (line 2224) | void update(const void* input, size_t len)
method update (line 2230) | void update(const std::basic_string<T>& input)
method update (line 2236) | void update(ContiguousIterator begin, ContiguousIterator end)
method update (line 2243) | void update(const std::vector<T>& input)
method update (line 2249) | void update(const std::array<T, AN>& input)
method update (line 2255) | void update(const std::initializer_list<T>& input)
method digest (line 2260) | hash_t<bit_mode> digest()
FILE: test/catch.hpp
type Catch (line 98) | namespace Catch {
type CaseSensitive (line 486) | struct CaseSensitive { enum Choice {
type Choice (line 486) | enum Choice {
class NonCopyable (line 491) | class NonCopyable {
method NonCopyable (line 492) | NonCopyable( NonCopyable const& ) = delete;
method NonCopyable (line 493) | NonCopyable( NonCopyable && ) = delete;
method NonCopyable (line 494) | NonCopyable& operator = ( NonCopyable const& ) = delete;
method NonCopyable (line 495) | NonCopyable& operator = ( NonCopyable && ) = delete;
type SourceLineInfo (line 502) | struct SourceLineInfo {
method SourceLineInfo (line 504) | SourceLineInfo() = delete;
method SourceLineInfo (line 505) | SourceLineInfo( char const* _file, std::size_t _line ) noexcept
method SourceLineInfo (line 510) | SourceLineInfo( SourceLineInfo const& other ) = default;
method SourceLineInfo (line 511) | SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
method SourceLineInfo (line 512) | SourceLineInfo( SourceLineInfo&& ) noexcept = default;
method SourceLineInfo (line 513) | SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
method empty (line 515) | bool empty() const noexcept { return file[0] == '\0'; }
type StreamEndStop (line 534) | struct StreamEndStop {
function T (line 538) | T const& operator + ( T const& value, StreamEndStop ) {
type RegistrarForTagAliases (line 549) | struct RegistrarForTagAliases {
class TestSpec (line 570) | class TestSpec
class Pattern (line 5112) | class Pattern {
class NamePattern (line 5123) | class NamePattern : public Pattern {
class TagPattern (line 5131) | class TagPattern : public Pattern {
class ExcludedPattern (line 5139) | class ExcludedPattern : public Pattern {
type Filter (line 5147) | struct Filter {
type FilterMatch (line 5155) | struct FilterMatch {
type ITestInvoker (line 572) | struct ITestInvoker {
class TestCase (line 577) | class TestCase
type IConfig (line 578) | struct IConfig
type ITestCaseRegistry (line 580) | struct ITestCaseRegistry {
class StringRef (line 606) | class StringRef {
method StringRef (line 618) | constexpr StringRef() noexcept = default;
method StringRef (line 622) | constexpr StringRef( char const* rawChars, size_type size ) noexcept
method StringRef (line 627) | StringRef( std::string const& stdString ) noexcept
method empty (line 648) | constexpr auto empty() const noexcept -> bool {
method size (line 651) | constexpr auto size() const noexcept -> size_type {
method isNullTerminated (line 668) | constexpr auto isNullTerminated() const noexcept -> bool {
method const_iterator (line 673) | constexpr const_iterator begin() const { return m_start; }
method const_iterator (line 674) | constexpr const_iterator end() const { return m_start + m_size; }
type always_false (line 925) | struct always_false : std::false_type {}
type true_given (line 927) | struct true_given : std::true_type {}
type is_callable_tester (line 928) | struct is_callable_tester {
type is_callable (line 936) | struct is_callable
class TestInvokerAsMethod (line 962) | class TestInvokerAsMethod : public ITestInvoker {
method TestInvokerAsMethod (line 965) | TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAs...
method invoke (line 967) | void invoke() const override {
function makeTestInvoker (line 976) | auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInv...
type NameAndTags (line 980) | struct NameAndTags {
type AutoReg (line 986) | struct AutoReg : NonCopyable {
type ResultWas (line 1353) | struct ResultWas { enum OfType {
type OfType (line 1353) | enum OfType {
type ResultDisposition (line 1377) | struct ResultDisposition { enum Flags {
type Flags (line 1377) | enum Flags {
function isFalseTest (line 1388) | inline bool isFalseTest( int flags ) { return ( flags & ResultDisposit...
type AssertionInfo (line 1396) | struct AssertionInfo
class StringRef (line 1431) | class StringRef
method StringRef (line 618) | constexpr StringRef() noexcept = default;
method StringRef (line 622) | constexpr StringRef( char const* rawChars, size_type size ) noexcept
method StringRef (line 627) | StringRef( std::string const& stdString ) noexcept
method empty (line 648) | constexpr auto empty() const noexcept -> bool {
method size (line 651) | constexpr auto size() const noexcept -> size_type {
method isNullTerminated (line 668) | constexpr auto isNullTerminated() const noexcept -> bool {
method const_iterator (line 673) | constexpr const_iterator begin() const { return m_start; }
method const_iterator (line 674) | constexpr const_iterator end() const { return m_start + m_size; }
type IStream (line 1433) | struct IStream {
class ReusableStringStream (line 1440) | class ReusableStringStream : NonCopyable {
method get (line 1454) | auto get() -> std::ostream& { return *m_oss; }
type Detail (line 1465) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7883) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7887) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10565) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10592) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10602) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10614) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10622) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10636) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13647) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13652) | StreamBufImpl() {
method overflow (line 13661) | int overflow( int c ) override {
method sync (line 13673) | int sync() override {
type OutputDebugWriter (line 13684) | struct OutputDebugWriter {
class FileStream (line 13693) | class FileStream : public IStream {
method FileStream (line 13696) | FileStream( StringRef filename ) {
class CoutStream (line 13709) | class CoutStream : public IStream {
method CoutStream (line 13714) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13723) | class DebugOutStream : public IStream {
method DebugOutStream (line 13727) | DebugOutStream()
type Endianness (line 15027) | struct Endianness {
type Arch (line 15028) | enum Arch { Big, Little }
method Arch (line 15030) | static Arch which() {
function rawMemoryToString (line 15040) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type IMutableEnumValuesRegistry (line 1476) | struct IMutableEnumValuesRegistry {
type Detail (line 1552) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7883) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7887) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10565) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10592) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10602) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10614) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10622) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10636) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13647) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13652) | StreamBufImpl() {
method overflow (line 13661) | int overflow( int c ) override {
method sync (line 13673) | int sync() override {
type OutputDebugWriter (line 13684) | struct OutputDebugWriter {
class FileStream (line 13693) | class FileStream : public IStream {
method FileStream (line 13696) | FileStream( StringRef filename ) {
class CoutStream (line 13709) | class CoutStream : public IStream {
method CoutStream (line 13714) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13723) | class DebugOutStream : public IStream {
method DebugOutStream (line 13727) | DebugOutStream()
type Endianness (line 15027) | struct Endianness {
type Arch (line 15028) | enum Arch { Big, Little }
method Arch (line 15030) | static Arch which() {
function rawMemoryToString (line 15040) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type StringMaker (line 1615) | struct StringMaker {
method convert (line 1617) | static
method convert (line 1628) | static
type Detail (line 1639) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7883) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7887) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10565) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10592) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10602) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10614) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10622) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10636) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13647) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13652) | StreamBufImpl() {
method overflow (line 13661) | int overflow( int c ) override {
method sync (line 13673) | int sync() override {
type OutputDebugWriter (line 13684) | struct OutputDebugWriter {
class FileStream (line 13693) | class FileStream : public IStream {
method FileStream (line 13696) | FileStream( StringRef filename ) {
class CoutStream (line 13709) | class CoutStream : public IStream {
method CoutStream (line 13714) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13723) | class DebugOutStream : public IStream {
method DebugOutStream (line 13727) | DebugOutStream()
type Endianness (line 15027) | struct Endianness {
type Arch (line 15028) | enum Arch { Big, Little }
method Arch (line 15030) | static Arch which() {
function rawMemoryToString (line 15040) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type StringMaker<std::string> (line 1665) | struct StringMaker<std::string> {
type StringMaker<std::string_view> (line 1671) | struct StringMaker<std::string_view> {
type StringMaker<char const *> (line 1677) | struct StringMaker<char const *> {
type StringMaker<char *> (line 1681) | struct StringMaker<char *> {
type StringMaker<std::wstring> (line 1687) | struct StringMaker<std::wstring> {
type StringMaker<std::wstring_view> (line 1693) | struct StringMaker<std::wstring_view> {
type StringMaker<wchar_t const *> (line 1699) | struct StringMaker<wchar_t const *> {
type StringMaker<wchar_t *> (line 1703) | struct StringMaker<wchar_t *> {
type StringMaker<char[SZ]> (line 1711) | struct StringMaker<char[SZ]> {
method convert (line 1712) | static std::string convert(char const* str) {
type StringMaker<signed char[SZ]> (line 1717) | struct StringMaker<signed char[SZ]> {
method convert (line 1718) | static std::string convert(signed char const* str) {
type StringMaker<unsigned char[SZ]> (line 1723) | struct StringMaker<unsigned char[SZ]> {
method convert (line 1724) | static std::string convert(unsigned char const* str) {
type StringMaker<std::byte> (line 1731) | struct StringMaker<std::byte> {
type StringMaker<int> (line 1736) | struct StringMaker<int> {
type StringMaker<long> (line 1740) | struct StringMaker<long> {
type StringMaker<long long> (line 1744) | struct StringMaker<long long> {
type StringMaker<unsigned int> (line 1748) | struct StringMaker<unsigned int> {
type StringMaker<unsigned long> (line 1752) | struct StringMaker<unsigned long> {
type StringMaker<unsigned long long> (line 1756) | struct StringMaker<unsigned long long> {
type StringMaker<bool> (line 1761) | struct StringMaker<bool> {
type StringMaker<char> (line 1766) | struct StringMaker<char> {
type StringMaker<signed char> (line 1770) | struct StringMaker<signed char> {
type StringMaker<unsigned char> (line 1774) | struct StringMaker<unsigned char> {
type StringMaker<std::nullptr_t> (line 1779) | struct StringMaker<std::nullptr_t> {
type StringMaker<float> (line 1784) | struct StringMaker<float> {
type StringMaker<double> (line 1790) | struct StringMaker<double> {
type StringMaker<T*> (line 1796) | struct StringMaker<T*> {
method convert (line 1798) | static std::string convert(U* p) {
type StringMaker<R C::*> (line 1808) | struct StringMaker<R C::*> {
method convert (line 1809) | static std::string convert(R C::* p) {
type StringMaker<T^> (line 1820) | struct StringMaker<T^> {
method convert (line 1821) | static std::string convert( T^ ref ) {
type Detail (line 1827) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7883) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7887) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10565) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10592) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10602) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10614) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10622) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10636) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13647) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13652) | StreamBufImpl() {
method overflow (line 13661) | int overflow( int c ) override {
method sync (line 13673) | int sync() override {
type OutputDebugWriter (line 13684) | struct OutputDebugWriter {
class FileStream (line 13693) | class FileStream : public IStream {
method FileStream (line 13696) | FileStream( StringRef filename ) {
class CoutStream (line 13709) | class CoutStream : public IStream {
method CoutStream (line 13714) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13723) | class DebugOutStream : public IStream {
method DebugOutStream (line 13727) | DebugOutStream()
type Endianness (line 15027) | struct Endianness {
type Arch (line 15028) | enum Arch { Big, Little }
method Arch (line 15030) | static Arch which() {
function rawMemoryToString (line 15040) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type StringMaker<NSString*> (line 1844) | struct StringMaker<NSString*> {
method convert (line 1845) | static std::string convert(NSString * nsstring) {
type StringMaker<NSObject*> (line 1852) | struct StringMaker<NSObject*> {
method convert (line 1853) | static std::string convert(NSObject* nsObject) {
type Detail (line 1858) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7883) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7887) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10565) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10592) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10602) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10614) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10622) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10636) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13647) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13652) | StreamBufImpl() {
method overflow (line 13661) | int overflow( int c ) override {
method sync (line 13673) | int sync() override {
type OutputDebugWriter (line 13684) | struct OutputDebugWriter {
class FileStream (line 13693) | class FileStream : public IStream {
method FileStream (line 13696) | FileStream( StringRef filename ) {
class CoutStream (line 13709) | class CoutStream : public IStream {
method CoutStream (line 13714) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13723) | class DebugOutStream : public IStream {
method DebugOutStream (line 13727) | DebugOutStream()
type Endianness (line 15027) | struct Endianness {
type Arch (line 15028) | enum Arch { Big, Little }
method Arch (line 15030) | static Arch which() {
function rawMemoryToString (line 15040) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type StringMaker<std::pair<T1, T2> > (line 1885) | struct StringMaker<std::pair<T1, T2> > {
method convert (line 1886) | static std::string convert(const std::pair<T1, T2>& pair) {
type StringMaker<std::optional<T> > (line 1903) | struct StringMaker<std::optional<T> > {
method convert (line 1904) | static std::string convert(const std::optional<T>& optional) {
type Detail (line 1921) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7883) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7887) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10565) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10592) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10602) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10614) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10622) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10636) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13647) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13652) | StreamBufImpl() {
method overflow (line 13661) | int overflow( int c ) override {
method sync (line 13673) | int sync() override {
type OutputDebugWriter (line 13684) | struct OutputDebugWriter {
class FileStream (line 13693) | class FileStream : public IStream {
method FileStream (line 13696) | FileStream( StringRef filename ) {
class CoutStream (line 13709) | class CoutStream : public IStream {
method CoutStream (line 13714) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13723) | class DebugOutStream : public IStream {
method DebugOutStream (line 13727) | DebugOutStream()
type Endianness (line 15027) | struct Endianness {
type Arch (line 15028) | enum Arch { Big, Little }
method Arch (line 15030) | static Arch which() {
function rawMemoryToString (line 15040) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type StringMaker<std::monostate> (line 1962) | struct StringMaker<std::monostate> {
method convert (line 1963) | static std::string convert(const std::monostate&) {
type detail (line 1991) | namespace detail {
type void_type (line 1993) | struct void_type {
type is_range_impl (line 1998) | struct is_range_impl : std::false_type {
type is_range_impl<T, typename void_type<decltype(begin(std::declval<T>()))>::type> (line 2002) | struct is_range_impl<T, typename void_type<decltype(begin(std::declv...
type is_range (line 2007) | struct is_range : detail::is_range_impl<T> {
type is_range<T^> (line 2012) | struct is_range<T^> {
function rangeToString (line 2018) | std::string rangeToString( Range const& range ) {
function rangeToString (line 2024) | std::string rangeToString( std::vector<bool, Allocator> const& v ) {
type StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> (line 2040) | struct StringMaker<R, typename std::enable_if<is_range<R>::value && !:...
method convert (line 2041) | static std::string convert( R const& range ) {
type StringMaker<T[SZ]> (line 2047) | struct StringMaker<T[SZ]> {
method convert (line 2048) | static std::string convert(T const(&arr)[SZ]) {
type ratio_string (line 2064) | struct ratio_string {
type ratio_string<std::atto> (line 2076) | struct ratio_string<std::atto> {
type ratio_string<std::femto> (line 2080) | struct ratio_string<std::femto> {
type ratio_string<std::pico> (line 2084) | struct ratio_string<std::pico> {
type ratio_string<std::nano> (line 2088) | struct ratio_string<std::nano> {
type ratio_string<std::micro> (line 2092) | struct ratio_string<std::micro> {
type ratio_string<std::milli> (line 2096) | struct ratio_string<std::milli> {
type StringMaker<std::chrono::duration<Value, Ratio>> (line 2103) | struct StringMaker<std::chrono::duration<Value, Ratio>> {
method convert (line 2104) | static std::string convert(std::chrono::duration<Value, Ratio> const...
type StringMaker<std::chrono::duration<Value, std::ratio<1>>> (line 2111) | struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
method convert (line 2112) | static std::string convert(std::chrono::duration<Value, std::ratio<1...
type StringMaker<std::chrono::duration<Value, std::ratio<60>>> (line 2119) | struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
method convert (line 2120) | static std::string convert(std::chrono::duration<Value, std::ratio<6...
type StringMaker<std::chrono::duration<Value, std::ratio<3600>>> (line 2127) | struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
method convert (line 2128) | static std::string convert(std::chrono::duration<Value, std::ratio<3...
type StringMaker<std::chrono::time_point<Clock, Duration>> (line 2139) | struct StringMaker<std::chrono::time_point<Clock, Duration>> {
method convert (line 2140) | static std::string convert(std::chrono::time_point<Clock, Duration> ...
type StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> (line 2146) | struct StringMaker<std::chrono::time_point<std::chrono::system_clock, ...
method convert (line 2147) | static std::string convert(std::chrono::time_point<std::chrono::syst...
type ITransientExpression (line 2202) | struct ITransientExpression {
method isBinaryExpression (line 2203) | auto isBinaryExpression() const -> bool { return m_isBinaryExpressio...
method getResult (line 2204) | auto getResult() const -> bool { return m_result; }
method ITransientExpression (line 2207) | ITransientExpression( bool isBinaryExpression, bool result )
class BinaryExpr (line 2224) | class BinaryExpr : public ITransientExpression {
method streamReconstructedExpression (line 2229) | void streamReconstructedExpression( std::ostream &os ) const override {
method BinaryExpr (line 2235) | BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
class UnaryExpr (line 2300) | class UnaryExpr : public ITransientExpression {
method streamReconstructedExpression (line 2303) | void streamReconstructedExpression( std::ostream &os ) const override {
method UnaryExpr (line 2308) | explicit UnaryExpr( LhsT lhs )
function compareEqual (line 2316) | auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return...
function compareEqual (line 2318) | auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == re...
function compareEqual (line 2320) | auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == r...
function compareEqual (line 2322) | auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpr...
function compareEqual (line 2324) | auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterp...
function compareNotEqual (line 2327) | auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return s...
function compareNotEqual (line 2329) | auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs !=...
function compareNotEqual (line 2331) | auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs !...
function compareNotEqual (line 2333) | auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinte...
function compareNotEqual (line 2335) | auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reint...
class ExprLhs (line 2338) | class ExprLhs {
method ExprLhs (line 2341) | explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
method makeUnaryExpr (line 2402) | auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
function handleExpression (line 2410) | void handleExpression( ExprLhs<T> const& expr ) {
type Decomposer (line 2414) | struct Decomposer {
class AssertionResult (line 2439) | class AssertionResult
method AssertionResult (line 5399) | AssertionResult() = delete;
type AssertionInfo (line 2440) | struct AssertionInfo
type SectionInfo (line 2441) | struct SectionInfo
method SectionInfo (line 2866) | SectionInfo
type SectionEndInfo (line 2442) | struct SectionEndInfo
type MessageInfo (line 2443) | struct MessageInfo
type MessageBuilder (line 2444) | struct MessageBuilder
method MessageBuilder (line 2633) | MessageBuilder& operator << ( T const& value ) {
type Counts (line 2445) | struct Counts
type AssertionReaction (line 2446) | struct AssertionReaction
type SourceLineInfo (line 2447) | struct SourceLineInfo
method SourceLineInfo (line 504) | SourceLineInfo() = delete;
method SourceLineInfo (line 505) | SourceLineInfo( char const* _file, std::size_t _line ) noexcept
method SourceLineInfo (line 510) | SourceLineInfo( SourceLineInfo const& other ) = default;
method SourceLineInfo (line 511) | SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
method SourceLineInfo (line 512) | SourceLineInfo( SourceLineInfo&& ) noexcept = default;
method SourceLineInfo (line 513) | SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
method empty (line 515) | bool empty() const noexcept { return file[0] == '\0'; }
type ITransientExpression (line 2449) | struct ITransientExpression
method isBinaryExpression (line 2203) | auto isBinaryExpression() const -> bool { return m_isBinaryExpressio...
method getResult (line 2204) | auto getResult() const -> bool { return m_result; }
method ITransientExpression (line 2207) | ITransientExpression( bool isBinaryExpression, bool result )
type IGeneratorTracker (line 2450) | struct IGeneratorTracker
type BenchmarkInfo (line 2453) | struct BenchmarkInfo
type BenchmarkStats (line 2455) | struct BenchmarkStats
type IResultCapture (line 2458) | struct IResultCapture {
type TestFailureException (line 2521) | struct TestFailureException{}
type AssertionResultData (line 2522) | struct AssertionResultData
method AssertionResultData (line 5385) | AssertionResultData() = delete;
type IResultCapture (line 2523) | struct IResultCapture
class RunContext (line 2524) | class RunContext
method RunContext (line 8062) | RunContext( RunContext const& ) = delete;
method RunContext (line 8063) | RunContext& operator =( RunContext const& ) = delete;
class LazyExpression (line 2526) | class LazyExpression {
method LazyExpression (line 2536) | LazyExpression& operator = ( LazyExpression const& ) = delete;
type AssertionReaction (line 2543) | struct AssertionReaction {
class AssertionHandler (line 2548) | class AssertionHandler {
method handleExpr (line 2567) | void handleExpr( ExprLhs<T> const& expr ) {
type MessageInfo (line 2599) | struct MessageInfo {
type MessageStream (line 2616) | struct MessageStream {
method MessageStream (line 2619) | MessageStream& operator << ( T const& value ) {
type MessageBuilder (line 2627) | struct MessageBuilder : MessageStream {
method MessageBuilder (line 2633) | MessageBuilder& operator << ( T const& value ) {
class ScopedMessage (line 2641) | class ScopedMessage {
method ScopedMessage (line 2644) | ScopedMessage( ScopedMessage& duplicate ) = delete;
class Capturer (line 2652) | class Capturer {
method captureValues (line 2663) | void captureValues( size_t index, T const& value ) {
method captureValues (line 2668) | void captureValues( size_t index, T const& value, Ts const&... value...
type Counts (line 2829) | struct Counts {
type Totals (line 2842) | struct Totals {
type SectionInfo (line 2860) | struct SectionInfo {
method SectionInfo (line 2866) | SectionInfo
type SectionEndInfo (line 2876) | struct SectionEndInfo {
class Timer (line 2894) | class Timer {
class Section (line 2911) | class Section : NonCopyable {
class TestCase (line 2952) | class TestCase
type ITestCaseRegistry (line 2953) | struct ITestCaseRegistry
type IExceptionTranslatorRegistry (line 2954) | struct IExceptionTranslatorRegistry
type IExceptionTranslator (line 2955) | struct IExceptionTranslator
type IReporterRegistry (line 2956) | struct IReporterRegistry
type IReporterFactory (line 2957) | struct IReporterFactory
type ITagAliasRegistry (line 2958) | struct ITagAliasRegistry
type IMutableEnumValuesRegistry (line 2959) | struct IMutableEnumValuesRegistry
class StartupExceptionRegistry (line 2961) | class StartupExceptionRegistry
type IRegistryHub (line 2965) | struct IRegistryHub {
type IMutableRegistryHub (line 2976) | struct IMutableRegistryHub {
type IExceptionTranslator (line 3007) | struct IExceptionTranslator
type IExceptionTranslator (line 3010) | struct IExceptionTranslator {
type IExceptionTranslatorRegistry (line 3015) | struct IExceptionTranslatorRegistry {
class ExceptionTranslatorRegistrar (line 3021) | class ExceptionTranslatorRegistrar {
class ExceptionTranslator (line 3023) | class ExceptionTranslator : public IExceptionTranslator {
method ExceptionTranslator (line 3026) | ExceptionTranslator( std::string(*translateFunction)( T& ) )
method translate (line 3030) | std::string translate( ExceptionTranslators::const_iterator it, Ex...
method ExceptionTranslatorRegistrar (line 3052) | ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
type Detail (line 3076) | namespace Detail {
type EnumInfo (line 1466) | struct EnumInfo {
function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
class IsStreamInsertable (line 1564) | class IsStreamInsertable {
function convertUnstreamable (line 1580) | typename std::enable_if<
function convertUnstreamable (line 1586) | typename std::enable_if<
function convertUnstreamable (line 1593) | typename std::enable_if<
function stringify (line 1644) | std::string stringify(const T& e) {
function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
class Approx (line 3078) | class Approx {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7883) | Approx Approx::custom() {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
function Approx (line 7887) | Approx Approx::operator-() const {
method Approx (line 3096) | Approx operator()( T const& value ) const {
method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
method Approx (line 3157) | Approx& margin( T const& newMargin ) {
method Approx (line 3164) | Approx& scale( T const& newScale ) {
class EnumValuesRegistry (line 10565) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
function StringRef (line 10592) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 10602) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 10614) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 10622) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
function EnumInfo (line 10636) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
class StreamBufImpl (line 13647) | class StreamBufImpl : public std::streambuf {
method StreamBufImpl (line 13652) | StreamBufImpl() {
method overflow (line 13661) | int overflow( int c ) override {
method sync (line 13673) | int sync() override {
type OutputDebugWriter (line 13684) | struct OutputDebugWriter {
class FileStream (line 13693) | class FileStream : public IStream {
method FileStream (line 13696) | FileStream( StringRef filename ) {
class CoutStream (line 13709) | class CoutStream : public IStream {
method CoutStream (line 13714) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
class DebugOutStream (line 13723) | class DebugOutStream : public IStream {
method DebugOutStream (line 13727) | DebugOutStream()
type Endianness (line 15027) | struct Endianness {
type Arch (line 15028) | enum Arch { Big, Little }
method Arch (line 15030) | static Arch which() {
function rawMemoryToString (line 15040) | std::string rawMemoryToString( const void *object, std::size_t size ) {
type literals (line 3179) | namespace literals {
type StringMaker<Catch::Detail::Approx> (line 3185) | struct StringMaker<Catch::Detail::Approx> {
type pluralise (line 3216) | struct pluralise {
type Matchers (line 3236) | namespace Matchers {
type Impl (line 3237) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 3397) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
type Floating (line 3425) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11563) | enum class FloatingPointKind : uint8_t {
type Generic (line 3488) | namespace Generic {
type Detail (line 3490) | namespace Detail {
class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
method match (line 3505) | bool match( T const& item ) const override {
method describe (line 3509) | std::string describe() const override {
function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
type StdString (line 3536) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
type Vector (line 3605) | namespace Vector {
type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
method describe (line 3620) | std::string describe() const override {
type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3650) | std::string describe() const override {
type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3674) | std::string describe() const override {
type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3693) | std::string describe() const override {
method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
method describe (line 3726) | std::string describe() const override {
function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
type Impl (line 11404) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 11426) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
function Message (line 11437) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
type Floating (line 11561) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11563) | enum class FloatingPointKind : uint8_t {
function WithinULP (line 11661) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
function WithinULP (line 11665) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
function WithinAbs (line 11669) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRel (line 11673) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
function WithinRel (line 11677) | Floating::WithinRelMatcher WithinRel(double target) {
function WithinRel (line 11681) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
function WithinRel (line 11685) | Floating::WithinRelMatcher WithinRel(float target) {
type StdString (line 11709) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
function Equals (line 11784) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
function Contains (line 11787) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
function EndsWith (line 11790) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
function StartsWith (line 11793) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
function Matches (line 11797) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
type Matchers (line 3396) | namespace Matchers {
type Impl (line 3237) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 3397) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
type Floating (line 3425) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11563) | enum class FloatingPointKind : uint8_t {
type Generic (line 3488) | namespace Generic {
type Detail (line 3490) | namespace Detail {
class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
method match (line 3505) | bool match( T const& item ) const override {
method describe (line 3509) | std::string describe() const override {
function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
type StdString (line 3536) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
type Vector (line 3605) | namespace Vector {
type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
method describe (line 3620) | std::string describe() const override {
type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3650) | std::string describe() const override {
type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3674) | std::string describe() const override {
type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3693) | std::string describe() const override {
method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
method describe (line 3726) | std::string describe() const override {
function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
type Impl (line 11404) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 11426) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
function Message (line 11437) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
type Floating (line 11561) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11563) | enum class FloatingPointKind : uint8_t {
function WithinULP (line 11661) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
function WithinULP (line 11665) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
function WithinAbs (line 11669) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRel (line 11673) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
function WithinRel (line 11677) | Floating::WithinRelMatcher WithinRel(double target) {
function WithinRel (line 11681) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
function WithinRel (line 11685) | Floating::WithinRelMatcher WithinRel(float target) {
type StdString (line 11709) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
function Equals (line 11784) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
function Contains (line 11787) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
function EndsWith (line 11790) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
function StartsWith (line 11793) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
function Matches (line 11797) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
type Matchers (line 3423) | namespace Matchers {
type Impl (line 3237) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 3397) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
type Floating (line 3425) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11563) | enum class FloatingPointKind : uint8_t {
type Generic (line 3488) | namespace Generic {
type Detail (line 3490) | namespace Detail {
class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
method match (line 3505) | bool match( T const& item ) const override {
method describe (line 3509) | std::string describe() const override {
function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
type StdString (line 3536) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
type Vector (line 3605) | namespace Vector {
type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
method describe (line 3620) | std::string describe() const override {
type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3650) | std::string describe() const override {
type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3674) | std::string describe() const override {
type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3693) | std::string describe() const override {
method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
method describe (line 3726) | std::string describe() const override {
function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
type Impl (line 11404) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 11426) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
function Message (line 11437) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
type Floating (line 11561) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11563) | enum class FloatingPointKind : uint8_t {
function WithinULP (line 11661) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
function WithinULP (line 11665) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
function WithinAbs (line 11669) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRel (line 11673) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
function WithinRel (line 11677) | Floating::WithinRelMatcher WithinRel(double target) {
function WithinRel (line 11681) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
function WithinRel (line 11685) | Floating::WithinRelMatcher WithinRel(float target) {
type StdString (line 11709) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
function Equals (line 11784) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
function Contains (line 11787) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
function EndsWith (line 11790) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
function StartsWith (line 11793) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
function Matches (line 11797) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
type Matchers (line 3487) | namespace Matchers {
type Impl (line 3237) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 3397) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
type Floating (line 3425) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11563) | enum class FloatingPointKind : uint8_t {
type Generic (line 3488) | namespace Generic {
type Detail (line 3490) | namespace Detail {
class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
method match (line 3505) | bool match( T const& item ) const override {
method describe (line 3509) | std::string describe() const override {
function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
type StdString (line 3536) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
type Vector (line 3605) | namespace Vector {
type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
method describe (line 3620) | std::string describe() const override {
type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3650) | std::string describe() const override {
type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3674) | std::string describe() const override {
type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3693) | std::string describe() const override {
method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
method describe (line 3726) | std::string describe() const override {
function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
type Impl (line 11404) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 11426) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
function Message (line 11437) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
type Floating (line 11561) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11563) | enum class FloatingPointKind : uint8_t {
function WithinULP (line 11661) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
function WithinULP (line 11665) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
function WithinAbs (line 11669) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRel (line 11673) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
function WithinRel (line 11677) | Floating::WithinRelMatcher WithinRel(double target) {
function WithinRel (line 11681) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
function WithinRel (line 11685) | Floating::WithinRelMatcher WithinRel(float target) {
type StdString (line 11709) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
function Equals (line 11784) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
function Contains (line 11787) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
function EndsWith (line 11790) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
function StartsWith (line 11793) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
function Matches (line 11797) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
type Matchers (line 3534) | namespace Matchers {
type Impl (line 3237) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 3397) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
type Floating (line 3425) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11563) | enum class FloatingPointKind : uint8_t {
type Generic (line 3488) | namespace Generic {
type Detail (line 3490) | namespace Detail {
class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
method match (line 3505) | bool match( T const& item ) const override {
method describe (line 3509) | std::string describe() const override {
function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
type StdString (line 3536) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
type Vector (line 3605) | namespace Vector {
type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
method describe (line 3620) | std::string describe() const override {
type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3650) | std::string describe() const override {
type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3674) | std::string describe() const override {
type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3693) | std::string describe() const override {
method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
method describe (line 3726) | std::string describe() const override {
function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
type Impl (line 11404) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 11426) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
function Message (line 11437) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
type Floating (line 11561) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11563) | enum class FloatingPointKind : uint8_t {
function WithinULP (line 11661) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
function WithinULP (line 11665) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
function WithinAbs (line 11669) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRel (line 11673) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
function WithinRel (line 11677) | Floating::WithinRelMatcher WithinRel(double target) {
function WithinRel (line 11681) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
function WithinRel (line 11685) | Floating::WithinRelMatcher WithinRel(float target) {
type StdString (line 11709) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
function Equals (line 11784) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
function Contains (line 11787) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
function EndsWith (line 11790) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
function StartsWith (line 11793) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
function Matches (line 11797) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
type Matchers (line 3603) | namespace Matchers {
type Impl (line 3237) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 3397) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
type Floating (line 3425) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11563) | enum class FloatingPointKind : uint8_t {
type Generic (line 3488) | namespace Generic {
type Detail (line 3490) | namespace Detail {
class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
method match (line 3505) | bool match( T const& item ) const override {
method describe (line 3509) | std::string describe() const override {
function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
type StdString (line 3536) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
type Vector (line 3605) | namespace Vector {
type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
method describe (line 3620) | std::string describe() const override {
type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3650) | std::string describe() const override {
type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3674) | std::string describe() const override {
type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
method describe (line 3693) | std::string describe() const override {
method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
method describe (line 3726) | std::string describe() const override {
function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
type Impl (line 11404) | namespace Impl {
type MatchAllOf (line 3239) | struct MatchAllOf
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3240) | struct MatchAnyOf
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3241) | struct MatchNotOf
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
type MatcherMethod (line 3262) | struct MatcherMethod {
type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
method match (line 3289) | bool match( ArgT const& arg ) const override {
method describe (line 3296) | std::string describe() const override {
type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
method match (line 3323) | bool match( ArgT const& arg ) const override {
method describe (line 3330) | std::string describe() const override {
type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
method match (line 3360) | bool match( ArgT const& arg ) const override {
method describe (line 3364) | std::string describe() const override {
type Exception (line 11426) | namespace Exception {
class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
function Message (line 11437) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
type Floating (line 11561) | namespace Floating {
type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
type FloatingPointKind (line 11563) | enum class FloatingPointKind : uint8_t {
function WithinULP (line 11661) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
function WithinULP (line 11665) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
function WithinAbs (line 11669) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRel (line 11673) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
function WithinRel (line 11677) | Floating::WithinRelMatcher WithinRel(double target) {
function WithinRel (line 11681) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
function WithinRel (line 11685) | Floating::WithinRelMatcher WithinRel(float target) {
type StdString (line 11709) | namespace StdString {
type CasedString (line 3538) | struct CasedString
type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
function Equals (line 11784) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
function Contains (line 11787) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
function EndsWith (line 11790) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
function StartsWith (line 11793) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
function Matches (line 11797) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
class MatchExpr (line 3770) | class MatchExpr : public ITransientExpression {
method MatchExpr (line 3775) | MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const...
method streamReconstructedExpression (line 3782) | void streamReconstructedExpression( std::ostream &os ) const override {
function makeMatchExpr (line 3797) | auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRe...
type Generators (line 3844) | namespace Generators {
class GeneratorUntypedBase (line 3845) | class GeneratorUntypedBase {
method GeneratorUntypedBase (line 3847) | GeneratorUntypedBase() = default;
type pf (line 3933) | namespace pf{
function make_unique (line 3935) | std::unique_ptr<T> make_unique( Args&&... args ) {
type IGenerator (line 3941) | struct IGenerator : GeneratorUntypedBase {
class SingleValueGenerator (line 3953) | class SingleValueGenerator final : public IGenerator<T> {
method SingleValueGenerator (line 3956) | SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
method T (line 3958) | T const& get() const override {
method next (line 3961) | bool next() override {
class FixedValuesGenerator (line 3967) | class FixedValuesGenerator final : public IGenerator<T> {
method FixedValuesGenerator (line 3974) | FixedValuesGenerator( std::initializer_list<T> values ) : m_values...
method T (line 3976) | T const& get() const override {
method next (line 3979) | bool next() override {
class GeneratorWrapper (line 3986) | class GeneratorWrapper final {
method GeneratorWrapper (line 3989) | GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
method T (line 3992) | T const& get() const {
method next (line 3995) | bool next() {
function value (line 4001) | GeneratorWrapper<T> value(T&& value) {
function values (line 4005) | GeneratorWrapper<T> values(std::initializer_list<T> values) {
class Generators (line 4010) | class Generators : public IGenerator<T> {
method populate (line 4014) | void populate(GeneratorWrapper<T>&& generator) {
method populate (line 4017) | void populate(T&& val) {
method populate (line 4021) | void populate(U&& val) {
method populate (line 4025) | void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
method Generators (line 4032) | Generators(Gs &&... moreGenerators) {
method T (line 4037) | T const& get() const override {
method next (line 4041) | bool next() override {
function table (line 4054) | GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std...
type as (line 4060) | struct as {}
function makeGenerators (line 4063) | auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreG...
function makeGenerators (line 4067) | auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators...
function makeGenerators (line 4071) | auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generator...
function makeGenerators (line 4075) | auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Ge...
function generate (line 4085) | auto generate( StringRef generatorName, SourceLineInfo const& lineIn...
class TakeGenerator (line 4120) | class TakeGenerator : public IGenerator<T> {
method TakeGenerator (line 4125) | TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
method T (line 4131) | T const& get() const override {
method next (line 4134) | bool next() override {
function take (line 4151) | GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& genera...
class FilterGenerator (line 4156) | class FilterGenerator : public IGenerator<T> {
method FilterGenerator (line 4161) | FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
method T (line 4175) | T const& get() const override {
method next (line 4179) | bool next() override {
method nextImpl (line 4184) | bool nextImpl() {
function filter (line 4195) | GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& g...
class RepeatGenerator (line 4200) | class RepeatGenerator : public IGenerator<T> {
method RepeatGenerator (line 4210) | RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
method T (line 4217) | T const& get() const override {
method next (line 4225) | bool next() override {
function repeat (line 4251) | GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& gen...
class MapGenerator (line 4256) | class MapGenerator : public IGenerator<T> {
method MapGenerator (line 4264) | MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
method T (line 4270) | T const& get() const override {
method next (line 4273) | bool next() override {
function map (line 4283) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
function map (line 4290) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
class ChunkGenerator (line 4297) | class ChunkGenerator final : public IGenerator<std::vector<T>> {
method ChunkGenerator (line 4303) | ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
method next (line 4320) | bool next() override {
function chunk (line 4333) | GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper...
class RandomFloatingGenerator (line 4603) | class RandomFloatingGenerator final : public IGenerator<Float> {
method RandomFloatingGenerator (line 4609) | RandomFloatingGenerator(Float a, Float b):
method Float (line 4615) | Float const& get() const override {
method next (line 4618) | bool next() override {
class RandomIntegerGenerator (line 4625) | class RandomIntegerGenerator final : public IGenerator<Integer> {
method RandomIntegerGenerator (line 4631) | RandomIntegerGenerator(Integer a, Integer b):
method Integer (line 4637) | Integer const& get() const override {
method next (line 4640) | bool next() override {
function random (line 4649) | typename std::enable_if<std::is_integral<T>::value && !std::is_same<...
function random (line 4658) | typename std::enable_if<std::is_floating_point<T>::value,
class RangeGenerator (line 4667) | class RangeGenerator final : public IGenerator<T> {
method RangeGenerator (line 4674) | RangeGenerator(T const& start, T const& end, T const& step):
method RangeGenerator (line 4685) | RangeGenerator(T const& start, T const& end):
method T (line 4689) | T const& get() const override {
method next (line 4693) | bool next() override {
function range (line 4700) | GeneratorWrapper<T> range(T const& start, T const& end, T const& ste...
function range (line 4706) | GeneratorWrapper<T> range(T const& start, T const& end) {
class IteratorGenerator (line 4712) | class IteratorGenerator final : public IGenerator<T> {
method IteratorGenerator (line 4721) | IteratorGenerator(InputIterator first, InputSentinel last):m_elems...
method T (line 4727) | T const& get() const override {
method next (line 4731) | bool next() override {
function from_range (line 4740) | GeneratorWrapper<ResultType> from_range(InputIterator from, InputSen...
function from_range (line 4746) | GeneratorWrapper<ResultType> from_range(Container const& cnt) {
function acquireGeneratorTracker (line 10980) | auto acquireGeneratorTracker( StringRef generatorName, SourceLineInf...
type GeneratorTracker (line 12586) | struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorT...
method GeneratorTracker (line 12589) | GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAnd...
method GeneratorTracker (line 12594) | static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTra...
method isGeneratorTracker (line 12631) | bool isGeneratorTracker() const override { return true; }
method hasGenerator (line 12632) | auto hasGenerator() const -> bool override {
method close (line 12635) | void close() override {
method getGenerator (line 12705) | auto getGenerator() const -> GeneratorBasePtr const& override {
method setGenerator (line 12708) | void setGenerator( GeneratorBasePtr&& generator ) override {
type IGeneratorTracker (line 3859) | struct IGeneratorTracker {
function throw_exception (line 3876) | [[noreturn]]
class GeneratorException (line 3919) | class GeneratorException : public std::exception {
method GeneratorException (line 3923) | GeneratorException(const char* msg):
type Generators (line 3930) | namespace Generators {
class GeneratorUntypedBase (line 3845) | class GeneratorUntypedBase {
method GeneratorUntypedBase (line 3847) | GeneratorUntypedBase() = default;
type pf (line 3933) | namespace pf{
function make_unique (line 3935) | std::unique_ptr<T> make_unique( Args&&... args ) {
type IGenerator (line 3941) | struct IGenerator : GeneratorUntypedBase {
class SingleValueGenerator (line 3953) | class SingleValueGenerator final : public IGenerator<T> {
method SingleValueGenerator (line 3956) | SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
method T (line 3958) | T const& get() const override {
method next (line 3961) | bool next() override {
class FixedValuesGenerator (line 3967) | class FixedValuesGenerator final : public IGenerator<T> {
method FixedValuesGenerator (line 3974) | FixedValuesGenerator( std::initializer_list<T> values ) : m_values...
method T (line 3976) | T const& get() const override {
method next (line 3979) | bool next() override {
class GeneratorWrapper (line 3986) | class GeneratorWrapper final {
method GeneratorWrapper (line 3989) | GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
method T (line 3992) | T const& get() const {
method next (line 3995) | bool next() {
function value (line 4001) | GeneratorWrapper<T> value(T&& value) {
function values (line 4005) | GeneratorWrapper<T> values(std::initializer_list<T> values) {
class Generators (line 4010) | class Generators : public IGenerator<T> {
method populate (line 4014) | void populate(GeneratorWrapper<T>&& generator) {
method populate (line 4017) | void populate(T&& val) {
method populate (line 4021) | void populate(U&& val) {
method populate (line 4025) | void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
method Generators (line 4032) | Generators(Gs &&... moreGenerators) {
method T (line 4037) | T const& get() const override {
method next (line 4041) | bool next() override {
function table (line 4054) | GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std...
type as (line 4060) | struct as {}
function makeGenerators (line 4063) | auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreG...
function makeGenerators (line 4067) | auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators...
function makeGenerators (line 4071) | auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generator...
function makeGenerators (line 4075) | auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Ge...
function generate (line 4085) | auto generate( StringRef generatorName, SourceLineInfo const& lineIn...
class TakeGenerator (line 4120) | class TakeGenerator : public IGenerator<T> {
method TakeGenerator (line 4125) | TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
method T (line 4131) | T const& get() const override {
method next (line 4134) | bool next() override {
function take (line 4151) | GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& genera...
class FilterGenerator (line 4156) | class FilterGenerator : public IGenerator<T> {
method FilterGenerator (line 4161) | FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
method T (line 4175) | T const& get() const override {
method next (line 4179) | bool next() override {
method nextImpl (line 4184) | bool nextImpl() {
function filter (line 4195) | GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& g...
class RepeatGenerator (line 4200) | class RepeatGenerator : public IGenerator<T> {
method RepeatGenerator (line 4210) | RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
method T (line 4217) | T const& get() const override {
method next (line 4225) | bool next() override {
function repeat (line 4251) | GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& gen...
class MapGenerator (line 4256) | class MapGenerator : public IGenerator<T> {
method MapGenerator (line 4264) | MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
method T (line 4270) | T const& get() const override {
method next (line 4273) | bool next() override {
function map (line 4283) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
function map (line 4290) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
class ChunkGenerator (line 4297) | class ChunkGenerator final : public IGenerator<std::vector<T>> {
method ChunkGenerator (line 4303) | ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
method next (line 4320) | bool next() override {
function chunk (line 4333) | GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper...
class RandomFloatingGenerator (line 4603) | class RandomFloatingGenerator final : public IGenerator<Float> {
method RandomFloatingGenerator (line 4609) | RandomFloatingGenerator(Float a, Float b):
method Float (line 4615) | Float const& get() const override {
method next (line 4618) | bool next() override {
class RandomIntegerGenerator (line 4625) | class RandomIntegerGenerator final : public IGenerator<Integer> {
method RandomIntegerGenerator (line 4631) | RandomIntegerGenerator(Integer a, Integer b):
method Integer (line 4637) | Integer const& get() const override {
method next (line 4640) | bool next() override {
function random (line 4649) | typename std::enable_if<std::is_integral<T>::value && !std::is_same<...
function random (line 4658) | typename std::enable_if<std::is_floating_point<T>::value,
class RangeGenerator (line 4667) | class RangeGenerator final : public IGenerator<T> {
method RangeGenerator (line 4674) | RangeGenerator(T const& start, T const& end, T const& step):
method RangeGenerator (line 4685) | RangeGenerator(T const& start, T const& end):
method T (line 4689) | T const& get() const override {
method next (line 4693) | bool next() override {
function range (line 4700) | GeneratorWrapper<T> range(T const& start, T const& end, T const& ste...
function range (line 4706) | GeneratorWrapper<T> range(T const& start, T const& end) {
class IteratorGenerator (line 4712) | class IteratorGenerator final : public IGenerator<T> {
method IteratorGenerator (line 4721) | IteratorGenerator(InputIterator first, InputSentinel last):m_elems...
method T (line 4727) | T const& get() const override {
method next (line 4731) | bool next() override {
function from_range (line 4740) | GeneratorWrapper<ResultType> from_range(InputIterator from, InputSen...
function from_range (line 4746) | GeneratorWrapper<ResultType> from_range(Container const& cnt) {
function acquireGeneratorTracker (line 10980) | auto acquireGeneratorTracker( StringRef generatorName, SourceLineInf...
type GeneratorTracker (line 12586) | struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorT...
method GeneratorTracker (line 12589) | GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAnd...
method GeneratorTracker (line 12594) | static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTra...
method isGeneratorTracker (line 12631) | bool isGeneratorTracker() const override { return true; }
method hasGenerator (line 12632) | auto hasGenerator() const -> bool override {
method close (line 12635) | void close() override {
method getGenerator (line 12705) | auto getGenerator() const -> GeneratorBasePtr const& override {
method setGenerator (line 12708) | void setGenerator( GeneratorBasePtr&& generator ) override {
type Generators (line 4117) | namespace Generators {
class GeneratorUntypedBase (line 3845) | class GeneratorUntypedBase {
method GeneratorUntypedBase (line 3847) | GeneratorUntypedBase() = default;
type pf (line 3933) | namespace pf{
function make_unique (line 3935) | std::unique_ptr<T> make_unique( Args&&... args ) {
type IGenerator (line 3941) | struct IGenerator : GeneratorUntypedBase {
class SingleValueGenerator (line 3953) | class SingleValueGenerator final : public IGenerator<T> {
method SingleValueGenerator (line 3956) | SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
method T (line 3958) | T const& get() const override {
method next (line 3961) | bool next() override {
class FixedValuesGenerator (line 3967) | class FixedValuesGenerator final : public IGenerator<T> {
method FixedValuesGenerator (line 3974) | FixedValuesGenerator( std::initializer_list<T> values ) : m_values...
method T (line 3976) | T const& get() const override {
method next (line 3979) | bool next() override {
class GeneratorWrapper (line 3986) | class GeneratorWrapper final {
method GeneratorWrapper (line 3989) | GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
method T (line 3992) | T const& get() const {
method next (line 3995) | bool next() {
function value (line 4001) | GeneratorWrapper<T> value(T&& value) {
function values (line 4005) | GeneratorWrapper<T> values(std::initializer_list<T> values) {
class Generators (line 4010) | class Generators : public IGenerator<T> {
method populate (line 4014) | void populate(GeneratorWrapper<T>&& generator) {
method populate (line 4017) | void populate(T&& val) {
method populate (line 4021) | void populate(U&& val) {
method populate (line 4025) | void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
method Generators (line 4032) | Generators(Gs &&... moreGenerators) {
method T (line 4037) | T const& get() const override {
method next (line 4041) | bool next() override {
function table (line 4054) | GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std...
type as (line 4060) | struct as {}
function makeGenerators (line 4063) | auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreG...
function makeGenerators (line 4067) | auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators...
function makeGenerators (line 4071) | auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generator...
function makeGenerators (line 4075) | auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Ge...
function generate (line 4085) | auto generate( StringRef generatorName, SourceLineInfo const& lineIn...
class TakeGenerator (line 4120) | class TakeGenerator : public IGenerator<T> {
method TakeGenerator (line 4125) | TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
method T (line 4131) | T const& get() const override {
method next (line 4134) | bool next() override {
function take (line 4151) | GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& genera...
class FilterGenerator (line 4156) | class FilterGenerator : public IGenerator<T> {
method FilterGenerator (line 4161) | FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
method T (line 4175) | T const& get() const override {
method next (line 4179) | bool next() override {
method nextImpl (line 4184) | bool nextImpl() {
function filter (line 4195) | GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& g...
class RepeatGenerator (line 4200) | class RepeatGenerator : public IGenerator<T> {
method RepeatGenerator (line 4210) | RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
method T (line 4217) | T const& get() const override {
method next (line 4225) | bool next() override {
function repeat (line 4251) | GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& gen...
class MapGenerator (line 4256) | class MapGenerator : public IGenerator<T> {
method MapGenerator (line 4264) | MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
method T (line 4270) | T const& get() const override {
method next (line 4273) | bool next() override {
function map (line 4283) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
function map (line 4290) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
class ChunkGenerator (line 4297) | class ChunkGenerator final : public IGenerator<std::vector<T>> {
method ChunkGenerator (line 4303) | ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
method next (line 4320) | bool next() override {
function chunk (line 4333) | GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper...
class RandomFloatingGenerator (line 4603) | class RandomFloatingGenerator final : public IGenerator<Float> {
method RandomFloatingGenerator (line 4609) | RandomFloatingGenerator(Float a, Float b):
method Float (line 4615) | Float const& get() const override {
method next (line 4618) | bool next() override {
class RandomIntegerGenerator (line 4625) | class RandomIntegerGenerator final : public IGenerator<Integer> {
method RandomIntegerGenerator (line 4631) | RandomIntegerGenerator(Integer a, Integer b):
method Integer (line 4637) | Integer const& get() const override {
method next (line 4640) | bool next() override {
function random (line 4649) | typename std::enable_if<std::is_integral<T>::value && !std::is_same<...
function random (line 4658) | typename std::enable_if<std::is_floating_point<T>::value,
class RangeGenerator (line 4667) | class RangeGenerator final : public IGenerator<T> {
method RangeGenerator (line 4674) | RangeGenerator(T const& start, T const& end, T const& step):
method RangeGenerator (line 4685) | RangeGenerator(T const& start, T const& end):
method T (line 4689) | T const& get() const override {
method next (line 4693) | bool next() override {
function range (line 4700) | GeneratorWrapper<T> range(T const& start, T const& end, T const& ste...
function range (line 4706) | GeneratorWrapper<T> range(T const& start, T const& end) {
class IteratorGenerator (line 4712) | class IteratorGenerator final : public IGenerator<T> {
method IteratorGenerator (line 4721) | IteratorGenerator(InputIterator first, InputSentinel last):m_elems...
method T (line 4727) | T const& get() const override {
method next (line 4731) | bool next() override {
function from_range (line 4740) | GeneratorWrapper<ResultType> from_range(InputIterator from, InputSen...
function from_range (line 4746) | GeneratorWrapper<ResultType> from_range(Container const& cnt) {
function acquireGeneratorTracker (line 10980) | auto acquireGeneratorTracker( StringRef generatorName, SourceLineInf...
type GeneratorTracker (line 12586) | struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorT...
method GeneratorTracker (line 12589) | GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAnd...
method GeneratorTracker (line 12594) | static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTra...
method isGeneratorTracker (line 12631) | bool isGeneratorTracker() const override { return true; }
method hasGenerator (line 12632) | auto hasGenerator() const -> bool override {
method close (line 12635) | void close() override {
method getGenerator (line 12705) | auto getGenerator() const -> GeneratorBasePtr const& override {
method setGenerator (line 12708) | void setGenerator( GeneratorBasePtr&& generator ) override {
type IResultCapture (line 4351) | struct IResultCapture
type IRunner (line 4352) | struct IRunner
type IConfig (line 4353) | struct IConfig
type IMutableContext (line 4354) | struct IMutableContext
type IContext (line 4358) | struct IContext
type IMutableContext (line 4367) | struct IMutableContext : IContext
function IMutableContext (line 4381) | inline IMutableContext& getCurrentMutableContext()
function IContext (line 4389) | inline IContext& getCurrentContext()
class SimplePcg32 (line 4396) | class SimplePcg32
method SimplePcg32 (line 4570) | SimplePcg32():SimplePcg32(0xed743cc4U) {}
class Option (line 4409) | class Option {
method Option (line 4411) | Option() : nullableValue( nullptr ) {}
method Option (line 4412) | Option( T const& _value )
method Option (line 4415) | Option( Option const& _other )
method Option (line 4423) | Option& operator= ( Option const& _other ) {
method Option (line 4431) | Option& operator = ( T const& _value ) {
method reset (line 4437) | void reset() {
method T (line 4443) | T& operator*() { return *nullableValue; }
method T (line 4444) | T const& operator*() const { return *nullableValue; }
method T (line 4445) | T* operator->() { return nullableValue; }
method T (line 4446) | const T* operator->() const { return nullableValue; }
method T (line 4448) | T valueOr( T const& defaultValue ) const {
method some (line 4452) | bool some() const { return nullableValue != nullptr; }
method none (line 4453) | bool none() const { return nullableValue == nullptr; }
type Verbosity (line 4476) | enum class Verbosity {
type WarnAbout (line 4482) | struct WarnAbout { enum What {
type What (line 4482) | enum What {
type ShowDurations (line 4488) | struct ShowDurations { enum OrNot {
type OrNot (line 4488) | enum OrNot {
type RunTests (line 4493) | struct RunTests { enum InWhatOrder {
type InWhatOrder (line 4493) | enum InWhatOrder {
type UseColour (line 4498) | struct UseColour { enum YesOrNo {
type YesOrNo (line 4498) | enum YesOrNo {
type WaitForKeypress (line 4503) | struct WaitForKeypress { enum When {
type When (line 4503) | enum When {
class TestSpec (line 4510) | class TestSpec
class Pattern (line 5112) | class Pattern {
class NamePattern (line 5123) | class NamePattern : public Pattern {
class TagPattern (line 5131) | class TagPattern : public Pattern {
class ExcludedPattern (line 5139) | class ExcludedPattern : public Pattern {
type Filter (line 5147) | struct Filter {
type FilterMatch (line 5155) | struct FilterMatch {
type IConfig (line 4512) | struct IConfig : NonCopyable {
class SimplePcg32 (line 4558) | class SimplePcg32 {
method SimplePcg32 (line 4570) | SimplePcg32():SimplePcg32(0xed743cc4U) {}
type Generators (line 4600) | namespace Generators {
class GeneratorUntypedBase (line 3845) | class GeneratorUntypedBase {
method GeneratorUntypedBase (line 3847) | GeneratorUntypedBase() = default;
type pf (line 3933) | namespace pf{
function make_unique (line 3935) | std::unique_ptr<T> make_unique( Args&&... args ) {
type IGenerator (line 3941) | struct IGenerator : GeneratorUntypedBase {
class SingleValueGenerator (line 3953) | class SingleValueGenerator final : public IGenerator<T> {
method SingleValueGenerator (line 3956) | SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
method T (line 3958) | T const& get() const override {
method next (line 3961) | bool next() override {
class FixedValuesGenerator (line 3967) | class FixedValuesGenerator final : public IGenerator<T> {
method FixedValuesGenerator (line 3974) | FixedValuesGenerator( std::initializer_list<T> values ) : m_values...
method T (line 3976) | T const& get() const override {
method next (line 3979) | bool next() override {
class GeneratorWrapper (line 3986) | class GeneratorWrapper final {
method GeneratorWrapper (line 3989) | GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
method T (line 3992) | T const& get() const {
method next (line 3995) | bool next() {
function value (line 4001) | GeneratorWrapper<T> value(T&& value) {
function values (line 4005) | GeneratorWrapper<T> values(std::initializer_list<T> values) {
class Generators (line 4010) | class Generators : public IGenerator<T> {
method populate (line 4014) | void populate(GeneratorWrapper<T>&& generator) {
method populate (line 4017) | void populate(T&& val) {
method populate (line 4021) | void populate(U&& val) {
method populate (line 4025) | void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
method Generators (line 4032) | Generators(Gs &&... moreGenerators) {
method T (line 4037) | T const& get() const override {
method next (line 4041) | bool next() override {
function table (line 4054) | GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std...
type as (line 4060) | struct as {}
function makeGenerators (line 4063) | auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreG...
function makeGenerators (line 4067) | auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators...
function makeGenerators (line 4071) | auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generator...
function makeGenerators (line 4075) | auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Ge...
function generate (line 4085) | auto generate( StringRef generatorName, SourceLineInfo const& lineIn...
class TakeGenerator (line 4120) | class TakeGenerator : public IGenerator<T> {
method TakeGenerator (line 4125) | TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
method T (line 4131) | T const& get() const override {
method next (line 4134) | bool next() override {
function take (line 4151) | GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& genera...
class FilterGenerator (line 4156) | class FilterGenerator : public IGenerator<T> {
method FilterGenerator (line 4161) | FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
method T (line 4175) | T const& get() const override {
method next (line 4179) | bool next() override {
method nextImpl (line 4184) | bool nextImpl() {
function filter (line 4195) | GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& g...
class RepeatGenerator (line 4200) | class RepeatGenerator : public IGenerator<T> {
method RepeatGenerator (line 4210) | RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
method T (line 4217) | T const& get() const override {
method next (line 4225) | bool next() override {
function repeat (line 4251) | GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& gen...
class MapGenerator (line 4256) | class MapGenerator : public IGenerator<T> {
method MapGenerator (line 4264) | MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
method T (line 4270) | T const& get() const override {
method next (line 4273) | bool next() override {
function map (line 4283) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
function map (line 4290) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
class ChunkGenerator (line 4297) | class ChunkGenerator final : public IGenerator<std::vector<T>> {
method ChunkGenerator (line 4303) | ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
method next (line 4320) | bool next() override {
function chunk (line 4333) | GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper...
class RandomFloatingGenerator (line 4603) | class RandomFloatingGenerator final : public IGenerator<Float> {
method RandomFloatingGenerator (line 4609) | RandomFloatingGenerator(Float a, Float b):
method Float (line 4615) | Float const& get() const override {
method next (line 4618) | bool next() override {
class RandomIntegerGenerator (line 4625) | class RandomIntegerGenerator final : public IGenerator<Integer> {
method RandomIntegerGenerator (line 4631) | RandomIntegerGenerator(Integer a, Integer b):
method Integer (line 4637) | Integer const& get() const override {
method next (line 4640) | bool next() override {
function random (line 4649) | typename std::enable_if<std::is_integral<T>::value && !std::is_same<...
function random (line 4658) | typename std::enable_if<std::is_floating_point<T>::value,
class RangeGenerator (line 4667) | class RangeGenerator final : public IGenerator<T> {
method RangeGenerator (line 4674) | RangeGenerator(T const& start, T const& end, T const& step):
method RangeGenerator (line 4685) | RangeGenerator(T const& start, T const& end):
method T (line 4689) | T const& get() const override {
method next (line 4693) | bool next() override {
function range (line 4700) | GeneratorWrapper<T> range(T const& start, T const& end, T const& ste...
function range (line 4706) | GeneratorWrapper<T> range(T const& start, T const& end) {
class IteratorGenerator (line 4712) | class IteratorGenerator final : public IGenerator<T> {
method IteratorGenerator (line 4721) | IteratorGenerator(InputIterator first, InputSentinel last):m_elems...
method T (line 4727) | T const& get() const override {
method next (line 4731) | bool next() override {
function from_range (line 4740) | GeneratorWrapper<ResultType> from_range(InputIterator from, InputSen...
function from_range (line 4746) | GeneratorWrapper<ResultType> from_range(Container const& cnt) {
function acquireGeneratorTracker (line 10980) | auto acquireGeneratorTracker( StringRef generatorName, SourceLineInf...
type GeneratorTracker (line 12586) | struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorT...
method GeneratorTracker (line 12589) | GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAnd...
method GeneratorTracker (line 12594) | static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTra...
method isGeneratorTracker (line 12631) | bool isGeneratorTracker() const override { return true; }
method hasGenerator (line 12632) | auto hasGenerator() const -> bool override {
method close (line 12635) | void close() override {
method getGenerator (line 12705) | auto getGenerator() const -> GeneratorBasePtr const& override {
method setGenerator (line 12708) | void setGenerator( GeneratorBasePtr&& generator ) override {
type ITestInvoker (line 4770) | struct ITestInvoker
type TestCaseInfo (line 4772) | struct TestCaseInfo {
type SpecialProperties (line 4773) | enum SpecialProperties{
class TestCase (line 4807) | class TestCase : public TestCaseInfo {
type IRunner (line 4840) | struct IRunner {
class WildcardPattern (line 5080) | class WildcardPattern {
type WildcardPosition (line 5081) | enum WildcardPosition {
type IConfig (line 5109) | struct IConfig
class TestSpec (line 5111) | class TestSpec {
class Pattern (line 5112) | class Pattern {
class NamePattern (line 5123) | class NamePattern : public Pattern {
class TagPattern (line 5131) | class TagPattern : public Pattern {
class ExcludedPattern (line 5139) | class ExcludedPattern : public Pattern {
type Filter (line 5147) | struct Filter {
type FilterMatch (line 5155) | struct FilterMatch {
type TagAlias (line 5185) | struct TagAlias
type ITagAliasRegistry (line 5187) | struct ITagAliasRegistry {
class TestSpecParser (line 5201) | class TestSpecParser {
type Mode (line 5202) | enum Mode{ None, Name, QuotedName, Tag, EscapedName }
method addCharToPattern (line 5243) | inline void addCharToPattern(char c) {
type IStream (line 5271) | struct IStream
type ConfigData (line 5273) | struct ConfigData {
class Config (line 5317) | class Config : public IConfig {
method Config (line 5320) | Config() = default;
type AssertionResultData (line 5383) | struct AssertionResultData
method AssertionResultData (line 5385) | AssertionResultData() = delete;
class AssertionResult (line 5397) | class AssertionResult {
method AssertionResult (line 5399) | AssertionResult() = delete;
type Benchmark (line 5430) | namespace Benchmark {
type Estimate (line 5432) | struct Estimate {
type OutlierClassification (line 5453) | struct OutlierClassification {
method total (line 5460) | int total() const {
type now (line 6469) | struct now {
function keep_memory (line 6493) | inline void keep_memory(T* p) {
function keep_memory (line 6496) | inline void keep_memory() {
type Detail (line 6500) | namespace Detail {
function optimizer_barrier (line 6501) | inline void optimizer_barrier() { keep_memory(); }
function optimizer_barrier (line 6515) | inline void optimizer_barrier() {
type CompleteType (line 6552) | struct CompleteType { using type = T; }
type CompleteType<void> (line 6554) | struct CompleteType<void> { struct type {}; }
type type (line 6554) | struct type {}
type CompleteInvoker (line 6560) | struct CompleteInvoker {
method Result (line 6562) | static Result invoke(Fun&& fun, Args&&... args) {
type CompleteInvoker<void> (line 6567) | struct CompleteInvoker<void> {
method invoke (line 6569) | static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
function complete_invoke (line 6577) | CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(F...
type ChronometerConcept (line 6600) | struct ChronometerConcept {
type ChronometerModel (line 6606) | struct ChronometerModel final : public ChronometerConcept {
method start (line 6607) | void start() override { started = Clock::now(); }
method finish (line 6608) | void finish() override { finished = Clock::now(); }
method elapsed (line 6610) | ClockDuration<Clock> elapsed() const { return finished - started; }
type is_related (line 6698) | struct is_related
type BenchmarkFunction (line 6708) | struct BenchmarkFunction {
type callable (line 6710) | struct callable {
type model (line 6716) | struct model : public callable {
method model (line 6717) | model(Fun&& fun) : fun(std::move(fun)) {}
method model (line 6718) | model(Fun const& fun) : fun(fun) {}
method call (line 6722) | void call(Chronometer meter) const override {
method call (line 6725) | void call(Chronometer meter, std::true_type) const {
method call (line 6728) | void call(Chronometer meter, std::false_type) const {
type do_nothing (line 6735) | struct do_nothing { void operator()() const {} }
method BenchmarkFunction (line 6738) | BenchmarkFunction(model<T>* c) : f(c) {}
method BenchmarkFunction (line 6741) | BenchmarkFunction()
method BenchmarkFunction (line 6746) | BenchmarkFunction(Fun&& fun)
method BenchmarkFunction (line 6749) | BenchmarkFunction(BenchmarkFunction&& that)
method BenchmarkFunction (line 6752) | BenchmarkFunction(BenchmarkFunction const& that)
method BenchmarkFunction (line 6755) | BenchmarkFunction& operator=(BenchmarkFunction&& that) {
method BenchmarkFunction (line 6760) | BenchmarkFunction& operator=(BenchmarkFunction const& that) {
type repeater (line 6787) | struct repeater {
function repeat (line 6796) | repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
function measure (line 6842) | TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
function measure_one (line 6861) | TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::f...
function measure_one (line 6865) | TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters...
type optimized_away_error (line 6875) | struct optimized_away_error : std::exception {
function run_for_at_least (line 6882) | TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>> run_...
function OutlierClassification (line 6967) | OutlierClassification classify_outliers(Iterator first, Iterator l...
function mean (line 6991) | double mean(Iterator first, Iterator last) {
function sample (line 6998) | sample resample(URng& rng, int resamples, Iterator first, Iterator...
function sample (line 7015) | sample jackknife(Estimator&& estimator, Iterator first, Iterator l...
function normal_cdf (line 7029) | inline double normal_cdf(double x) {
function bootstrap (line 7038) | Estimate<double> bootstrap(double confidence_level, Iterator first...
type bootstrap_analysis (line 7079) | struct bootstrap_analysis {
function resolution (line 7101) | std::vector<double> resolution(int k) {
function warmup (line 7126) | int warmup() {
function estimate_clock_resolution (line 7131) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolutio...
function estimate_clock_cost (line 7140) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(Floa...
function measure_environment (line 7168) | Environment<FloatDuration<Clock>> measure_environment() {
function analyse (line 7237) | SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<D...
type ObjectStorage (line 7396) | struct ObjectStorage
method ObjectStorage (line 7398) | ObjectStorage() : data() {}
method ObjectStorage (line 7400) | ObjectStorage(const ObjectStorage& other)
method ObjectStorage (line 7405) | ObjectStorage(ObjectStorage&& other)
method construct (line 7413) | void construct(Args&&... args)
method destruct (line 7419) | typename std::enable_if<AllowManualDestruction>::type destruct()
method destruct_on_exit (line 7427) | void destruct_on_exit(typename std::enable_if<Destruct, U>::type...
method destruct_on_exit (line 7430) | void destruct_on_exit(typename std::enable_if<!Destruct, U>::typ...
method T (line 7432) | T& stored_object() {
method T (line 7436) | T const& stored_object() const {
function weighted_average_quantile (line 7751) | double weighted_average_quantile(int k, int q, std::vector<double>...
function erfc_inv (line 7764) | double erfc_inv(double x) {
function normal_quantile (line 7768) | double normal_quantile(double p) {
function outlier_variance (line 7784) | double outlier_variance(Estimate<double> mean, Estimate<double> st...
function bootstrap_analysis (line 7810) | bootstrap_analysis analyse_samples(double confidence_level, int n_...
function keep_memory (line 6507) | inline void keep_memory(T* p) {
type Detail (line 6514) | namespace Detail {
function optimizer_barrier (line 6501) | inline void optimizer_barrier() { keep_memory(); }
function optimizer_barrier (line 6515) | inline void optimizer_barrier() {
type CompleteType (line 6552) | struct CompleteType { using type = T; }
type CompleteType<void> (line 6554) | struct CompleteType<void> { struct type {}; }
type type (line 6554) | struct type {}
type CompleteInvoker (line 6560) | struct CompleteInvoker {
method Result (line 6562) | static Result invoke(Fun&& fun, Args&&... args) {
type CompleteInvoker<void> (line 6567) | struct CompleteInvoker<void> {
method invoke (line 6569) | static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
function complete_invoke (line 6577) | CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(F...
type ChronometerConcept (line 6600) | struct ChronometerConcept {
type ChronometerModel (line 6606) | struct ChronometerModel final : public ChronometerConcept {
method start (line 6607) | void start() override { started = Clock::now(); }
method finish (line 6608) | void finish() override { finished = Clock::now(); }
method elapsed (line 6610) | ClockDuration<Clock> elapsed() const { return finished - started; }
type is_related (line 6698) | struct is_related
type BenchmarkFunction (line 6708) | struct BenchmarkFunction {
type callable (line 6710) | struct callable {
type model (line 6716) | struct model : public callable {
method model (line 6717) | model(Fun&& fun) : fun(std::move(fun)) {}
method model (line 6718) | model(Fun const& fun) : fun(fun) {}
method call (line 6722) | void call(Chronometer meter) const override {
method call (line 6725) | void call(Chronometer meter, std::true_type) const {
method call (line 6728) | void call(Chronometer meter, std::false_type) const {
type do_nothing (line 6735) | struct do_nothing { void operator()() const {} }
method BenchmarkFunction (line 6738) | BenchmarkFunction(model<T>* c) : f(c) {}
method BenchmarkFunction (line 6741) | BenchmarkFunction()
method BenchmarkFunction (line 6746) | BenchmarkFunction(Fun&& fun)
method BenchmarkFunction (line 6749) | BenchmarkFunction(BenchmarkFunction&& that)
method BenchmarkFunction (line 6752) | BenchmarkFunction(BenchmarkFunction const& that)
method BenchmarkFunction (line 6755) | BenchmarkFunction& operator=(BenchmarkFunction&& that) {
method BenchmarkFunction (line 6760) | BenchmarkFunction& operator=(BenchmarkFunction const& that) {
type repeater (line 6787) | struct repeater {
function repeat (line 6796) | repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
function measure (line 6842) | TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
function measure_one (line 6861) | TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::f...
function measure_one (line 6865) | TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters...
type optimized_away_error (line 6875) | struct optimized_away_error : std::exception {
function run_for_at_least (line 6882) | TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>> run_...
function OutlierClassification (line 6967) | OutlierClassification classify_outliers(Iterator first, Iterator l...
function mean (line 6991) | double mean(Iterator first, Iterator last) {
function sample (line 6998) | sample resample(URng& rng, int resamples, Iterator first, Iterator...
function sample (line 7015) | sample jackknife(Estimator&& estimator, Iterator first, Iterator l...
function normal_cdf (line 7029) | inline double normal_cdf(double x) {
function bootstrap (line 7038) | Estimate<double> bootstrap(double confidence_level, Iterator first...
type bootstrap_analysis (line 7079) | struct bootstrap_analysis {
function resolution (line 7101) | std::vector<double> resolution(int k) {
function warmup (line 7126) | int warmup() {
function estimate_clock_resolution (line 7131) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolutio...
function estimate_clock_cost (line 7140) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(Floa...
function measure_environment (line 7168) | Environment<FloatDuration<Clock>> measure_environment() {
function analyse (line 7237) | SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<D...
type ObjectStorage (line 7396) | struct ObjectStorage
method ObjectStorage (line 7398) | ObjectStorage() : data() {}
method ObjectStorage (line 7400) | ObjectStorage(const ObjectStorage& other)
method ObjectStorage (line 7405) | ObjectStorage(ObjectStorage&& other)
method construct (line 7413) | void construct(Args&&... args)
method destruct (line 7419) | typename std::enable_if<AllowManualDestruction>::type destruct()
method destruct_on_exit (line 7427) | void destruct_on_exit(typename std::enable_if<Destruct, U>::type...
method destruct_on_exit (line 7430) | void destruct_on_exit(typename std::enable_if<!Destruct, U>::typ...
method T (line 7432) | T& stored_object() {
method T (line 7436) | T const& stored_object() const {
function weighted_average_quantile (line 7751) | double weighted_average_quantile(int k, int q, std::vector<double>...
function erfc_inv (line 7764) | double erfc_inv(double x) {
function normal_quantile (line 7768) | double normal_quantile(double p) {
function outlier_variance (line 7784) | double outlier_variance(Estimate<double> mean, Estimate<double> st...
function bootstrap_analysis (line 7810) | bootstrap_analysis analyse_samples(double confidence_level, int n_...
function deoptimize_value (line 6523) | inline void deoptimize_value(T&& x) {
function invoke_deoptimized (line 6528) | inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename ...
function invoke_deoptimized (line 6533) | inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename ...
type Detail (line 6550) | namespace Detail {
function optimizer_barrier (line 6501) | inline void optimizer_barrier() { keep_memory(); }
function optimizer_barrier (line 6515) | inline void optimizer_barrier() {
type CompleteType (line 6552) | struct CompleteType { using type = T; }
type CompleteType<void> (line 6554) | struct CompleteType<void> { struct type {}; }
type type (line 6554) | struct type {}
type CompleteInvoker (line 6560) | struct CompleteInvoker {
method Result (line 6562) | static Result invoke(Fun&& fun, Args&&... args) {
type CompleteInvoker<void> (line 6567) | struct CompleteInvoker<void> {
method invoke (line 6569) | static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
function complete_invoke (line 6577) | CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(F...
type ChronometerConcept (line 6600) | struct ChronometerConcept {
type ChronometerModel (line 6606) | struct ChronometerModel final : public ChronometerConcept {
method start (line 6607) | void start() override { started = Clock::now(); }
method finish (line 6608) | void finish() override { finished = Clock::now(); }
method elapsed (line 6610) | ClockDuration<Clock> elapsed() const { return finished - started; }
type is_related (line 6698) | struct is_related
type BenchmarkFunction (line 6708) | struct BenchmarkFunction {
type callable (line 6710) | struct callable {
type model (line 6716) | struct model : public callable {
method model (line 6717) | model(Fun&& fun) : fun(std::move(fun)) {}
method model (line 6718) | model(Fun const& fun) : fun(fun) {}
method call (line 6722) | void call(Chronometer meter) const override {
method call (line 6725) | void call(Chronometer meter, std::true_type) const {
method call (line 6728) | void call(Chronometer meter, std::false_type) const {
type do_nothing (line 6735) | struct do_nothing { void operator()() const {} }
method BenchmarkFunction (line 6738) | BenchmarkFunction(model<T>* c) : f(c) {}
method BenchmarkFunction (line 6741) | BenchmarkFunction()
method BenchmarkFunction (line 6746) | BenchmarkFunction(Fun&& fun)
method BenchmarkFunction (line 6749) | BenchmarkFunction(BenchmarkFunction&& that)
method BenchmarkFunction (line 6752) | BenchmarkFunction(BenchmarkFunction const& that)
method BenchmarkFunction (line 6755) | BenchmarkFunction& operator=(BenchmarkFunction&& that) {
method BenchmarkFunction (line 6760) | BenchmarkFunction& operator=(BenchmarkFunction const& that) {
type repeater (line 6787) | struct repeater {
function repeat (line 6796) | repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
function measure (line 6842) | TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
function measure_one (line 6861) | TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::f...
function measure_one (line 6865) | TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters...
type optimized_away_error (line 6875) | struct optimized_away_error : std::exception {
function run_for_at_least (line 6882) | TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>> run_...
function OutlierClassification (line 6967) | OutlierClassification classify_outliers(Iterator first, Iterator l...
function mean (line 6991) | double mean(Iterator first, Iterator last) {
function sample (line 6998) | sample resample(URng& rng, int resamples, Iterator first, Iterator...
function sample (line 7015) | sample jackknife(Estimator&& estimator, Iterator first, Iterator l...
function normal_cdf (line 7029) | inline double normal_cdf(double x) {
function bootstrap (line 7038) | Estimate<double> bootstrap(double confidence_level, Iterator first...
type bootstrap_analysis (line 7079) | struct bootstrap_analysis {
function resolution (line 7101) | std::vector<double> resolution(int k) {
function warmup (line 7126) | int warmup() {
function estimate_clock_resolution (line 7131) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolutio...
function estimate_clock_cost (line 7140) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(Floa...
function measure_environment (line 7168) | Environment<FloatDuration<Clock>> measure_environment() {
function analyse (line 7237) | SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<D...
type ObjectStorage (line 7396) | struct ObjectStorage
method ObjectStorage (line 7398) | ObjectStorage() : data() {}
method ObjectStorage (line 7400) | ObjectStorage(const ObjectStorage& other)
method ObjectStorage (line 7405) | ObjectStorage(ObjectStorage&& other)
method construct (line 7413) | void construct(Args&&... args)
method destruct (line 7419) | typename std::enable_if<AllowManualDestruction>::type destruct()
method destruct_on_exit (line 7427) | void destruct_on_exit(typename std::enable_if<Destruct, U>::type...
method destruct_on_exit (line 7430) | void destruct_on_exit(typename std::enable_if<!Destruct, U>::typ...
method T (line 7432) | T& stored_object() {
method T (line 7436) | T const& stored_object() const {
function weighted_average_quantile (line 7751) | double weighted_average_quantile(int k, int q, std::vector<double>...
function erfc_inv (line 7764) | double erfc_inv(double x) {
function normal_quantile (line 7768) | double normal_quantile(double p) {
function outlier_variance (line 7784) | double outlier_variance(Estimate<double> mean, Estimate<double> st...
function bootstrap_analysis (line 7810) | bootstrap_analysis analyse_samples(double confidence_level, int n_...
function user_code (line 6585) | Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
type Detail (line 6599) | namespace Detail {
function optimizer_barrier (line 6501) | inline void optimizer_barrier() { keep_memory(); }
function optimizer_barrier (line 6515) | inline void optimizer_barrier() {
type CompleteType (line 6552) | struct CompleteType { using type = T; }
type CompleteType<void> (line 6554) | struct CompleteType<void> { struct type {}; }
type type (line 6554) | struct type {}
type CompleteInvoker (line 6560) | struct CompleteInvoker {
method Result (line 6562) | static Result invoke(Fun&& fun, Args&&... args) {
type CompleteInvoker<void> (line 6567) | struct CompleteInvoker<void> {
method invoke (line 6569) | static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
function complete_invoke (line 6577) | CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(F...
type ChronometerConcept (line 6600) | struct ChronometerConcept {
type ChronometerModel (line 6606) | struct ChronometerModel final : public ChronometerConcept {
method start (line 6607) | void start() override { started = Clock::now(); }
method finish (line 6608) | void finish() override { finished = Clock::now(); }
method elapsed (line 6610) | ClockDuration<Clock> elapsed() const { return finished - started; }
type is_related (line 6698) | struct is_related
type BenchmarkFunction (line 6708) | struct BenchmarkFunction {
type callable (line 6710) | struct callable {
type model (line 6716) | struct model : public callable {
method model (line 6717) | model(Fun&& fun) : fun(std::move(fun)) {}
method model (line 6718) | model(Fun const& fun) : fun(fun) {}
method call (line 6722) | void call(Chronometer meter) const override {
method call (line 6725) | void call(Chronometer meter, std::true_type) const {
method call (line 6728) | void call(Chronometer meter, std::false_type) const {
type do_nothing (line 6735) | struct do_nothing { void operator()() const {} }
method BenchmarkFunction (lin
Condensed preview — 14 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (1,104K chars).
[
{
"path": ".circleci/config.yml",
"chars": 830,
"preview": "# Use the latest 2.1 version of CircleCI pipeline process engine.\n# See: https://circleci.com/docs/2.0/configuration-ref"
},
{
"path": ".gitattributes",
"chars": 2518,
"preview": "###############################################################################\n# Set default behavior to automatically "
},
{
"path": ".github/ISSUE_TEMPLATE/bug_report.md",
"chars": 834,
"preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n**Describe the b"
},
{
"path": ".gitignore",
"chars": 4480,
"preview": "## Ignore Visual Studio temporary files, build results, and\n## files generated by popular Visual Studio add-ons.\n\n# User"
},
{
"path": "CMakeLists.txt",
"chars": 2063,
"preview": "cmake_minimum_required(VERSION 3.8)\n\nproject(xxhash_cpp \n\tVERSION 0.8.1\n\tLANGUAGES CXX \n\tDESCRIPTION \"C++ port of the x"
},
{
"path": "CODE_OF_CONDUCT.md",
"chars": 3349,
"preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, w"
},
{
"path": "LICENSE",
"chars": 1356,
"preview": "BSD 2-Clause License\n\nCopyright (c) 2012-2020, Yann Collet\nCopyright (c) 2017-2020, Red Gavin\nAll rights reserved.\n\nRedi"
},
{
"path": "README.md",
"chars": 4918,
"preview": "# xxhash_cpp\nPort of the xxHash library to C++17.\n\n[![CircleCI](https://dl.circleci.com/status-badge/img/gh/RedSpah/xxha"
},
{
"path": "include/xxhash.hpp",
"chars": 70602,
"preview": "#pragma once\n#include <cstdint>\n#include <cstring>\n#include <array>\n#include <type_traits>\n#include <vector>\n#include <s"
},
{
"path": "test/CMakeLists.txt",
"chars": 836,
"preview": "option(XXH_CPP_USE_AVX2 \"Use AVX2 instructions for tests\" OFF)\n\nfunction(xxh_cpp_add_test name xxh_vector)\n add_executa"
},
{
"path": "test/catch.hpp",
"chars": 657411,
"preview": "/*\n * Catch v2.13.10\n * Generated: 2022-10-16 11:01:23.452308\n * ----------------------------------------------------"
},
{
"path": "test/test_main.cpp",
"chars": 44573,
"preview": "#include <array>\n#include <iomanip>\n#include <iostream>\n#include <chrono>\n#include <random>\n#include <algorithm>\n#includ"
},
{
"path": "test/xxh3.h",
"chars": 2393,
"preview": "/*\n * xxHash - Extremely Fast Hash algorithm\n * Development source file for `xxh3`\n * Copyright (C) 2019-2020 Yann Colle"
},
{
"path": "test/xxhash.h",
"chars": 268319,
"preview": "/*\n * xxHash - Extremely Fast Hash algorithm\n * Header File\n * Copyright (C) 2012-2023 Yann Collet\n *\n * BSD 2-Clause Li"
}
]
About this extraction
This page contains the full source code of the RedSpah/xxhash_cpp GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 14 files (1.0 MB), approximately 269.2k tokens, and a symbol index with 1826 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.