Showing preview only (907K chars total). Download the full file or copy to clipboard to get everything.
Repository: Qix-/tortellini
Branch: master
Commit: b47a39af410e
Files: 10
Total size: 883.8 KB
Directory structure:
gitextract_w1n33c92/
├── .editorconfig
├── .github/
│ ├── FUNDING.yml
│ └── workflows/
│ └── ci.yml
├── .gitignore
├── CMakeLists.txt
├── README.md
├── catch2/
│ ├── catch_amalgamated.cpp
│ └── catch_amalgamated.hpp
├── include/
│ └── tortellini.hh
└── test.cc
================================================
FILE CONTENTS
================================================
================================================
FILE: .editorconfig
================================================
root = true
[*]
indent_style = tab
indent_size = 4
tab_width = 4
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
[{*.json,*.json.example,*.gyp,*.yml,*.yaml}]
indent_style = space
indent_size = 2
[{*.py,*.asm}]
indent_style = space
[*.py]
indent_size = 4
[*.asm]
indent_size = 8
[*.md]
trim_trailing_whitespace = false
# Ideal settings - some plugins might support these.
[*.js]
quote_type = single
[{*.c,*.cc,*.h,*.hh,*.cpp,*.hpp,*.m,*.mm,*.mpp,*.js,*.java,*.go,*.rs,*.php,*.ng,*.jsx,*.ts,*.d,*.cs,*.swift}]
curly_bracket_next_line = false
spaces_around_operators = true
spaces_around_brackets = outside
# close enough to 1TB
indent_brace_style = K&R
================================================
FILE: .github/FUNDING.yml
================================================
github: qix-
================================================
FILE: .github/workflows/ci.yml
================================================
name: Test
on: [push]
jobs:
buildlinux:
name: Test
runs-on: ubuntu-latest
timeout-minutes: 3
steps:
- uses: actions/checkout@v2
- name: Install CMake
run: |
sudo apt install cmake
- name: Configure
run: |
mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Debug -DBUILD_TESTING=ON
- name: Build
run: |
cmake --build build
- name: Test
run: |
cd build && ctest -VV
================================================
FILE: .gitignore
================================================
/build/
/.cache/
================================================
FILE: CMakeLists.txt
================================================
project (tortellini)
cmake_minimum_required (VERSION 3.2)
add_library (tortellini INTERFACE)
target_include_directories (tortellini INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include")
target_sources (tortellini INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include/tortellini.hh")
if (BUILD_TESTING)
enable_testing ()
add_executable (tortellini-tests test.cc catch2/catch_amalgamated.hpp catch2/catch_amalgamated.cpp)
target_link_libraries (tortellini-tests PRIVATE tortellini)
target_compile_options (tortellini-tests PRIVATE
$<IF:$<CXX_COMPILER_ID:MSVC>,/W4,-Wall -Wextra -Werror -pedantic>
)
add_test (
NAME tortellini-test
COMMAND $<TARGET_FILE:tortellini-tests> -s
)
endif ()
================================================
FILE: README.md
================================================
<h1 align="center">
<img height="250" src="logo.png" alt="Tortellini">
</h1>
The stupid - _and I mean really, really stupid_ - INI file reader and writer for C++11 and above. Calorie free (no dependencies)!
```c++
#include <tortellini.hh>
// (optional)
#include <fstream>
int main() {
tortellini::ini ini;
// (optional) Read INI in from a file.
// Default construction and subsequent assignment is just fine, too.
std::ifstream in("config.ini");
in >> ini;
// Retrieval
//
// All value retrievals must be done via the "default" operator
// (the pipe operator).
//
// The right-hand-side type is what is returned. Anything other
// than a string-like type causes a parse (see caveats section below).
//
// All keys are case-INsensitive. This includes section headers.
std::string s = ini["Section"]["key"] | "default string";
int i = ini["Section"]["key"] | 42; // default int
long l = ini["Section"]["key"] | 42L; // default long
long long ll = ini["Section"]["key"] | 42LL; // default long long
unsigned int u = ini["Section"]["key"] | 42u; // default unsigned int
unsigned long ul = ini["Section"]["key"] | 42UL; // default unsigned long
unsigned long long ull = ini["Section"]["key"] | 42ULL; // default unsigned long long
float f = ini["Section"]["key"] | 42.0f; // default float
double d = ini["Section"]["key"] | 42.0; // default double
long double ld = ini["Section"]["key"] | 42.0L; // default long double
bool b = ini["Section"]["key"] | true; // default bool
// Assignment
//
// (This example uses the same key, but of course
// in reality this would just be overwriting the
// same key over and over again - probably not
// what you'd really want. I would hope I wouldn't
// have to explain this, but you never know.)
ini["New Section"]["new-key"] = "Noodles are tasty.";
ini["New Section"]["new-key"] = 1234;
ini["New Section"]["new-key"] = 1234u;
ini["New Section"]["new-key"] = 1234L;
ini["New Section"]["new-key"] = 1234UL;
ini["New Section"]["new-key"] = 1234LL;
ini["New Section"]["new-key"] = 1234ULL;
ini["New Section"]["new-key"] = 1234.0f;
ini["New Section"]["new-key"] = 1234.0;
ini["New Section"]["new-key"] = 1234.0L;
ini["New Section"]["new-key"] = true;
// "Naked" section (top-most key/value pairs, before a section header)
// denoted by empty string in section selector
ini[""]["naked-key"] = "I'll be at the very top, without a section";
// You can also iterate over all sections
for (auto &pair : ini) {
std::cout << pair.name << "\n"; // the name of the section
int v = pair.section["some-key"] | 1234;
std::cout << "some-key=" << v << "\n";
}
// (optional) Write INI to file.
std::ofstream out("config.ini");
out << ini;
}
```
# Things you should know.
This library has very few bells and whistles. It doesn't do anything fancy.
Here are the guarantees/features:
- Case-insensitive keys and section headers. Reading from a key/section with different cases will work fine, and writing to an existing section/key will preserve the casing.
- Untouched output (from using `stream << ini`) is guaranteed to be parsable (by using `stream >> ini`).
- Barring I/O issues or exceptions coming from the standard library, Tortellini will not throw or abort (see below section about "invalid data").
- _Pasta in, pasta out._ Source strings (from a parse) are preserved to the output. If you use `yes` instead of `true`, Tortellini will preserve that (unless the application overwrites the value).
- `yes`, `1` and `true` are all parsable as `bool(true)`. All other values equate to `false`. **NOTE:** This means that `ini[""]["b"] | true` will return `false`, _not_ `true`, if the key exists but is not a valid, parsable truth-ey value. This may be counter-intuitive for some users.
- All values are inherently string, and only parsed when retrieved.
Here are the caveats:
- **Do not store or share anything returned from the subscript operators (`[]`).** They return temporary objects that are meant for short-lived interactions. They are NOT lifetime safe and expect the underlying `tortellini::ini` instance to subsist beyond their own lifetimes.
- Invalid keys, values or section names skip the line entirely. This condition is henceforth referred to as "invalid data".
- Integer overflows when parsing are invalid data.
- Mismatched `]` for a `[` line is invalid data. Yes, keys _will_ bleed into the preceding section name. That's user error, not your application's. _Embrace it._
- Empty keys or empty values (excluding leading/trailing whitespace!) are "invalid data" in that they might be valid but not included in the resulting data and thus _won't_ be re-emitted.
- Empty sections (or sections with 100% invalid data as key/value pairs) are themselves invalid data and are not emitted.
- `[]` is a valid section name. It means the "naked" section. Re-emitting the INI will move those keys to the top regardless of where `[]` is positioned in the input file.
- No comments are supported; `;` is a valid (string) character.
- No caching or memoization; if you retrieve anything but a `std::string`, there _will_ be a parse. I never said Tortellini was hyper-over-optimized.
# Testing
You can test by running:
```bash
mkdir build && cd build
cmake .. -DBUILD_TESTING=ON -DCMAKE_BUILD_TYPE=Debug
cmake --build .
ctest
```
# License
You have two choices in license. Pick whichever one you want.
Tortellini is uncucumbered. Go crazy. Eat some pasta.
### Unlicense
```
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.
In jurisdictions that recognize copyright laws, the author or authors
of this software dedicate any and all copyright interest in the
software to the public domain. We make this dedication for the benefit
of the public at large and to the detriment of our heirs and
successors. We intend this dedication to be an overt act of
relinquishment in perpetuity of all present and future rights to this
software under copyright law.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
For more information, please refer to <http://unlicense.org/>
```
### MIT License
```
Copyright (c) 2020 Josh Junon
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```
================================================
FILE: catch2/catch_amalgamated.cpp
================================================
// Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
// SPDX-License-Identifier: BSL-1.0
// Catch v3.4.0
// Generated: 2023-07-13 13:23:09.554273
// ----------------------------------------------------------
// This file is an amalgamation of multiple different files.
// You probably shouldn't edit it directly.
// ----------------------------------------------------------
#include "catch_amalgamated.hpp"
#ifndef CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
#define CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
#if defined(CATCH_PLATFORM_WINDOWS)
// We might end up with the define made globally through the compiler,
// and we don't want to trigger warnings for this
#if !defined(NOMINMAX)
# define NOMINMAX
#endif
#if !defined(WIN32_LEAN_AND_MEAN)
# define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#endif // defined(CATCH_PLATFORM_WINDOWS)
#endif // CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
namespace Catch {
namespace Benchmark {
namespace Detail {
ChronometerConcept::~ChronometerConcept() = default;
} // namespace Detail
} // namespace Benchmark
} // namespace Catch
namespace Catch {
namespace Benchmark {
namespace Detail {
BenchmarkFunction::callable::~callable() = default;
} // namespace Detail
} // namespace Benchmark
} // namespace Catch
#include <exception>
namespace Catch {
namespace Benchmark {
namespace Detail {
struct optimized_away_error : std::exception {
const char* what() const noexcept override;
};
const char* optimized_away_error::what() const noexcept {
return "could not measure benchmark, maybe it was optimized away";
}
void throw_optimized_away_error() {
Catch::throw_exception(optimized_away_error{});
}
} // namespace Detail
} // namespace Benchmark
} // namespace Catch
// Adapted from donated nonius code.
#include <cassert>
#include <cstddef>
#include <numeric>
#include <random>
#if defined(CATCH_CONFIG_USE_ASYNC)
#include <future>
#endif
namespace Catch {
namespace Benchmark {
namespace Detail {
namespace {
template <typename URng, typename Estimator>
static sample
resample( URng& rng,
unsigned int resamples,
std::vector<double>::const_iterator first,
std::vector<double>::const_iterator last,
Estimator& estimator ) {
auto n = static_cast<size_t>( last - first );
std::uniform_int_distribution<decltype( n )> dist( 0,
n - 1 );
sample out;
out.reserve( resamples );
// We allocate the vector outside the loop to avoid realloc
// per resample
std::vector<double> resampled;
resampled.reserve( n );
for ( size_t i = 0; i < resamples; ++i ) {
resampled.clear();
for ( size_t s = 0; s < n; ++s ) {
resampled.push_back(
first[static_cast<std::ptrdiff_t>(
dist( rng ) )] );
}
const auto estimate =
estimator( resampled.begin(), resampled.end() );
out.push_back( estimate );
}
std::sort( out.begin(), out.end() );
return out;
}
static double outlier_variance( Estimate<double> mean,
Estimate<double> stddev,
int n ) {
double sb = stddev.point;
double mn = mean.point / n;
double mg_min = mn / 2.;
double sg = (std::min)( mg_min / 4., sb / std::sqrt( n ) );
double sg2 = sg * sg;
double sb2 = sb * sb;
auto c_max = [n, mn, sb2, sg2]( double x ) -> double {
double k = mn - x;
double d = k * k;
double nd = n * d;
double k0 = -n * nd;
double k1 = sb2 - n * sg2 + nd;
double det = k1 * k1 - 4 * sg2 * k0;
return static_cast<int>( -2. * k0 /
( k1 + std::sqrt( det ) ) );
};
auto var_out = [n, sb2, sg2]( double c ) {
double nc = n - c;
return ( nc / n ) * ( sb2 - nc * sg2 );
};
return (std::min)( var_out( 1 ),
var_out(
(std::min)( c_max( 0. ),
c_max( mg_min ) ) ) ) /
sb2;
}
static double erf_inv( double x ) {
// Code accompanying the article "Approximating the erfinv
// function" in GPU Computing Gems, Volume 2
double w, p;
w = -log( ( 1.0 - x ) * ( 1.0 + x ) );
if ( w < 6.250000 ) {
w = w - 3.125000;
p = -3.6444120640178196996e-21;
p = -1.685059138182016589e-19 + p * w;
p = 1.2858480715256400167e-18 + p * w;
p = 1.115787767802518096e-17 + p * w;
p = -1.333171662854620906e-16 + p * w;
p = 2.0972767875968561637e-17 + p * w;
p = 6.6376381343583238325e-15 + p * w;
p = -4.0545662729752068639e-14 + p * w;
p = -8.1519341976054721522e-14 + p * w;
p = 2.6335093153082322977e-12 + p * w;
p = -1.2975133253453532498e-11 + p * w;
p = -5.4154120542946279317e-11 + p * w;
p = 1.051212273321532285e-09 + p * w;
p = -4.1126339803469836976e-09 + p * w;
p = -2.9070369957882005086e-08 + p * w;
p = 4.2347877827932403518e-07 + p * w;
p = -1.3654692000834678645e-06 + p * w;
p = -1.3882523362786468719e-05 + p * w;
p = 0.0001867342080340571352 + p * w;
p = -0.00074070253416626697512 + p * w;
p = -0.0060336708714301490533 + p * w;
p = 0.24015818242558961693 + p * w;
p = 1.6536545626831027356 + p * w;
} else if ( w < 16.000000 ) {
w = sqrt( w ) - 3.250000;
p = 2.2137376921775787049e-09;
p = 9.0756561938885390979e-08 + p * w;
p = -2.7517406297064545428e-07 + p * w;
p = 1.8239629214389227755e-08 + p * w;
p = 1.5027403968909827627e-06 + p * w;
p = -4.013867526981545969e-06 + p * w;
p = 2.9234449089955446044e-06 + p * w;
p = 1.2475304481671778723e-05 + p * w;
p = -4.7318229009055733981e-05 + p * w;
p = 6.8284851459573175448e-05 + p * w;
p = 2.4031110387097893999e-05 + p * w;
p = -0.0003550375203628474796 + p * w;
p = 0.00095328937973738049703 + p * w;
p = -0.0016882755560235047313 + p * w;
p = 0.0024914420961078508066 + p * w;
p = -0.0037512085075692412107 + p * w;
p = 0.005370914553590063617 + p * w;
p = 1.0052589676941592334 + p * w;
p = 3.0838856104922207635 + p * w;
} else {
w = sqrt( w ) - 5.000000;
p = -2.7109920616438573243e-11;
p = -2.5556418169965252055e-10 + p * w;
p = 1.5076572693500548083e-09 + p * w;
p = -3.7894654401267369937e-09 + p * w;
p = 7.6157012080783393804e-09 + p * w;
p = -1.4960026627149240478e-08 + p * w;
p = 2.9147953450901080826e-08 + p * w;
p = -6.7711997758452339498e-08 + p * w;
p = 2.2900482228026654717e-07 + p * w;
p = -9.9298272942317002539e-07 + p * w;
p = 4.5260625972231537039e-06 + p * w;
p = -1.9681778105531670567e-05 + p * w;
p = 7.5995277030017761139e-05 + p * w;
p = -0.00021503011930044477347 + p * w;
p = -0.00013871931833623122026 + p * w;
p = 1.0103004648645343977 + p * w;
p = 4.8499064014085844221 + p * w;
}
return p * x;
}
static double
standard_deviation( std::vector<double>::const_iterator first,
std::vector<double>::const_iterator last ) {
auto m = Catch::Benchmark::Detail::mean( first, last );
double variance =
std::accumulate( first,
last,
0.,
[m]( double a, double b ) {
double diff = b - m;
return a + diff * diff;
} ) /
( last - first );
return std::sqrt( variance );
}
} // namespace
} // namespace Detail
} // namespace Benchmark
} // namespace Catch
namespace Catch {
namespace Benchmark {
namespace Detail {
#if defined( __GNUC__ ) || defined( __clang__ )
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
#if defined( __GNUC__ ) || defined( __clang__ )
# pragma GCC diagnostic pop
#endif
double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
auto count = last - first;
double idx = (count - 1) * k / static_cast<double>(q);
int j = static_cast<int>(idx);
double g = idx - j;
std::nth_element(first, first + j, last);
auto xj = first[j];
if ( directCompare( g, 0 ) ) {
return xj;
}
auto xj1 = *std::min_element(first + (j + 1), last);
return xj + g * (xj1 - xj);
}
OutlierClassification
classify_outliers( std::vector<double>::const_iterator first,
std::vector<double>::const_iterator last ) {
std::vector<double> copy( first, last );
auto q1 = weighted_average_quantile( 1, 4, copy.begin(), copy.end() );
auto q3 = weighted_average_quantile( 3, 4, copy.begin(), copy.end() );
auto iqr = q3 - q1;
auto los = q1 - ( iqr * 3. );
auto lom = q1 - ( iqr * 1.5 );
auto him = q3 + ( iqr * 1.5 );
auto his = q3 + ( iqr * 3. );
OutlierClassification o;
for ( ; first != last; ++first ) {
const double t = *first;
if ( t < los ) {
++o.low_severe;
} else if ( t < lom ) {
++o.low_mild;
} else if ( t > his ) {
++o.high_severe;
} else if ( t > him ) {
++o.high_mild;
}
++o.samples_seen;
}
return o;
}
double mean( std::vector<double>::const_iterator first,
std::vector<double>::const_iterator last ) {
auto count = last - first;
double sum = 0.;
while (first != last) {
sum += *first;
++first;
}
return sum / static_cast<double>(count);
}
double erfc_inv(double x) {
return erf_inv(1.0 - x);
}
double normal_quantile(double p) {
static const double ROOT_TWO = std::sqrt(2.0);
double result = 0.0;
assert(p >= 0 && p <= 1);
if (p < 0 || p > 1) {
return result;
}
result = -erfc_inv(2.0 * p);
// result *= normal distribution standard deviation (1.0) * sqrt(2)
result *= /*sd * */ ROOT_TWO;
// result += normal disttribution mean (0)
return result;
}
bootstrap_analysis analyse_samples(double confidence_level,
unsigned int n_resamples,
std::vector<double>::iterator first,
std::vector<double>::iterator last) {
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
static std::random_device entropy;
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
auto mean = &Detail::mean;
auto stddev = &standard_deviation;
#if defined(CATCH_CONFIG_USE_ASYNC)
auto Estimate = [=](double(*f)(std::vector<double>::const_iterator,
std::vector<double>::const_iterator)) {
auto seed = entropy();
return std::async(std::launch::async, [=] {
std::mt19937 rng(seed);
auto resampled = resample(rng, n_resamples, first, last, f);
return bootstrap(confidence_level, first, last, resampled, f);
});
};
auto mean_future = Estimate(mean);
auto stddev_future = Estimate(stddev);
auto mean_estimate = mean_future.get();
auto stddev_estimate = stddev_future.get();
#else
auto Estimate = [=](double(*f)(std::vector<double>::const_iterator,
std::vector<double>::const_iterator)) {
auto seed = entropy();
std::mt19937 rng(seed);
auto resampled = resample(rng, n_resamples, first, last, f);
return bootstrap(confidence_level, first, last, resampled, f);
};
auto mean_estimate = Estimate(mean);
auto stddev_estimate = Estimate(stddev);
#endif // CATCH_USE_ASYNC
double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
return { mean_estimate, stddev_estimate, outlier_variance };
}
} // namespace Detail
} // namespace Benchmark
} // namespace Catch
#include <cmath>
#include <limits>
namespace {
// Performs equivalent check of std::fabs(lhs - rhs) <= margin
// But without the subtraction to allow for INFINITY in comparison
bool marginComparison(double lhs, double rhs, double margin) {
return (lhs + margin >= rhs) && (rhs + margin >= lhs);
}
}
namespace Catch {
Approx::Approx ( double value )
: m_epsilon( std::numeric_limits<float>::epsilon()*100. ),
m_margin( 0.0 ),
m_scale( 0.0 ),
m_value( value )
{}
Approx Approx::custom() {
return Approx( 0 );
}
Approx Approx::operator-() const {
auto temp(*this);
temp.m_value = -temp.m_value;
return temp;
}
std::string Approx::toString() const {
ReusableStringStream rss;
rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
return rss.str();
}
bool Approx::equalityComparisonImpl(const double other) const {
// First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
// Thanks to Richard Harris for his help refining the scaled margin value
return marginComparison(m_value, other, m_margin)
|| marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
}
void Approx::setMargin(double newMargin) {
CATCH_ENFORCE(newMargin >= 0,
"Invalid Approx::margin: " << newMargin << '.'
<< " Approx::Margin has to be non-negative.");
m_margin = newMargin;
}
void Approx::setEpsilon(double newEpsilon) {
CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
"Invalid Approx::epsilon: " << newEpsilon << '.'
<< " Approx::epsilon has to be in [0, 1]");
m_epsilon = newEpsilon;
}
namespace literals {
Approx operator "" _a(long double val) {
return Approx(val);
}
Approx operator "" _a(unsigned long long val) {
return Approx(val);
}
} // end namespace literals
std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) {
return value.toString();
}
} // end namespace Catch
namespace Catch {
AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
lazyExpression(_lazyExpression),
resultType(_resultType) {}
std::string AssertionResultData::reconstructExpression() const {
if( reconstructedExpression.empty() ) {
if( lazyExpression ) {
ReusableStringStream rss;
rss << lazyExpression;
reconstructedExpression = rss.str();
}
}
return reconstructedExpression;
}
AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData&& data )
: m_info( info ),
m_resultData( CATCH_MOVE(data) )
{}
// Result was a success
bool AssertionResult::succeeded() const {
return Catch::isOk( m_resultData.resultType );
}
// Result was a success, or failure is suppressed
bool AssertionResult::isOk() const {
return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
}
ResultWas::OfType AssertionResult::getResultType() const {
return m_resultData.resultType;
}
bool AssertionResult::hasExpression() const {
return !m_info.capturedExpression.empty();
}
bool AssertionResult::hasMessage() const {
return !m_resultData.message.empty();
}
std::string AssertionResult::getExpression() const {
// Possibly overallocating by 3 characters should be basically free
std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
if (isFalseTest(m_info.resultDisposition)) {
expr += "!(";
}
expr += m_info.capturedExpression;
if (isFalseTest(m_info.resultDisposition)) {
expr += ')';
}
return expr;
}
std::string AssertionResult::getExpressionInMacro() const {
if ( m_info.macroName.empty() ) {
return static_cast<std::string>( m_info.capturedExpression );
}
std::string expr;
expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
expr += m_info.macroName;
expr += "( ";
expr += m_info.capturedExpression;
expr += " )";
return expr;
}
bool AssertionResult::hasExpandedExpression() const {
return hasExpression() && getExpandedExpression() != getExpression();
}
std::string AssertionResult::getExpandedExpression() const {
std::string expr = m_resultData.reconstructExpression();
return expr.empty()
? getExpression()
: expr;
}
StringRef AssertionResult::getMessage() const {
return m_resultData.message;
}
SourceLineInfo AssertionResult::getSourceInfo() const {
return m_info.lineInfo;
}
StringRef AssertionResult::getTestMacroName() const {
return m_info.macroName;
}
} // end namespace Catch
#include <fstream>
namespace Catch {
namespace {
static bool enableBazelEnvSupport() {
#if defined( CATCH_CONFIG_BAZEL_SUPPORT )
return true;
#else
return Detail::getEnv( "BAZEL_TEST" ) != nullptr;
#endif
}
struct bazelShardingOptions {
unsigned int shardIndex, shardCount;
std::string shardFilePath;
};
static Optional<bazelShardingOptions> readBazelShardingOptions() {
const auto bazelShardIndex = Detail::getEnv( "TEST_SHARD_INDEX" );
const auto bazelShardTotal = Detail::getEnv( "TEST_TOTAL_SHARDS" );
const auto bazelShardInfoFile = Detail::getEnv( "TEST_SHARD_STATUS_FILE" );
const bool has_all =
bazelShardIndex && bazelShardTotal && bazelShardInfoFile;
if ( !has_all ) {
// We provide nice warning message if the input is
// misconfigured.
auto warn = []( const char* env_var ) {
Catch::cerr()
<< "Warning: Bazel shard configuration is missing '"
<< env_var << "'. Shard configuration is skipped.\n";
};
if ( !bazelShardIndex ) {
warn( "TEST_SHARD_INDEX" );
}
if ( !bazelShardTotal ) {
warn( "TEST_TOTAL_SHARDS" );
}
if ( !bazelShardInfoFile ) {
warn( "TEST_SHARD_STATUS_FILE" );
}
return {};
}
auto shardIndex = parseUInt( bazelShardIndex );
if ( !shardIndex ) {
Catch::cerr()
<< "Warning: could not parse 'TEST_SHARD_INDEX' ('" << bazelShardIndex
<< "') as unsigned int.\n";
return {};
}
auto shardTotal = parseUInt( bazelShardTotal );
if ( !shardTotal ) {
Catch::cerr()
<< "Warning: could not parse 'TEST_TOTAL_SHARD' ('"
<< bazelShardTotal << "') as unsigned int.\n";
return {};
}
return bazelShardingOptions{
*shardIndex, *shardTotal, bazelShardInfoFile };
}
} // end namespace
bool operator==( ProcessedReporterSpec const& lhs,
ProcessedReporterSpec const& rhs ) {
return lhs.name == rhs.name &&
lhs.outputFilename == rhs.outputFilename &&
lhs.colourMode == rhs.colourMode &&
lhs.customOptions == rhs.customOptions;
}
Config::Config( ConfigData const& data ):
m_data( data ) {
// We need to trim filter specs to avoid trouble with superfluous
// whitespace (esp. important for bdd macros, as those are manually
// aligned with whitespace).
for (auto& elem : m_data.testsOrTags) {
elem = trim(elem);
}
for (auto& elem : m_data.sectionsToRun) {
elem = trim(elem);
}
// Insert the default reporter if user hasn't asked for a specific one
if ( m_data.reporterSpecifications.empty() ) {
m_data.reporterSpecifications.push_back( {
#if defined( CATCH_CONFIG_DEFAULT_REPORTER )
CATCH_CONFIG_DEFAULT_REPORTER,
#else
"console",
#endif
{}, {}, {}
} );
}
if ( enableBazelEnvSupport() ) {
readBazelEnvVars();
}
// Bazel support can modify the test specs, so parsing has to happen
// after reading Bazel env vars.
TestSpecParser parser( ITagAliasRegistry::get() );
if ( !m_data.testsOrTags.empty() ) {
m_hasTestFilters = true;
for ( auto const& testOrTags : m_data.testsOrTags ) {
parser.parse( testOrTags );
}
}
m_testSpec = parser.testSpec();
// We now fixup the reporter specs to handle default output spec,
// default colour spec, etc
bool defaultOutputUsed = false;
for ( auto const& reporterSpec : m_data.reporterSpecifications ) {
// We do the default-output check separately, while always
// using the default output below to make the code simpler
// and avoid superfluous copies.
if ( reporterSpec.outputFile().none() ) {
CATCH_ENFORCE( !defaultOutputUsed,
"Internal error: cannot use default output for "
"multiple reporters" );
defaultOutputUsed = true;
}
m_processedReporterSpecs.push_back( ProcessedReporterSpec{
reporterSpec.name(),
reporterSpec.outputFile() ? *reporterSpec.outputFile()
: data.defaultOutputFilename,
reporterSpec.colourMode().valueOr( data.defaultColourMode ),
reporterSpec.customOptions() } );
}
}
Config::~Config() = default;
bool Config::listTests() const { return m_data.listTests; }
bool Config::listTags() const { return m_data.listTags; }
bool Config::listReporters() const { return m_data.listReporters; }
bool Config::listListeners() const { return m_data.listListeners; }
std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
std::vector<ReporterSpec> const& Config::getReporterSpecs() const {
return m_data.reporterSpecifications;
}
std::vector<ProcessedReporterSpec> const&
Config::getProcessedReporterSpecs() const {
return m_processedReporterSpecs;
}
TestSpec const& Config::testSpec() const { return m_testSpec; }
bool Config::hasTestFilters() const { return m_hasTestFilters; }
bool Config::showHelp() const { return m_data.showHelp; }
// IConfig interface
bool Config::allowThrows() const { return !m_data.noThrow; }
StringRef Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; }
bool Config::includeSuccessfulResults() const { return m_data.showSuccessfulTests; }
bool Config::warnAboutMissingAssertions() const {
return !!( m_data.warnings & WarnAbout::NoAssertions );
}
bool Config::warnAboutUnmatchedTestSpecs() const {
return !!( m_data.warnings & WarnAbout::UnmatchedTestSpec );
}
bool Config::zeroTestsCountAsSuccess() const { return m_data.allowZeroTests; }
ShowDurations Config::showDurations() const { return m_data.showDurations; }
double Config::minDuration() const { return m_data.minDuration; }
TestRunOrder Config::runOrder() const { return m_data.runOrder; }
uint32_t Config::rngSeed() const { return m_data.rngSeed; }
unsigned int Config::shardCount() const { return m_data.shardCount; }
unsigned int Config::shardIndex() const { return m_data.shardIndex; }
ColourMode Config::defaultColourMode() const { return m_data.defaultColourMode; }
bool Config::shouldDebugBreak() const { return m_data.shouldDebugBreak; }
int Config::abortAfter() const { return m_data.abortAfter; }
bool Config::showInvisibles() const { return m_data.showInvisibles; }
Verbosity Config::verbosity() const { return m_data.verbosity; }
bool Config::skipBenchmarks() const { return m_data.skipBenchmarks; }
bool Config::benchmarkNoAnalysis() const { return m_data.benchmarkNoAnalysis; }
unsigned int Config::benchmarkSamples() const { return m_data.benchmarkSamples; }
double Config::benchmarkConfidenceInterval() const { return m_data.benchmarkConfidenceInterval; }
unsigned int Config::benchmarkResamples() const { return m_data.benchmarkResamples; }
std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
void Config::readBazelEnvVars() {
// Register a JUnit reporter for Bazel. Bazel sets an environment
// variable with the path to XML output. If this file is written to
// during test, Bazel will not generate a default XML output.
// This allows the XML output file to contain higher level of detail
// than what is possible otherwise.
const auto bazelOutputFile = Detail::getEnv( "XML_OUTPUT_FILE" );
if ( bazelOutputFile ) {
m_data.reporterSpecifications.push_back(
{ "junit", std::string( bazelOutputFile ), {}, {} } );
}
const auto bazelTestSpec = Detail::getEnv( "TESTBRIDGE_TEST_ONLY" );
if ( bazelTestSpec ) {
// Presumably the test spec from environment should overwrite
// the one we got from CLI (if we got any)
m_data.testsOrTags.clear();
m_data.testsOrTags.push_back( bazelTestSpec );
}
const auto bazelShardOptions = readBazelShardingOptions();
if ( bazelShardOptions ) {
std::ofstream f( bazelShardOptions->shardFilePath,
std::ios_base::out | std::ios_base::trunc );
if ( f.is_open() ) {
f << "";
m_data.shardIndex = bazelShardOptions->shardIndex;
m_data.shardCount = bazelShardOptions->shardCount;
}
}
}
} // end namespace Catch
namespace Catch {
std::uint32_t getSeed() {
return getCurrentContext().getConfig()->rngSeed();
}
}
#include <cassert>
#include <stack>
namespace Catch {
////////////////////////////////////////////////////////////////////////////
ScopedMessage::ScopedMessage( MessageBuilder&& builder ):
m_info( CATCH_MOVE(builder.m_info) ) {
m_info.message = builder.m_stream.str();
getResultCapture().pushScopedMessage( m_info );
}
ScopedMessage::ScopedMessage( ScopedMessage&& old ) noexcept:
m_info( CATCH_MOVE( old.m_info ) ) {
old.m_moved = true;
}
ScopedMessage::~ScopedMessage() {
if ( !uncaught_exceptions() && !m_moved ){
getResultCapture().popScopedMessage(m_info);
}
}
Capturer::Capturer( StringRef macroName,
SourceLineInfo const& lineInfo,
ResultWas::OfType resultType,
StringRef names ):
m_resultCapture( getResultCapture() ) {
auto trimmed = [&] (size_t start, size_t end) {
while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
++start;
}
while (names[end] == ',' || isspace(static_cast<unsigned char>(names[end]))) {
--end;
}
return names.substr(start, end - start + 1);
};
auto skipq = [&] (size_t start, char quote) {
for (auto i = start + 1; i < names.size() ; ++i) {
if (names[i] == quote)
return i;
if (names[i] == '\\')
++i;
}
CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
};
size_t start = 0;
std::stack<char> openings;
for (size_t pos = 0; pos < names.size(); ++pos) {
char c = names[pos];
switch (c) {
case '[':
case '{':
case '(':
// It is basically impossible to disambiguate between
// comparison and start of template args in this context
// case '<':
openings.push(c);
break;
case ']':
case '}':
case ')':
// case '>':
openings.pop();
break;
case '"':
case '\'':
pos = skipq(pos, c);
break;
case ',':
if (start != pos && openings.empty()) {
m_messages.emplace_back(macroName, lineInfo, resultType);
m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
m_messages.back().message += " := ";
start = pos;
}
}
}
assert(openings.empty() && "Mismatched openings");
m_messages.emplace_back(macroName, lineInfo, resultType);
m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
m_messages.back().message += " := ";
}
Capturer::~Capturer() {
if ( !uncaught_exceptions() ){
assert( m_captured == m_messages.size() );
for( size_t i = 0; i < m_captured; ++i )
m_resultCapture.popScopedMessage( m_messages[i] );
}
}
void Capturer::captureValue( size_t index, std::string const& value ) {
assert( index < m_messages.size() );
m_messages[index].message += value;
m_resultCapture.pushScopedMessage( m_messages[index] );
m_captured++;
}
} // end namespace Catch
#include <exception>
namespace Catch {
namespace {
class RegistryHub : public IRegistryHub,
public IMutableRegistryHub,
private Detail::NonCopyable {
public: // IRegistryHub
RegistryHub() = default;
ReporterRegistry const& getReporterRegistry() const override {
return m_reporterRegistry;
}
ITestCaseRegistry const& getTestCaseRegistry() const override {
return m_testCaseRegistry;
}
IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
return m_exceptionTranslatorRegistry;
}
ITagAliasRegistry const& getTagAliasRegistry() const override {
return m_tagAliasRegistry;
}
StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
return m_exceptionRegistry;
}
public: // IMutableRegistryHub
void registerReporter( std::string const& name, IReporterFactoryPtr factory ) override {
m_reporterRegistry.registerReporter( name, CATCH_MOVE(factory) );
}
void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) override {
m_reporterRegistry.registerListener( CATCH_MOVE(factory) );
}
void registerTest( Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker ) override {
m_testCaseRegistry.registerTest( CATCH_MOVE(testInfo), CATCH_MOVE(invoker) );
}
void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) override {
m_exceptionTranslatorRegistry.registerTranslator( CATCH_MOVE(translator) );
}
void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
m_tagAliasRegistry.add( alias, tag, lineInfo );
}
void registerStartupException() noexcept override {
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
m_exceptionRegistry.add(std::current_exception());
#else
CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
#endif
}
IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
return m_enumValuesRegistry;
}
private:
TestRegistry m_testCaseRegistry;
ReporterRegistry m_reporterRegistry;
ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
TagAliasRegistry m_tagAliasRegistry;
StartupExceptionRegistry m_exceptionRegistry;
Detail::EnumValuesRegistry m_enumValuesRegistry;
};
}
using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
IRegistryHub const& getRegistryHub() {
return RegistryHubSingleton::get();
}
IMutableRegistryHub& getMutableRegistryHub() {
return RegistryHubSingleton::getMutable();
}
void cleanUp() {
cleanupSingletons();
cleanUpContext();
}
std::string translateActiveException() {
return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
}
} // end namespace Catch
#include <algorithm>
#include <cassert>
#include <exception>
#include <iomanip>
#include <set>
namespace Catch {
namespace {
const int MaxExitCode = 255;
IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {
auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config));
CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << '\'');
return reporter;
}
IEventListenerPtr prepareReporters(Config const* config) {
if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()
&& config->getProcessedReporterSpecs().size() == 1) {
auto const& spec = config->getProcessedReporterSpecs()[0];
return createReporter(
spec.name,
ReporterConfig( config,
makeStream( spec.outputFilename ),
spec.colourMode,
spec.customOptions ) );
}
auto multi = Detail::make_unique<MultiReporter>(config);
auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
for (auto const& listener : listeners) {
multi->addListener(listener->create(config));
}
for ( auto const& reporterSpec : config->getProcessedReporterSpecs() ) {
multi->addReporter( createReporter(
reporterSpec.name,
ReporterConfig( config,
makeStream( reporterSpec.outputFilename ),
reporterSpec.colourMode,
reporterSpec.customOptions ) ) );
}
return multi;
}
class TestGroup {
public:
explicit TestGroup(IEventListenerPtr&& reporter, Config const* config):
m_reporter(reporter.get()),
m_config{config},
m_context{config, CATCH_MOVE(reporter)} {
assert( m_config->testSpec().getInvalidSpecs().empty() &&
"Invalid test specs should be handled before running tests" );
auto const& allTestCases = getAllTestCasesSorted(*m_config);
auto const& testSpec = m_config->testSpec();
if ( !testSpec.hasFilters() ) {
for ( auto const& test : allTestCases ) {
if ( !test.getTestCaseInfo().isHidden() ) {
m_tests.emplace( &test );
}
}
} else {
m_matches =
testSpec.matchesByFilter( allTestCases, *m_config );
for ( auto const& match : m_matches ) {
m_tests.insert( match.tests.begin(),
match.tests.end() );
}
}
m_tests = createShard(m_tests, m_config->shardCount(), m_config->shardIndex());
}
Totals execute() {
Totals totals;
for (auto const& testCase : m_tests) {
if (!m_context.aborting())
totals += m_context.runTest(*testCase);
else
m_reporter->skipTest(testCase->getTestCaseInfo());
}
for (auto const& match : m_matches) {
if (match.tests.empty()) {
m_unmatchedTestSpecs = true;
m_reporter->noMatchingTestCases( match.name );
}
}
return totals;
}
bool hadUnmatchedTestSpecs() const {
return m_unmatchedTestSpecs;
}
private:
IEventListener* m_reporter;
Config const* m_config;
RunContext m_context;
std::set<TestCaseHandle const*> m_tests;
TestSpec::Matches m_matches;
bool m_unmatchedTestSpecs = false;
};
void applyFilenamesAsTags() {
for (auto const& testInfo : getRegistryHub().getTestCaseRegistry().getAllInfos()) {
testInfo->addFilenameTag();
}
}
} // anon namespace
Session::Session() {
static bool alreadyInstantiated = false;
if( alreadyInstantiated ) {
CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
}
// There cannot be exceptions at startup in no-exception mode.
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
if ( !exceptions.empty() ) {
config();
getCurrentMutableContext().setConfig(m_config.get());
m_startupExceptions = true;
auto errStream = makeStream( "%stderr" );
auto colourImpl = makeColourImpl(
ColourMode::PlatformDefault, errStream.get() );
auto guard = colourImpl->guardColour( Colour::Red );
errStream->stream() << "Errors occurred during startup!" << '\n';
// iterate over all exceptions and notify user
for ( const auto& ex_ptr : exceptions ) {
try {
std::rethrow_exception(ex_ptr);
} catch ( std::exception const& ex ) {
errStream->stream() << TextFlow::Column( ex.what() ).indent(2) << '\n';
}
}
}
#endif
alreadyInstantiated = true;
m_cli = makeCommandLineParser( m_configData );
}
Session::~Session() {
Catch::cleanUp();
}
void Session::showHelp() const {
Catch::cout()
<< "\nCatch2 v" << libraryVersion() << '\n'
<< m_cli << '\n'
<< "For more detailed usage please see the project docs\n\n" << std::flush;
}
void Session::libIdentify() {
Catch::cout()
<< std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
<< std::left << std::setw(16) << "category: " << "testframework\n"
<< std::left << std::setw(16) << "framework: " << "Catch2\n"
<< std::left << std::setw(16) << "version: " << libraryVersion() << '\n' << std::flush;
}
int Session::applyCommandLine( int argc, char const * const * argv ) {
if( m_startupExceptions )
return 1;
auto result = m_cli.parse( Clara::Args( argc, argv ) );
if( !result ) {
config();
getCurrentMutableContext().setConfig(m_config.get());
auto errStream = makeStream( "%stderr" );
auto colour = makeColourImpl( ColourMode::PlatformDefault, errStream.get() );
errStream->stream()
<< colour->guardColour( Colour::Red )
<< "\nError(s) in input:\n"
<< TextFlow::Column( result.errorMessage() ).indent( 2 )
<< "\n\n";
errStream->stream() << "Run with -? for usage\n\n" << std::flush;
return MaxExitCode;
}
if( m_configData.showHelp )
showHelp();
if( m_configData.libIdentify )
libIdentify();
m_config.reset();
return 0;
}
#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
char **utf8Argv = new char *[ argc ];
for ( int i = 0; i < argc; ++i ) {
int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
utf8Argv[ i ] = new char[ bufSize ];
WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
}
int returnCode = applyCommandLine( argc, utf8Argv );
for ( int i = 0; i < argc; ++i )
delete [] utf8Argv[ i ];
delete [] utf8Argv;
return returnCode;
}
#endif
void Session::useConfigData( ConfigData const& configData ) {
m_configData = configData;
m_config.reset();
}
int Session::run() {
if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
Catch::cout() << "...waiting for enter/ return before starting\n" << std::flush;
static_cast<void>(std::getchar());
}
int exitCode = runInternal();
if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << '\n' << std::flush;
static_cast<void>(std::getchar());
}
return exitCode;
}
Clara::Parser const& Session::cli() const {
return m_cli;
}
void Session::cli( Clara::Parser const& newParser ) {
m_cli = newParser;
}
ConfigData& Session::configData() {
return m_configData;
}
Config& Session::config() {
if( !m_config )
m_config = Detail::make_unique<Config>( m_configData );
return *m_config;
}
int Session::runInternal() {
if( m_startupExceptions )
return 1;
if (m_configData.showHelp || m_configData.libIdentify) {
return 0;
}
if ( m_configData.shardIndex >= m_configData.shardCount ) {
Catch::cerr() << "The shard count (" << m_configData.shardCount
<< ") must be greater than the shard index ("
<< m_configData.shardIndex << ")\n"
<< std::flush;
return 1;
}
CATCH_TRY {
config(); // Force config to be constructed
seedRng( *m_config );
if (m_configData.filenamesAsTags) {
applyFilenamesAsTags();
}
// Set up global config instance before we start calling into other functions
getCurrentMutableContext().setConfig(m_config.get());
// Create reporter(s) so we can route listings through them
auto reporter = prepareReporters(m_config.get());
auto const& invalidSpecs = m_config->testSpec().getInvalidSpecs();
if ( !invalidSpecs.empty() ) {
for ( auto const& spec : invalidSpecs ) {
reporter->reportInvalidTestSpec( spec );
}
return 1;
}
// Handle list request
if (list(*reporter, *m_config)) {
return 0;
}
TestGroup tests { CATCH_MOVE(reporter), m_config.get() };
auto const totals = tests.execute();
if ( tests.hadUnmatchedTestSpecs()
&& m_config->warnAboutUnmatchedTestSpecs() ) {
return 3;
}
if ( totals.testCases.total() == 0
&& !m_config->zeroTestsCountAsSuccess() ) {
return 2;
}
if ( totals.testCases.total() > 0 &&
totals.testCases.total() == totals.testCases.skipped
&& !m_config->zeroTestsCountAsSuccess() ) {
return 4;
}
// Note that on unices only the lower 8 bits are usually used, clamping
// the return value to 255 prevents false negative when some multiple
// of 256 tests has failed
return (std::min) (MaxExitCode, static_cast<int>(totals.assertions.failed));
}
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
catch( std::exception& ex ) {
Catch::cerr() << ex.what() << '\n' << std::flush;
return MaxExitCode;
}
#endif
}
} // end namespace Catch
namespace Catch {
RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
CATCH_TRY {
getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
} CATCH_CATCH_ALL {
// Do not throw when constructing global objects, instead register the exception to be processed later
getMutableRegistryHub().registerStartupException();
}
}
}
#include <cassert>
#include <cctype>
#include <algorithm>
namespace Catch {
namespace {
using TCP_underlying_type = uint8_t;
static_assert(sizeof(TestCaseProperties) == sizeof(TCP_underlying_type),
"The size of the TestCaseProperties is different from the assumed size");
TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) {
return static_cast<TestCaseProperties>(
static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
);
}
TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) {
lhs = static_cast<TestCaseProperties>(
static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
);
return lhs;
}
TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) {
return static_cast<TestCaseProperties>(
static_cast<TCP_underlying_type>(lhs) & static_cast<TCP_underlying_type>(rhs)
);
}
bool applies(TestCaseProperties tcp) {
static_assert(static_cast<TCP_underlying_type>(TestCaseProperties::None) == 0,
"TestCaseProperties::None must be equal to 0");
return tcp != TestCaseProperties::None;
}
TestCaseProperties parseSpecialTag( StringRef tag ) {
if( !tag.empty() && tag[0] == '.' )
return TestCaseProperties::IsHidden;
else if( tag == "!throws"_sr )
return TestCaseProperties::Throws;
else if( tag == "!shouldfail"_sr )
return TestCaseProperties::ShouldFail;
else if( tag == "!mayfail"_sr )
return TestCaseProperties::MayFail;
else if( tag == "!nonportable"_sr )
return TestCaseProperties::NonPortable;
else if( tag == "!benchmark"_sr )
return TestCaseProperties::Benchmark | TestCaseProperties::IsHidden;
else
return TestCaseProperties::None;
}
bool isReservedTag( StringRef tag ) {
return parseSpecialTag( tag ) == TestCaseProperties::None
&& tag.size() > 0
&& !std::isalnum( static_cast<unsigned char>(tag[0]) );
}
void enforceNotReservedTag( StringRef tag, SourceLineInfo const& _lineInfo ) {
CATCH_ENFORCE( !isReservedTag(tag),
"Tag name: [" << tag << "] is not allowed.\n"
<< "Tag names starting with non alphanumeric characters are reserved\n"
<< _lineInfo );
}
std::string makeDefaultName() {
static size_t counter = 0;
return "Anonymous test case " + std::to_string(++counter);
}
StringRef extractFilenamePart(StringRef filename) {
size_t lastDot = filename.size();
while (lastDot > 0 && filename[lastDot - 1] != '.') {
--lastDot;
}
--lastDot;
size_t nameStart = lastDot;
while (nameStart > 0 && filename[nameStart - 1] != '/' && filename[nameStart - 1] != '\\') {
--nameStart;
}
return filename.substr(nameStart, lastDot - nameStart);
}
// Returns the upper bound on size of extra tags ([#file]+[.])
size_t sizeOfExtraTags(StringRef filepath) {
// [.] is 3, [#] is another 3
const size_t extras = 3 + 3;
return extractFilenamePart(filepath).size() + extras;
}
} // end unnamed namespace
bool operator<( Tag const& lhs, Tag const& rhs ) {
Detail::CaseInsensitiveLess cmp;
return cmp( lhs.original, rhs.original );
}
bool operator==( Tag const& lhs, Tag const& rhs ) {
Detail::CaseInsensitiveEqualTo cmp;
return cmp( lhs.original, rhs.original );
}
Detail::unique_ptr<TestCaseInfo>
makeTestCaseInfo(StringRef _className,
NameAndTags const& nameAndTags,
SourceLineInfo const& _lineInfo ) {
return Detail::make_unique<TestCaseInfo>(_className, nameAndTags, _lineInfo);
}
TestCaseInfo::TestCaseInfo(StringRef _className,
NameAndTags const& _nameAndTags,
SourceLineInfo const& _lineInfo):
name( _nameAndTags.name.empty() ? makeDefaultName() : _nameAndTags.name ),
className( _className ),
lineInfo( _lineInfo )
{
StringRef originalTags = _nameAndTags.tags;
// We need to reserve enough space to store all of the tags
// (including optional hidden tag and filename tag)
auto requiredSize = originalTags.size() + sizeOfExtraTags(_lineInfo.file);
backingTags.reserve(requiredSize);
// We cannot copy the tags directly, as we need to normalize
// some tags, so that [.foo] is copied as [.][foo].
size_t tagStart = 0;
size_t tagEnd = 0;
bool inTag = false;
for (size_t idx = 0; idx < originalTags.size(); ++idx) {
auto c = originalTags[idx];
if (c == '[') {
CATCH_ENFORCE(
!inTag,
"Found '[' inside a tag while registering test case '"
<< _nameAndTags.name << "' at " << _lineInfo );
inTag = true;
tagStart = idx;
}
if (c == ']') {
CATCH_ENFORCE(
inTag,
"Found unmatched ']' while registering test case '"
<< _nameAndTags.name << "' at " << _lineInfo );
inTag = false;
tagEnd = idx;
assert(tagStart < tagEnd);
// We need to check the tag for special meanings, copy
// it over to backing storage and actually reference the
// backing storage in the saved tags
StringRef tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1);
CATCH_ENFORCE( !tagStr.empty(),
"Found an empty tag while registering test case '"
<< _nameAndTags.name << "' at "
<< _lineInfo );
enforceNotReservedTag(tagStr, lineInfo);
properties |= parseSpecialTag(tagStr);
// When copying a tag to the backing storage, we need to
// check if it is a merged hide tag, such as [.foo], and
// if it is, we need to handle it as if it was [foo].
if (tagStr.size() > 1 && tagStr[0] == '.') {
tagStr = tagStr.substr(1, tagStr.size() - 1);
}
// We skip over dealing with the [.] tag, as we will add
// it later unconditionally and then sort and unique all
// the tags.
internalAppendTag(tagStr);
}
}
CATCH_ENFORCE( !inTag,
"Found an unclosed tag while registering test case '"
<< _nameAndTags.name << "' at " << _lineInfo );
// Add [.] if relevant
if (isHidden()) {
internalAppendTag("."_sr);
}
// Sort and prepare tags
std::sort(begin(tags), end(tags));
tags.erase(std::unique(begin(tags), end(tags)),
end(tags));
}
bool TestCaseInfo::isHidden() const {
return applies( properties & TestCaseProperties::IsHidden );
}
bool TestCaseInfo::throws() const {
return applies( properties & TestCaseProperties::Throws );
}
bool TestCaseInfo::okToFail() const {
return applies( properties & (TestCaseProperties::ShouldFail | TestCaseProperties::MayFail ) );
}
bool TestCaseInfo::expectedToFail() const {
return applies( properties & (TestCaseProperties::ShouldFail) );
}
void TestCaseInfo::addFilenameTag() {
std::string combined("#");
combined += extractFilenamePart(lineInfo.file);
internalAppendTag(combined);
}
std::string TestCaseInfo::tagsAsString() const {
std::string ret;
// '[' and ']' per tag
std::size_t full_size = 2 * tags.size();
for (const auto& tag : tags) {
full_size += tag.original.size();
}
ret.reserve(full_size);
for (const auto& tag : tags) {
ret.push_back('[');
ret += tag.original;
ret.push_back(']');
}
return ret;
}
void TestCaseInfo::internalAppendTag(StringRef tagStr) {
backingTags += '[';
const auto backingStart = backingTags.size();
backingTags += tagStr;
const auto backingEnd = backingTags.size();
backingTags += ']';
tags.emplace_back(StringRef(backingTags.c_str() + backingStart, backingEnd - backingStart));
}
bool operator<( TestCaseInfo const& lhs, TestCaseInfo const& rhs ) {
// We want to avoid redoing the string comparisons multiple times,
// so we store the result of a three-way comparison before using
// it in the actual comparison logic.
const auto cmpName = lhs.name.compare( rhs.name );
if ( cmpName != 0 ) {
return cmpName < 0;
}
const auto cmpClassName = lhs.className.compare( rhs.className );
if ( cmpClassName != 0 ) {
return cmpClassName < 0;
}
return lhs.tags < rhs.tags;
}
TestCaseInfo const& TestCaseHandle::getTestCaseInfo() const {
return *m_info;
}
} // end namespace Catch
#include <algorithm>
#include <string>
#include <vector>
#include <ostream>
namespace Catch {
TestSpec::Pattern::Pattern( std::string const& name )
: m_name( name )
{}
TestSpec::Pattern::~Pattern() = default;
std::string const& TestSpec::Pattern::name() const {
return m_name;
}
TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
: Pattern( filterString )
, m_wildcardPattern( toLower( name ), CaseSensitive::No )
{}
bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
return m_wildcardPattern.matches( testCase.name );
}
void TestSpec::NamePattern::serializeTo( std::ostream& out ) const {
out << '"' << name() << '"';
}
TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
: Pattern( filterString )
, m_tag( tag )
{}
bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
return std::find( begin( testCase.tags ),
end( testCase.tags ),
Tag( m_tag ) ) != end( testCase.tags );
}
void TestSpec::TagPattern::serializeTo( std::ostream& out ) const {
out << name();
}
bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
bool should_use = !testCase.isHidden();
for (auto const& pattern : m_required) {
should_use = true;
if (!pattern->matches(testCase)) {
return false;
}
}
for (auto const& pattern : m_forbidden) {
if (pattern->matches(testCase)) {
return false;
}
}
return should_use;
}
void TestSpec::Filter::serializeTo( std::ostream& out ) const {
bool first = true;
for ( auto const& pattern : m_required ) {
if ( !first ) {
out << ' ';
}
out << *pattern;
first = false;
}
for ( auto const& pattern : m_forbidden ) {
if ( !first ) {
out << ' ';
}
out << *pattern;
first = false;
}
}
std::string TestSpec::extractFilterName( Filter const& filter ) {
Catch::ReusableStringStream sstr;
sstr << filter;
return sstr.str();
}
bool TestSpec::hasFilters() const {
return !m_filters.empty();
}
bool TestSpec::matches( TestCaseInfo const& testCase ) const {
return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
}
TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const {
Matches matches;
matches.reserve( m_filters.size() );
for ( auto const& filter : m_filters ) {
std::vector<TestCaseHandle const*> currentMatches;
for ( auto const& test : testCases )
if ( isThrowSafe( test, config ) &&
filter.matches( test.getTestCaseInfo() ) )
currentMatches.emplace_back( &test );
matches.push_back(
FilterMatch{ extractFilterName( filter ), currentMatches } );
}
return matches;
}
const TestSpec::vectorStrings& TestSpec::getInvalidSpecs() const {
return m_invalidSpecs;
}
void TestSpec::serializeTo( std::ostream& out ) const {
bool first = true;
for ( auto const& filter : m_filters ) {
if ( !first ) {
out << ',';
}
out << filter;
first = false;
}
}
}
#include <chrono>
namespace Catch {
namespace {
static auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
}
} // end unnamed namespace
void Timer::start() {
m_nanoseconds = getCurrentNanosecondsSinceEpoch();
}
auto Timer::getElapsedNanoseconds() const -> uint64_t {
return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
}
auto Timer::getElapsedMicroseconds() const -> uint64_t {
return getElapsedNanoseconds()/1000;
}
auto Timer::getElapsedMilliseconds() const -> unsigned int {
return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
}
auto Timer::getElapsedSeconds() const -> double {
return getElapsedMicroseconds()/1000000.0;
}
} // namespace Catch
#include <cmath>
#include <iomanip>
namespace Catch {
namespace Detail {
namespace {
const int hexThreshold = 255;
struct Endianness {
enum Arch { Big, Little };
static Arch which() {
int one = 1;
// If the lowest byte we read is non-zero, we can assume
// that little endian format is used.
auto value = *reinterpret_cast<char*>(&one);
return value ? Little : Big;
}
};
template<typename T>
std::string fpToString(T value, int precision) {
if (Catch::isnan(value)) {
return "nan";
}
ReusableStringStream rss;
rss << std::setprecision(precision)
<< std::fixed
<< value;
std::string d = rss.str();
std::size_t i = d.find_last_not_of('0');
if (i != std::string::npos && i != d.size() - 1) {
if (d[i] == '.')
i++;
d = d.substr(0, i + 1);
}
return d;
}
} // end unnamed namespace
std::string convertIntoString(StringRef string, bool escape_invisibles) {
std::string ret;
// This is enough for the "don't escape invisibles" case, and a good
// lower bound on the "escape invisibles" case.
ret.reserve(string.size() + 2);
if (!escape_invisibles) {
ret += '"';
ret += string;
ret += '"';
return ret;
}
ret += '"';
for (char c : string) {
switch (c) {
case '\r':
ret.append("\\r");
break;
case '\n':
ret.append("\\n");
break;
case '\t':
ret.append("\\t");
break;
case '\f':
ret.append("\\f");
break;
default:
ret.push_back(c);
break;
}
}
ret += '"';
return ret;
}
std::string convertIntoString(StringRef string) {
return convertIntoString(string, getCurrentContext().getConfig()->showInvisibles());
}
std::string rawMemoryToString( const void *object, std::size_t size ) {
// Reverse order for little endian architectures
int i = 0, end = static_cast<int>( size ), inc = 1;
if( Endianness::which() == Endianness::Little ) {
i = end-1;
end = inc = -1;
}
unsigned char const *bytes = static_cast<unsigned char const *>(object);
ReusableStringStream rss;
rss << "0x" << std::setfill('0') << std::hex;
for( ; i != end; i += inc )
rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
return rss.str();
}
} // end Detail namespace
//// ======================================================= ////
//
// Out-of-line defs for full specialization of StringMaker
//
//// ======================================================= ////
std::string StringMaker<std::string>::convert(const std::string& str) {
return Detail::convertIntoString( str );
}
#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
std::string StringMaker<std::string_view>::convert(std::string_view str) {
return Detail::convertIntoString( StringRef( str.data(), str.size() ) );
}
#endif
std::string StringMaker<char const*>::convert(char const* str) {
if (str) {
return Detail::convertIntoString( str );
} else {
return{ "{null string}" };
}
}
std::string StringMaker<char*>::convert(char* str) {
if (str) {
return Detail::convertIntoString( str );
} else {
return{ "{null string}" };
}
}
#ifdef CATCH_CONFIG_WCHAR
std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
std::string s;
s.reserve(wstr.size());
for (auto c : wstr) {
s += (c <= 0xff) ? static_cast<char>(c) : '?';
}
return ::Catch::Detail::stringify(s);
}
# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
return StringMaker<std::wstring>::convert(std::wstring(str));
}
# endif
std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
if (str) {
return ::Catch::Detail::stringify(std::wstring{ str });
} else {
return{ "{null string}" };
}
}
std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
if (str) {
return ::Catch::Detail::stringify(std::wstring{ str });
} else {
return{ "{null string}" };
}
}
#endif
#if defined(CATCH_CONFIG_CPP17_BYTE)
#include <cstddef>
std::string StringMaker<std::byte>::convert(std::byte value) {
return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
}
#endif // defined(CATCH_CONFIG_CPP17_BYTE)
std::string StringMaker<int>::convert(int value) {
return ::Catch::Detail::stringify(static_cast<long long>(value));
}
std::string StringMaker<long>::convert(long value) {
return ::Catch::Detail::stringify(static_cast<long long>(value));
}
std::string StringMaker<long long>::convert(long long value) {
ReusableStringStream rss;
rss << value;
if (value > Detail::hexThreshold) {
rss << " (0x" << std::hex << value << ')';
}
return rss.str();
}
std::string StringMaker<unsigned int>::convert(unsigned int value) {
return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
}
std::string StringMaker<unsigned long>::convert(unsigned long value) {
return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
}
std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
ReusableStringStream rss;
rss << value;
if (value > Detail::hexThreshold) {
rss << " (0x" << std::hex << value << ')';
}
return rss.str();
}
std::string StringMaker<signed char>::convert(signed char value) {
if (value == '\r') {
return "'\\r'";
} else if (value == '\f') {
return "'\\f'";
} else if (value == '\n') {
return "'\\n'";
} else if (value == '\t') {
return "'\\t'";
} else if ('\0' <= value && value < ' ') {
return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
} else {
char chstr[] = "' '";
chstr[1] = value;
return chstr;
}
}
std::string StringMaker<char>::convert(char c) {
return ::Catch::Detail::stringify(static_cast<signed char>(c));
}
std::string StringMaker<unsigned char>::convert(unsigned char c) {
return ::Catch::Detail::stringify(static_cast<char>(c));
}
int StringMaker<float>::precision = 5;
std::string StringMaker<float>::convert(float value) {
return Detail::fpToString(value, precision) + 'f';
}
int StringMaker<double>::precision = 10;
std::string StringMaker<double>::convert(double value) {
return Detail::fpToString(value, precision);
}
} // end namespace Catch
namespace Catch {
Counts Counts::operator - ( Counts const& other ) const {
Counts diff;
diff.passed = passed - other.passed;
diff.failed = failed - other.failed;
diff.failedButOk = failedButOk - other.failedButOk;
diff.skipped = skipped - other.skipped;
return diff;
}
Counts& Counts::operator += ( Counts const& other ) {
passed += other.passed;
failed += other.failed;
failedButOk += other.failedButOk;
skipped += other.skipped;
return *this;
}
std::uint64_t Counts::total() const {
return passed + failed + failedButOk + skipped;
}
bool Counts::allPassed() const {
return failed == 0 && failedButOk == 0 && skipped == 0;
}
bool Counts::allOk() const {
return failed == 0;
}
Totals Totals::operator - ( Totals const& other ) const {
Totals diff;
diff.assertions = assertions - other.assertions;
diff.testCases = testCases - other.testCases;
return diff;
}
Totals& Totals::operator += ( Totals const& other ) {
assertions += other.assertions;
testCases += other.testCases;
return *this;
}
Totals Totals::delta( Totals const& prevTotals ) const {
Totals diff = *this - prevTotals;
if( diff.assertions.failed > 0 )
++diff.testCases.failed;
else if( diff.assertions.failedButOk > 0 )
++diff.testCases.failedButOk;
else if ( diff.assertions.skipped > 0 )
++ diff.testCases.skipped;
else
++diff.testCases.passed;
return diff;
}
}
namespace Catch {
namespace Detail {
void registerTranslatorImpl(
Detail::unique_ptr<IExceptionTranslator>&& translator ) {
getMutableRegistryHub().registerTranslator(
CATCH_MOVE( translator ) );
}
} // namespace Detail
} // namespace Catch
#include <ostream>
namespace Catch {
Version::Version
( unsigned int _majorVersion,
unsigned int _minorVersion,
unsigned int _patchNumber,
char const * const _branchName,
unsigned int _buildNumber )
: majorVersion( _majorVersion ),
minorVersion( _minorVersion ),
patchNumber( _patchNumber ),
branchName( _branchName ),
buildNumber( _buildNumber )
{}
std::ostream& operator << ( std::ostream& os, Version const& version ) {
os << version.majorVersion << '.'
<< version.minorVersion << '.'
<< version.patchNumber;
// branchName is never null -> 0th char is \0 if it is empty
if (version.branchName[0]) {
os << '-' << version.branchName
<< '.' << version.buildNumber;
}
return os;
}
Version const& libraryVersion() {
static Version version( 3, 4, 0, "", 0 );
return version;
}
}
namespace Catch {
const char* GeneratorException::what() const noexcept {
return m_msg;
}
} // end namespace Catch
namespace Catch {
IGeneratorTracker::~IGeneratorTracker() = default;
namespace Generators {
namespace Detail {
[[noreturn]]
void throw_generator_exception(char const* msg) {
Catch::throw_exception(GeneratorException{ msg });
}
} // end namespace Detail
GeneratorUntypedBase::~GeneratorUntypedBase() = default;
IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) {
return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
}
IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
SourceLineInfo lineInfo,
GeneratorBasePtr&& generator ) {
return getResultCapture().createGeneratorTracker(
generatorName, lineInfo, CATCH_MOVE( generator ) );
}
} // namespace Generators
} // namespace Catch
std::uint32_t Catch::Generators::Detail::getSeed() { return sharedRng()(); }
namespace Catch {
IResultCapture::~IResultCapture() = default;
}
namespace Catch {
IConfig::~IConfig() = default;
}
namespace Catch {
IExceptionTranslator::~IExceptionTranslator() = default;
IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
}
#include <string>
namespace Catch {
namespace Generators {
bool GeneratorUntypedBase::countedNext() {
auto ret = next();
if ( ret ) {
m_stringReprCache.clear();
++m_currentElementIndex;
}
return ret;
}
StringRef GeneratorUntypedBase::currentElementAsString() const {
if ( m_stringReprCache.empty() ) {
m_stringReprCache = stringifyImpl();
}
return m_stringReprCache;
}
} // namespace Generators
} // namespace Catch
namespace Catch {
IRegistryHub::~IRegistryHub() = default;
IMutableRegistryHub::~IMutableRegistryHub() = default;
}
#include <algorithm>
#include <cassert>
#include <iomanip>
namespace Catch {
ReporterConfig::ReporterConfig(
IConfig const* _fullConfig,
Detail::unique_ptr<IStream> _stream,
ColourMode colourMode,
std::map<std::string, std::string> customOptions ):
m_stream( CATCH_MOVE(_stream) ),
m_fullConfig( _fullConfig ),
m_colourMode( colourMode ),
m_customOptions( CATCH_MOVE( customOptions ) ) {}
Detail::unique_ptr<IStream> ReporterConfig::takeStream() && {
assert( m_stream );
return CATCH_MOVE( m_stream );
}
IConfig const * ReporterConfig::fullConfig() const { return m_fullConfig; }
ColourMode ReporterConfig::colourMode() const { return m_colourMode; }
std::map<std::string, std::string> const&
ReporterConfig::customOptions() const {
return m_customOptions;
}
ReporterConfig::~ReporterConfig() = default;
AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
std::vector<MessageInfo> const& _infoMessages,
Totals const& _totals )
: assertionResult( _assertionResult ),
infoMessages( _infoMessages ),
totals( _totals )
{
if( assertionResult.hasMessage() ) {
// Copy message into messages list.
// !TBD This should have been done earlier, somewhere
MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
builder.m_info.message = static_cast<std::string>(assertionResult.getMessage());
infoMessages.push_back( CATCH_MOVE(builder.m_info) );
}
}
SectionStats::SectionStats( SectionInfo&& _sectionInfo,
Counts const& _assertions,
double _durationInSeconds,
bool _missingAssertions )
: sectionInfo( CATCH_MOVE(_sectionInfo) ),
assertions( _assertions ),
durationInSeconds( _durationInSeconds ),
missingAssertions( _missingAssertions )
{}
TestCaseStats::TestCaseStats( TestCaseInfo const& _testInfo,
Totals const& _totals,
std::string&& _stdOut,
std::string&& _stdErr,
bool _aborting )
: testInfo( &_testInfo ),
totals( _totals ),
stdOut( CATCH_MOVE(_stdOut) ),
stdErr( CATCH_MOVE(_stdErr) ),
aborting( _aborting )
{}
TestRunStats::TestRunStats( TestRunInfo const& _runInfo,
Totals const& _totals,
bool _aborting )
: runInfo( _runInfo ),
totals( _totals ),
aborting( _aborting )
{}
IEventListener::~IEventListener() = default;
} // end namespace Catch
namespace Catch {
IReporterFactory::~IReporterFactory() = default;
EventListenerFactory::~EventListenerFactory() = default;
}
namespace Catch {
ITestCaseRegistry::~ITestCaseRegistry() = default;
}
namespace Catch {
AssertionHandler::AssertionHandler
( StringRef macroName,
SourceLineInfo const& lineInfo,
StringRef capturedExpression,
ResultDisposition::Flags resultDisposition )
: m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
m_resultCapture( getResultCapture() )
{
m_resultCapture.notifyAssertionStarted( m_assertionInfo );
}
void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
}
void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef message) {
m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
}
auto AssertionHandler::allowThrows() const -> bool {
return getCurrentContext().getConfig()->allowThrows();
}
void AssertionHandler::complete() {
m_completed = true;
if( m_reaction.shouldDebugBreak ) {
// If you find your debugger stopping you here then go one level up on the
// call-stack for the code that caused it (typically a failed assertion)
// (To go back to the test and change execution, jump over the throw, next)
CATCH_BREAK_INTO_DEBUGGER();
}
if (m_reaction.shouldThrow) {
throw_test_failure_exception();
}
if ( m_reaction.shouldSkip ) {
throw_test_skip_exception();
}
}
void AssertionHandler::handleUnexpectedInflightException() {
m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
}
void AssertionHandler::handleExceptionThrownAsExpected() {
m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
}
void AssertionHandler::handleExceptionNotThrownAsExpected() {
m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
}
void AssertionHandler::handleUnexpectedExceptionNotThrown() {
m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
}
void AssertionHandler::handleThrowingCallSkipped() {
m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
}
// This is the overload that takes a string and infers the Equals matcher from it
// The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str ) {
handleExceptionMatchExpr( handler, Matchers::Equals( str ) );
}
} // namespace Catch
#include <algorithm>
namespace Catch {
namespace Detail {
bool CaseInsensitiveLess::operator()( StringRef lhs,
StringRef rhs ) const {
return std::lexicographical_compare(
lhs.begin(), lhs.end(),
rhs.begin(), rhs.end(),
[]( char l, char r ) { return toLower( l ) < toLower( r ); } );
}
bool
CaseInsensitiveEqualTo::operator()( StringRef lhs,
StringRef rhs ) const {
return std::equal(
lhs.begin(), lhs.end(),
rhs.begin(), rhs.end(),
[]( char l, char r ) { return toLower( l ) == toLower( r ); } );
}
} // namespace Detail
} // namespace Catch
#include <algorithm>
#include <ostream>
namespace {
bool isOptPrefix( char c ) {
return c == '-'
#ifdef CATCH_PLATFORM_WINDOWS
|| c == '/'
#endif
;
}
std::string normaliseOpt( std::string const& optName ) {
#ifdef CATCH_PLATFORM_WINDOWS
if ( optName[0] == '/' )
return "-" + optName.substr( 1 );
else
#endif
return optName;
}
} // namespace
namespace Catch {
namespace Clara {
namespace Detail {
void TokenStream::loadBuffer() {
m_tokenBuffer.clear();
// Skip any empty strings
while ( it != itEnd && it->empty() ) {
++it;
}
if ( it != itEnd ) {
auto const& next = *it;
if ( isOptPrefix( next[0] ) ) {
auto delimiterPos = next.find_first_of( " :=" );
if ( delimiterPos != std::string::npos ) {
m_tokenBuffer.push_back(
{ TokenType::Option,
next.substr( 0, delimiterPos ) } );
m_tokenBuffer.push_back(
{ TokenType::Argument,
next.substr( delimiterPos + 1 ) } );
} else {
if ( next[1] != '-' && next.size() > 2 ) {
std::string opt = "- ";
for ( size_t i = 1; i < next.size(); ++i ) {
opt[1] = next[i];
m_tokenBuffer.push_back(
{ TokenType::Option, opt } );
}
} else {
m_tokenBuffer.push_back(
{ TokenType::Option, next } );
}
}
} else {
m_tokenBuffer.push_back(
{ TokenType::Argument, next } );
}
}
}
TokenStream::TokenStream( Args const& args ):
TokenStream( args.m_args.begin(), args.m_args.end() ) {}
TokenStream::TokenStream( Iterator it_, Iterator itEnd_ ):
it( it_ ), itEnd( itEnd_ ) {
loadBuffer();
}
TokenStream& TokenStream::operator++() {
if ( m_tokenBuffer.size() >= 2 ) {
m_tokenBuffer.erase( m_tokenBuffer.begin() );
} else {
if ( it != itEnd )
++it;
loadBuffer();
}
return *this;
}
ParserResult convertInto( std::string const& source,
std::string& target ) {
target = source;
return ParserResult::ok( ParseResultType::Matched );
}
ParserResult convertInto( std::string const& source,
bool& target ) {
std::string srcLC = toLower( source );
if ( srcLC == "y" || srcLC == "1" || srcLC == "true" ||
srcLC == "yes" || srcLC == "on" ) {
target = true;
} else if ( srcLC == "n" || srcLC == "0" || srcLC == "false" ||
srcLC == "no" || srcLC == "off" ) {
target = false;
} else {
return ParserResult::runtimeError(
"Expected a boolean value but did not recognise: '" +
source + '\'' );
}
return ParserResult::ok( ParseResultType::Matched );
}
size_t ParserBase::cardinality() const { return 1; }
InternalParseResult ParserBase::parse( Args const& args ) const {
return parse( args.exeName(), TokenStream( args ) );
}
ParseState::ParseState( ParseResultType type,
TokenStream const& remainingTokens ):
m_type( type ), m_remainingTokens( remainingTokens ) {}
ParserResult BoundFlagRef::setFlag( bool flag ) {
m_ref = flag;
return ParserResult::ok( ParseResultType::Matched );
}
ResultBase::~ResultBase() = default;
bool BoundRef::isContainer() const { return false; }
bool BoundRef::isFlag() const { return false; }
bool BoundFlagRefBase::isFlag() const { return true; }
} // namespace Detail
Detail::InternalParseResult Arg::parse(std::string const&,
Detail::TokenStream const& tokens) const {
auto validationResult = validate();
if (!validationResult)
return Detail::InternalParseResult(validationResult);
auto remainingTokens = tokens;
auto const& token = *remainingTokens;
if (token.type != Detail::TokenType::Argument)
return Detail::InternalParseResult::ok(Detail::ParseState(
ParseResultType::NoMatch, remainingTokens));
assert(!m_ref->isFlag());
auto valueRef =
static_cast<Detail::BoundValueRefBase*>(m_ref.get());
auto result = valueRef->setValue(remainingTokens->token);
if (!result)
return Detail::InternalParseResult(result);
else
return Detail::InternalParseResult::ok(Detail::ParseState(
ParseResultType::Matched, ++remainingTokens));
}
Opt::Opt(bool& ref) :
ParserRefImpl(std::make_shared<Detail::BoundFlagRef>(ref)) {}
std::vector<Detail::HelpColumns> Opt::getHelpColumns() const {
std::ostringstream oss;
bool first = true;
for (auto const& opt : m_optNames) {
if (first)
first = false;
else
oss << ", ";
oss << opt;
}
if (!m_hint.empty())
oss << " <" << m_hint << '>';
return { { oss.str(), m_description } };
}
bool Opt::isMatch(std::string const& optToken) const {
auto normalisedToken = normaliseOpt(optToken);
for (auto const& name : m_optNames) {
if (normaliseOpt(name) == normalisedToken)
return true;
}
return false;
}
Detail::InternalParseResult Opt::parse(std::string const&,
Detail::TokenStream const& tokens) const {
auto validationResult = validate();
if (!validationResult)
return Detail::InternalParseResult(validationResult);
auto remainingTokens = tokens;
if (remainingTokens &&
remainingTokens->type == Detail::TokenType::Option) {
auto const& token = *remainingTokens;
if (isMatch(token.token)) {
if (m_ref->isFlag()) {
auto flagRef =
static_cast<Detail::BoundFlagRefBase*>(
m_ref.get());
auto result = flagRef->setFlag(true);
if (!result)
return Detail::InternalParseResult(result);
if (result.value() ==
ParseResultType::ShortCircuitAll)
return Detail::InternalParseResult::ok(Detail::ParseState(
result.value(), remainingTokens));
} else {
auto valueRef =
static_cast<Detail::BoundValueRefBase*>(
m_ref.get());
++remainingTokens;
if (!remainingTokens)
return Detail::InternalParseResult::runtimeError(
"Expected argument following " +
token.token);
auto const& argToken = *remainingTokens;
if (argToken.type != Detail::TokenType::Argument)
return Detail::InternalParseResult::runtimeError(
"Expected argument following " +
token.token);
const auto result = valueRef->setValue(argToken.token);
if (!result)
return Detail::InternalParseResult(result);
if (result.value() ==
ParseResultType::ShortCircuitAll)
return Detail::InternalParseResult::ok(Detail::ParseState(
result.value(), remainingTokens));
}
return Detail::InternalParseResult::ok(Detail::ParseState(
ParseResultType::Matched, ++remainingTokens));
}
}
return Detail::InternalParseResult::ok(
Detail::ParseState(ParseResultType::NoMatch, remainingTokens));
}
Detail::Result Opt::validate() const {
if (m_optNames.empty())
return Detail::Result::logicError("No options supplied to Opt");
for (auto const& name : m_optNames) {
if (name.empty())
return Detail::Result::logicError(
"Option name cannot be empty");
#ifdef CATCH_PLATFORM_WINDOWS
if (name[0] != '-' && name[0] != '/')
return Detail::Result::logicError(
"Option name must begin with '-' or '/'");
#else
if (name[0] != '-')
return Detail::Result::logicError(
"Option name must begin with '-'");
#endif
}
return ParserRefImpl::validate();
}
ExeName::ExeName() :
m_name(std::make_shared<std::string>("<executable>")) {}
ExeName::ExeName(std::string& ref) : ExeName() {
m_ref = std::make_shared<Detail::BoundValueRef<std::string>>(ref);
}
Detail::InternalParseResult
ExeName::parse(std::string const&,
Detail::TokenStream const& tokens) const {
return Detail::InternalParseResult::ok(
Detail::ParseState(ParseResultType::NoMatch, tokens));
}
ParserResult ExeName::set(std::string const& newName) {
auto lastSlash = newName.find_last_of("\\/");
auto filename = (lastSlash == std::string::npos)
? newName
: newName.substr(lastSlash + 1);
*m_name = filename;
if (m_ref)
return m_ref->setValue(filename);
else
return ParserResult::ok(ParseResultType::Matched);
}
Parser& Parser::operator|=( Parser const& other ) {
m_options.insert( m_options.end(),
other.m_options.begin(),
other.m_options.end() );
m_args.insert(
m_args.end(), other.m_args.begin(), other.m_args.end() );
return *this;
}
std::vector<Detail::HelpColumns> Parser::getHelpColumns() const {
std::vector<Detail::HelpColumns> cols;
for ( auto const& o : m_options ) {
auto childCols = o.getHelpColumns();
cols.insert( cols.end(), childCols.begin(), childCols.end() );
}
return cols;
}
void Parser::writeToStream( std::ostream& os ) const {
if ( !m_exeName.name().empty() ) {
os << "usage:\n"
<< " " << m_exeName.name() << ' ';
bool required = true, first = true;
for ( auto const& arg : m_args ) {
if ( first )
first = false;
else
os << ' ';
if ( arg.isOptional() && required ) {
os << '[';
required = false;
}
os << '<' << arg.hint() << '>';
if ( arg.cardinality() == 0 )
os << " ... ";
}
if ( !required )
os << ']';
if ( !m_options.empty() )
os << " options";
os << "\n\nwhere options are:\n";
}
auto rows = getHelpColumns();
size_t consoleWidth = CATCH_CONFIG_CONSOLE_WIDTH;
size_t optWidth = 0;
for ( auto const& cols : rows )
optWidth = ( std::max )( optWidth, cols.left.size() + 2 );
optWidth = ( std::min )( optWidth, consoleWidth / 2 );
for ( auto const& cols : rows ) {
auto row = TextFlow::Column( cols.left )
.width( optWidth )
.indent( 2 ) +
TextFlow::Spacer( 4 ) +
TextFlow::Column( cols.right )
.width( consoleWidth - 7 - optWidth );
os << row << '\n';
}
}
Detail::Result Parser::validate() const {
for ( auto const& opt : m_options ) {
auto result = opt.validate();
if ( !result )
return result;
}
for ( auto const& arg : m_args ) {
auto result = arg.validate();
if ( !result )
return result;
}
return Detail::Result::ok();
}
Detail::InternalParseResult
Parser::parse( std::string const& exeName,
Detail::TokenStream const& tokens ) const {
struct ParserInfo {
ParserBase const* parser = nullptr;
size_t count = 0;
};
std::vector<ParserInfo> parseInfos;
parseInfos.reserve( m_options.size() + m_args.size() );
for ( auto const& opt : m_options ) {
parseInfos.push_back( { &opt, 0 } );
}
for ( auto const& arg : m_args ) {
parseInfos.push_back( { &arg, 0 } );
}
m_exeName.set( exeName );
auto result = Detail::InternalParseResult::ok(
Detail::ParseState( ParseResultType::NoMatch, tokens ) );
while ( result.value().remainingTokens() ) {
bool tokenParsed = false;
for ( auto& parseInfo : parseInfos ) {
if ( parseInfo.parser->cardinality() == 0 ||
parseInfo.count < parseInfo.parser->cardinality() ) {
result = parseInfo.parser->parse(
exeName, result.value().remainingTokens() );
if ( !result )
return result;
if ( result.value().type() !=
ParseResultType::NoMatch ) {
tokenParsed = true;
++parseInfo.count;
break;
}
}
}
if ( result.value().type() == ParseResultType::ShortCircuitAll )
return result;
if ( !tokenParsed )
return Detail::InternalParseResult::runtimeError(
"Unrecognised token: " +
result.value().remainingTokens()->token );
}
// !TBD Check missing required options
return result;
}
Args::Args(int argc, char const* const* argv) :
m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
Args::Args(std::initializer_list<std::string> args) :
m_exeName(*args.begin()),
m_args(args.begin() + 1, args.end()) {}
Help::Help( bool& showHelpFlag ):
Opt( [&]( bool flag ) {
showHelpFlag = flag;
return ParserResult::ok( ParseResultType::ShortCircuitAll );
} ) {
static_cast<Opt&> ( *this )(
"display usage information" )["-?"]["-h"]["--help"]
.optional();
}
} // namespace Clara
} // namespace Catch
#include <fstream>
#include <string>
namespace Catch {
Clara::Parser makeCommandLineParser( ConfigData& config ) {
using namespace Clara;
auto const setWarning = [&]( std::string const& warning ) {
if ( warning == "NoAssertions" ) {
config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::NoAssertions);
return ParserResult::ok( ParseResultType::Matched );
} else if ( warning == "UnmatchedTestSpec" ) {
config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::UnmatchedTestSpec);
return ParserResult::ok( ParseResultType::Matched );
}
return ParserResult ::runtimeError(
"Unrecognised warning option: '" + warning + '\'' );
};
auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
std::ifstream f( filename.c_str() );
if( !f.is_open() )
return ParserResult::runtimeError( "Unable to load input file: '" + filename + '\'' );
std::string line;
while( std::getline( f, line ) ) {
line = trim(line);
if( !line.empty() && !startsWith( line, '#' ) ) {
if( !startsWith( line, '"' ) )
line = '"' + line + '"';
config.testsOrTags.push_back( line );
config.testsOrTags.emplace_back( "," );
}
}
//Remove comma in the end
if(!config.testsOrTags.empty())
config.testsOrTags.erase( config.testsOrTags.end()-1 );
return ParserResult::ok( ParseResultType::Matched );
};
auto const setTestOrder = [&]( std::string const& order ) {
if( startsWith( "declared", order ) )
config.runOrder = TestRunOrder::Declared;
else if( startsWith( "lexical", order ) )
config.runOrder = TestRunOrder::LexicographicallySorted;
else if( startsWith( "random", order ) )
config.runOrder = TestRunOrder::Randomized;
else
return ParserResult::runtimeError( "Unrecognised ordering: '" + order + '\'' );
return ParserResult::ok( ParseResultType::Matched );
};
auto const setRngSeed = [&]( std::string const& seed ) {
if( seed == "time" ) {
config.rngSeed = generateRandomSeed(GenerateFrom::Time);
return ParserResult::ok(ParseResultType::Matched);
} else if (seed == "random-device") {
config.rngSeed = generateRandomSeed(GenerateFrom::RandomDevice);
return ParserResult::ok(ParseResultType::Matched);
}
// TODO: ideally we should be parsing uint32_t directly
// fix this later when we add new parse overload
auto parsedSeed = parseUInt( seed, 0 );
if ( !parsedSeed ) {
return ParserResult::runtimeError( "Could not parse '" + seed + "' as seed" );
}
config.rngSeed = *parsedSeed;
return ParserResult::ok( ParseResultType::Matched );
};
auto const setDefaultColourMode = [&]( std::string const& colourMode ) {
Optional<ColourMode> maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode ));
if ( !maybeMode ) {
return ParserResult::runtimeError(
"colour mode must be one of: default, ansi, win32, "
"or none. '" +
colourMode + "' is not recognised" );
}
auto mode = *maybeMode;
if ( !isColourImplAvailable( mode ) ) {
return ParserResult::runtimeError(
"colour mode '" + colourMode +
"' is not supported in this binary" );
}
config.defaultColourMode = mode;
return ParserResult::ok( ParseResultType::Matched );
};
auto const setWaitForKeypress = [&]( std::string const& keypress ) {
auto keypressLc = toLower( keypress );
if (keypressLc == "never")
config.waitForKeypress = WaitForKeypress::Never;
else if( keypressLc == "start" )
config.waitForKeypress = WaitForKeypress::BeforeStart;
else if( keypressLc == "exit" )
config.waitForKeypress = WaitForKeypress::BeforeExit;
else if( keypressLc == "both" )
config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
else
return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
return ParserResult::ok( ParseResultType::Matched );
};
auto const setVerbosity = [&]( std::string const& verbosity ) {
auto lcVerbosity = toLower( verbosity );
if( lcVerbosity == "quiet" )
config.verbosity = Verbosity::Quiet;
else if( lcVerbosity == "normal" )
config.verbosity = Verbosity::Normal;
else if( lcVerbosity == "high" )
config.verbosity = Verbosity::High;
else
return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + '\'' );
return ParserResult::ok( ParseResultType::Matched );
};
auto const setReporter = [&]( std::string const& userReporterSpec ) {
if ( userReporterSpec.empty() ) {
return ParserResult::runtimeError( "Received empty reporter spec." );
}
Optional<ReporterSpec> parsed =
parseReporterSpec( userReporterSpec );
if ( !parsed ) {
return ParserResult::runtimeError(
"Could not parse reporter spec '" + userReporterSpec +
"'" );
}
auto const& reporterSpec = *parsed;
auto const& factories =
getRegistryHub().getReporterRegistry().getFactories();
auto result = factories.find( reporterSpec.name() );
if ( result == factories.end() ) {
return ParserResult::runtimeError(
"Unrecognized reporter, '" + reporterSpec.name() +
"'. Check available with --list-reporters" );
}
const bool hadOutputFile = reporterSpec.outputFile().some();
config.reporterSpecifications.push_back( CATCH_MOVE( *parsed ) );
// It would be enough to check this only once at the very end, but
// there is not a place where we could call this check, so do it
// every time it could fail. For valid inputs, this is still called
// at most once.
if (!hadOutputFile) {
int n_reporters_without_file = 0;
for (auto const& spec : config.reporterSpecifications) {
if (spec.outputFile().none()) {
n_reporters_without_file++;
}
}
if (n_reporters_without_file > 1) {
return ParserResult::runtimeError( "Only one reporter may have unspecified output file." );
}
}
return ParserResult::ok( ParseResultType::Matched );
};
auto const setShardCount = [&]( std::string const& shardCount ) {
auto parsedCount = parseUInt( shardCount );
if ( !parsedCount ) {
return ParserResult::runtimeError(
"Could not parse '" + shardCount + "' as shard count" );
}
if ( *parsedCount == 0 ) {
return ParserResult::runtimeError(
"Shard count must be positive" );
}
config.shardCount = *parsedCount;
return ParserResult::ok( ParseResultType::Matched );
};
auto const setShardIndex = [&](std::string const& shardIndex) {
auto parsedIndex = parseUInt( shardIndex );
if ( !parsedIndex ) {
return ParserResult::runtimeError(
"Could not parse '" + shardIndex + "' as shard index" );
}
config.shardIndex = *parsedIndex;
return ParserResult::ok( ParseResultType::Matched );
};
auto cli
= ExeName( config.processName )
| Help( config.showHelp )
| Opt( config.showSuccessfulTests )
["-s"]["--success"]
( "include successful tests in output" )
| Opt( config.shouldDebugBreak )
["-b"]["--break"]
( "break into debugger on failure" )
| Opt( config.noThrow )
["-e"]["--nothrow"]
( "skip exception tests" )
| Opt( config.showInvisibles )
["-i"]["--invisibles"]
( "show invisibles (tabs, newlines)" )
| Opt( config.defaultOutputFilename, "filename" )
["-o"]["--out"]
( "default output filename" )
| Opt( accept_many, setReporter, "name[::key=value]*" )
["-r"]["--reporter"]
( "reporter to use (defaults to console)" )
| Opt( config.name, "name" )
["-n"]["--name"]
( "suite name" )
| Opt( [&]( bool ){ config.abortAfter = 1; } )
["-a"]["--abort"]
( "abort at first failure" )
| Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
["-x"]["--abortx"]
( "abort after x failures" )
| Opt( accept_many, setWarning, "warning name" )
["-w"]["--warn"]
( "enable warnings" )
| Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
["-d"]["--durations"]
( "show test durations" )
| Opt( config.minDuration, "seconds" )
["-D"]["--min-duration"]
( "show test durations for tests taking at least the given number of seconds" )
| Opt( loadTestNamesFromFile, "filename" )
["-f"]["--input-file"]
( "load test names to run from a file" )
| Opt( config.filenamesAsTags )
["-#"]["--filenames-as-tags"]
( "adds a tag for the filename" )
| Opt( config.sectionsToRun, "section name" )
["-c"]["--section"]
( "specify section to run" )
| Opt( setVerbosity, "quiet|normal|high" )
["-v"]["--verbosity"]
( "set output verbosity" )
| Opt( config.listTests )
["--list-tests"]
( "list all/matching test cases" )
| Opt( config.listTags )
["--list-tags"]
( "list all/matching tags" )
| Opt( config.listReporters )
["--list-reporters"]
( "list all available reporters" )
| Opt( config.listListeners )
["--list-listeners"]
( "list all listeners" )
| Opt( setTestOrder, "decl|lex|rand" )
["--order"]
( "test case order (defaults to decl)" )
| Opt( setRngSeed, "'time'|'random-device'|number" )
["--rng-seed"]
( "set a specific seed for random numbers" )
| Opt( setDefaultColourMode, "ansi|win32|none|default" )
["--colour-mode"]
( "what color mode should be used as default" )
| Opt( config.libIdentify )
["--libidentify"]
( "report name and version according to libidentify standard" )
| Opt( setWaitForKeypress, "never|start|exit|both" )
["--wait-for-keypress"]
( "waits for a keypress before exiting" )
| Opt( config.skipBenchmarks)
["--skip-benchmarks"]
( "disable running benchmarks")
| Opt( config.benchmarkSamples, "samples" )
["--benchmark-samples"]
( "number of samples to collect (default: 100)" )
| Opt( config.benchmarkResamples, "resamples" )
["--benchmark-resamples"]
( "number of resamples for the bootstrap (default: 100000)" )
| Opt( config.benchmarkConfidenceInterval, "confidence interval" )
["--benchmark-confidence-interval"]
( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
| Opt( config.benchmarkNoAnalysis )
["--benchmark-no-analysis"]
( "perform only measurements; do not perform any analysis" )
| Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
["--benchmark-warmup-time"]
( "amount of time in milliseconds spent on warming up each test (default: 100)" )
| Opt( setShardCount, "shard count" )
["--shard-count"]
( "split the tests to execute into this many groups" )
| Opt( setShardIndex, "shard index" )
["--shard-index"]
( "index of the group of tests to execute (see --shard-count)" ) |
Opt( config.allowZeroTests )
["--allow-running-no-tests"]
( "Treat 'No tests run' as a success" )
| Arg( config.testsOrTags, "test name|pattern|tags" )
( "which test or tests to use" );
return cli;
}
} // end namespace Catch
#if defined(__clang__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wexit-time-destructors"
#endif
#include <cassert>
#include <ostream>
#include <utility>
namespace Catch {
ColourImpl::~ColourImpl() = default;
ColourImpl::ColourGuard ColourImpl::guardColour( Colour::Code colourCode ) {
return ColourGuard(colourCode, this );
}
void ColourImpl::ColourGuard::engageImpl( std::ostream& stream ) {
assert( &stream == &m_colourImpl->m_stream->stream() &&
"Engaging colour guard for different stream than used by the "
"parent colour implementation" );
static_cast<void>( stream );
m_engaged = true;
m_colourImpl->use( m_code );
}
ColourImpl::ColourGuard::ColourGuard( Colour::Code code,
ColourImpl const* colour ):
m_colourImpl( colour ), m_code( code ) {
}
ColourImpl::ColourGuard::ColourGuard( ColourGuard&& rhs ) noexcept:
m_colourImpl( rhs.m_colourImpl ),
m_code( rhs.m_code ),
m_engaged( rhs.m_engaged ) {
rhs.m_engaged = false;
}
ColourImpl::ColourGuard&
ColourImpl::ColourGuard::operator=( ColourGuard&& rhs ) noexcept {
using std::swap;
swap( m_colourImpl, rhs.m_colourImpl );
swap( m_code, rhs.m_code );
swap( m_engaged, rhs.m_engaged );
return *this;
}
ColourImpl::ColourGuard::~ColourGuard() {
if ( m_engaged ) {
m_colourImpl->use( Colour::None );
}
}
ColourImpl::ColourGuard&
ColourImpl::ColourGuard::engage( std::ostream& stream ) & {
engageImpl( stream );
return *this;
}
ColourImpl::ColourGuard&&
ColourImpl::ColourGuard::engage( std::ostream& stream ) && {
engageImpl( stream );
return CATCH_MOVE(*this);
}
namespace {
//! A do-nothing implementation of colour, used as fallback for unknown
//! platforms, and when the user asks to deactivate all colours.
class NoColourImpl final : public ColourImpl {
public:
NoColourImpl( IStream* stream ): ColourImpl( stream ) {}
private:
void use( Colour::Code ) const override {}
};
} // namespace
} // namespace Catch
#if defined ( CATCH_CONFIG_COLOUR_WIN32 ) /////////////////////////////////////////
namespace Catch {
namespace {
class Win32ColourImpl final : public ColourImpl {
public:
Win32ColourImpl(IStream* stream):
ColourImpl(stream) {
CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ),
&csbiInfo );
originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
}
static bool useImplementationForStream(IStream const& stream) {
// Win32 text colour APIs can only be used on console streams
// We cannot check that the output hasn't been redirected,
// so we just check that the original stream is console stream.
return stream.isConsole();
}
private:
void use( Colour::Code _colourCode ) const override {
switch( _colourCode ) {
case Colour::None: return setTextAttribute( originalForegroundAttributes );
case Colour::White: return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
case Colour::Red: return setTextAttribute( FOREGROUND_RED );
case Colour::Green: return setTextAttribute( FOREGROUND_GREEN );
case Colour::Blue: return setTextAttribute( FOREGROUND_BLUE );
case Colour::Cyan: return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
case Colour::Yellow: return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
case Colour::Grey: return setTextAttribute( 0 );
case Colour::LightGrey: return setTextAttribute( FOREGROUND_INTENSITY );
case Colour::BrightRed: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
case Colour::BrightGreen: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
case Colour::BrightWhite: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
case Colour::BrightYellow: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
default:
CATCH_ERROR( "Unknown colour requested" );
}
}
void setTextAttribute( WORD _textAttribute ) const {
SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),
_textAttribute |
originalBackgroundAttributes );
}
WORD originalForegroundAttributes;
WORD originalBackgroundAttributes;
};
} // end anon namespace
} // end namespace Catch
#endif // Windows/ ANSI/ None
#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC )
# define CATCH_INTERNAL_HAS_ISATTY
# include <unistd.h>
#endif
namespace Catch {
namespace {
class ANSIColourImpl final : public ColourImpl {
public:
ANSIColourImpl( IStream* stream ): ColourImpl( stream ) {}
static bool useImplementationForStream(IStream const& stream) {
// This is kinda messy due to trying to support a bunch of
// different platforms at once.
// The basic idea is that if we are asked to do autodetection (as
// opposed to being told to use posixy colours outright), then we
// only want to use the colours if we are writing to console.
// However, console might be redirected, so we make an attempt at
// checking for that on platforms where we know how to do that.
bool useColour = stream.isConsole();
#if defined( CATCH_INTERNAL_HAS_ISATTY ) && \
!( defined( __DJGPP__ ) && defined( __STRICT_ANSI__ ) )
ErrnoGuard _; // for isatty
useColour = useColour && isatty( STDOUT_FILENO );
# endif
# if defined( CATCH_PLATFORM_MAC ) || defined( CATCH_PLATFORM_IPHONE )
useColour = useColour && !isDebuggerActive();
# endif
return useColour;
}
private:
void use( Colour::Code _colourCode ) const override {
auto setColour = [&out =
m_stream->stream()]( char const* escapeCode ) {
// The escape sequence must be flushed to console, otherwise
// if stdin and stderr are intermixed, we'd get accidentally
// coloured output.
out << '\033' << escapeCode << std::flush;
};
switch( _colourCode ) {
case Colour::None:
case Colour::White: return setColour( "[0m" );
case Colour::Red: return setColour( "[0;31m" );
case Colour::Green: return setColour( "[0;32m" );
case Colour::Blue: return setColour( "[0;34m" );
case Colour::Cyan: return setColour( "[0;36m" );
case Colour::Yellow: return setColour( "[0;33m" );
case Colour::Grey: return setColour( "[1;30m" );
case Colour::LightGrey: return setColour( "[0;37m" );
case Colour::BrightRed: return setColour( "[1;31m" );
case Colour::BrightGreen: return setColour( "[1;32m" );
case Colour::BrightWhite: return setColour( "[1;37m" );
case Colour::BrightYellow: return setColour( "[1;33m" );
case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
}
}
};
} // end anon namespace
} // end namespace Catch
namespace Catch {
Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode implSelection,
IStream* stream ) {
#if defined( CATCH_CONFIG_COLOUR_WIN32 )
if ( implSelection == ColourMode::Win32 ) {
return Detail::make_unique<Win32ColourImpl>( stream );
}
#endif
if ( implSelection == ColourMode::ANSI ) {
return Detail::make_unique<ANSIColourImpl>( stream );
}
if ( implSelection == ColourMode::None ) {
return Detail::make_unique<NoColourImpl>( stream );
}
if ( implSelection == ColourMode::PlatformDefault) {
#if defined( CATCH_CONFIG_COLOUR_WIN32 )
if ( Win32ColourImpl::useImplementationForStream( *stream ) ) {
return Detail::make_unique<Win32ColourImpl>( stream );
}
#endif
if ( ANSIColourImpl::useImplementationForStream( *stream ) ) {
return Detail::make_unique<ANSIColourImpl>( stream );
}
return Detail::make_unique<NoColourImpl>( stream );
}
CATCH_ERROR( "Could not create colour impl for selection " << static_cast<int>(implSelection) );
}
bool isColourImplAvailable( ColourMode colourSelection ) {
switch ( colourSelection ) {
#if defined( CATCH_CONFIG_COLOUR_WIN32 )
case ColourMode::Win32:
#endif
case ColourMode::ANSI:
case ColourMode::None:
case ColourMode::PlatformDefault:
return true;
default:
return false;
}
}
} // end namespace Catch
#if defined(__clang__)
# pragma clang diagnostic pop
#endif
namespace Catch {
Context* Context::currentContext = nullptr;
void cleanUpContext() {
delete Context::currentContext;
Context::currentContext = nullptr;
}
void Context::createContext() {
currentContext = new Context();
}
Context& getCurrentMutableContext() {
if ( !Context::currentContext ) { Context::createContext(); }
// NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
return *Context::currentContext;
}
void Context::setResultCapture( IResultCapture* resultCapture ) {
m_resultCapture = resultCapture;
}
void Context::setConfig( IConfig const* config ) { m_config = config; }
SimplePcg32& sharedRng() {
static SimplePcg32 s_rng;
return s_rng;
}
}
#include <ostream>
#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
#include <android/log.h>
namespace Catch {
void writeToDebugConsole( std::string const& text ) {
__android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
}
}
#elif defined(CATCH_PLATFORM_WINDOWS)
namespace Catch {
void writeToDebugConsole( std::string const& text ) {
::OutputDebugStringA( text.c_str() );
}
}
#else
namespace Catch {
void writeToDebugConsole( std::string const& text ) {
// !TBD: Need a version for Mac/ XCode and other IDEs
Catch::cout() << text;
}
}
#endif // Platform
#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
# include <cassert>
# include <sys/types.h>
# include <unistd.h>
# include <cstddef>
# include <ostream>
#ifdef __apple_build_version__
// These headers will only compile with AppleClang (XCode)
// For other compilers (Clang, GCC, ... ) we need to exclude them
# include <sys/sysctl.h>
#endif
namespace Catch {
#ifdef __apple_build_version__
// The following function is taken directly from the following technical note:
// https://developer.apple.com/library/archive/qa/qa1361/_index.html
// Returns true if the current process is being debugged (either
// running under the debugger or has a debugger attached post facto).
bool isDebuggerActive(){
int mib[4];
struct kinfo_proc info;
std::size_t size;
// Initialize the flags so that, if sysctl fails for some bizarre
// reason, we get a predictable result.
info.kp_proc.p_flag = 0;
// Initialize mib, which tells sysctl the info we want, in this case
// we're looking for information about a specific process ID.
mib[0] = CTL_KERN;
mib[1] = KERN_PROC;
mib[2] = KERN_PROC_PID;
mib[3] = getpid();
// Call sysctl.
size = sizeof(info);
if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n\n" << std::flush;
return false;
}
// We're being debugged if the P_TRACED flag is set.
return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
}
#else
bool isDebuggerActive() {
// We need to find another way to determine this for non-appleclang compilers on macOS
return false;
}
#endif
} // namespace Catch
#elif defined(CATCH_PLATFORM_LINUX)
#include <fstream>
#include <string>
namespace Catch{
// The standard POSIX way of detecting a debugger is to attempt to
// ptrace() the process, but this needs to be done from a child and not
// this process itself to still allow attaching to this process later
// if wanted, so is rather heavy. Under Linux we have the PID of the
// "debugger" (which doesn't need to be gdb, of course, it could also
// be strace, for example) in /proc/$PID/status, so just get it from
// there instead.
bool isDebuggerActive(){
// Libstdc++ has a bug, where std::ifstream sets errno to 0
// This way our users can properly assert over errno values
ErrnoGuard guard;
std::ifstream in("/proc/self/status");
for( std::string line; std::getline(in, line); ) {
static const int PREFIX_LEN = 11;
if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
// We're traced if the PID is not 0 and no other PID starts
// with 0 digit, so it's enough to check for just a single
// character.
return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
}
}
return false;
}
} // namespace Catch
#elif defined(_MSC_VER)
extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
namespace Catch {
bool isDebuggerActive() {
return IsDebuggerPresent() != 0;
}
}
#elif defined(__MINGW32__)
extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
namespace Catch {
bool isDebuggerActive() {
return IsDebuggerPresent() != 0;
}
}
#else
namespace Catch {
bool isDebuggerActive() { return false; }
}
#endif // Platform
namespace Catch {
ITransientExpression::~ITransientExpression() = default;
void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
if( lhs.size() + rhs.size() < 40 &&
lhs.find('\n') == std::string::npos &&
rhs.find('\n') == std::string::npos )
os << lhs << ' ' << op << ' ' << rhs;
else
os << lhs << '\n' << op << '\n' << rhs;
}
}
#include <stdexcept>
namespace Catch {
#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
[[noreturn]]
void throw_exception(std::exception const& e) {
Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
<< "The message was: " << e.what() << '\n';
std::terminate();
}
#endif
[[noreturn]]
void throw_logic_error(std::string const& msg) {
throw_exception(std::logic_error(msg));
}
[[noreturn]]
void throw_domain_error(std::string const& msg) {
throw_exception(std::domain_error(msg));
}
[[noreturn]]
void throw_runtime_error(std::string const& msg) {
throw_exception(std::runtime_error(msg));
}
} // namespace Catch;
#include <cassert>
namespace Catch {
IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() = default;
namespace Detail {
namespace {
// Extracts the actual name part of an enum instance
// In other words, it returns the Blue part of Bikeshed::Colour::Blue
StringRef extractInstanceName(StringRef enumInstance) {
// Find last occurrence of ":"
size_t name_start = enumInstance.size();
while (name_start > 0 && enumInstance[name_start - 1] != ':') {
--name_start;
}
return enumInstance.substr(name_start, enumInstance.size() - name_start);
}
}
std::vector<StringRef> parseEnums( StringRef enums ) {
auto enumValues = splitStringRef( enums, ',' );
std::vector<StringRef> parsed;
parsed.reserve( enumValues.size() );
for( auto const& enumValue : enumValues ) {
parsed.push_back(trim(extractInstanceName(enumValue)));
}
return parsed;
}
EnumInfo::~EnumInfo() {}
StringRef EnumInfo::lookup( int value ) const {
for( auto const& valueToName : m_values ) {
if( valueToName.first == value )
return valueToName.second;
}
return "{** unexpected enum value **}"_sr;
}
Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
auto enumInfo = Catch::Detail::make_unique<EnumInfo>();
enumInfo->m_name = enumName;
enumInfo->m_values.reserve( values.size() );
const auto valueNames = Catch::Detail::parseEnums( allValueNames );
assert( valueNames.size() == values.size() );
std::size_t i = 0;
for( auto value : values )
enumInfo->m_values.emplace_back(value, valueNames[i++]);
return enumInfo;
}
EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
return *m_enumInfos.back();
}
} // Detail
} // Catch
#include <cerrno>
namespace Catch {
ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
}
#include <exception>
namespace Catch {
namespace {
static std::string tryTranslators(
std::vector<
Detail::unique_ptr<IExceptionTranslator const>> const& translators ) {
if ( translators.empty() ) {
std::rethrow_exception( std::current_exception() );
} else {
return translators[0]->translate( translators.begin() + 1,
translators.end() );
}
}
}
ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
}
void ExceptionTranslatorRegistry::registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) {
m_translators.push_back( CATCH_MOVE( translator ) );
}
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
std::string ExceptionTranslatorRegistry::translateActiveException() const {
// Compiling a mixed mode project with MSVC means that CLR
// exceptions will be caught in (...) as well. However, these do
// do not fill-in std::current_exception and thus lead to crash
// when attempting rethrow.
// /EHa switch also causes structured exceptions to be caught
// here, but they fill-in current_exception properly, so
// at worst the output should be a little weird, instead of
// causing a crash.
if ( std::current_exception() == nullptr ) {
return "Non C++ exception. Possibly a CLR exception.";
}
// First we try user-registered translators. If none of them can
// handle the exception, it will be rethrown handled by our defaults.
try {
return tryTranslators(m_translators);
}
// To avoid having to handle TFE explicitly everywhere, we just
// rethrow it so that it goes back up the caller.
catch( TestFailureException& ) {
std::rethrow_exception(std::current_exception());
}
catch( TestSkipException& ) {
std::rethrow_exception(std::current_exception());
}
catch( std::exception const& ex ) {
return ex.what();
}
catch( std::string const& msg ) {
return msg;
}
catch( const char* msg ) {
return msg;
}
catch(...) {
return "Unknown exception";
}
}
#else // ^^ Exceptions are enabled // Exceptions are disabled vv
std::string ExceptionTranslatorRegistry::translateActiveException() const {
CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
}
#endif
}
/** \file
* This file provides platform specific implementations of FatalConditionHandler
*
* This means that there is a lot of conditional compilation, and platform
* specific code. Currently, Catch2 supports a dummy handler (if no
* handler is desired), and 2 platform specific handlers:
* * Windows' SEH
* * POSIX signals
*
* Consequently, various pieces of code below are compiled if either of
* the platform specific handlers is enabled, or if none of them are
* enabled. It is assumed that both cannot be enabled at the same time,
* and doing so should cause a compilation error.
*
* If another platform specific handler is added, the compile guards
* below will need to be updated taking these assumptions into account.
*/
#include <algorithm>
#if !defined( CATCH_CONFIG_WINDOWS_SEH ) && !defined( CATCH_CONFIG_POSIX_SIGNALS )
namespace Catch {
// If neither SEH nor signal handling is required, the handler impls
// do not have to do anything, and can be empty.
void FatalConditionHandler::engage_platform() {}
void FatalConditionHandler::disengage_platform() noexcept {}
FatalConditionHandler::FatalConditionHandler() = default;
FatalConditionHandler::~FatalConditionHandler() = default;
} // end namespace Catch
#endif // !CATCH_CONFIG_WINDOWS_SEH && !CATCH_CONFIG_POSIX_SIGNALS
#if defined( CATCH_CONFIG_WINDOWS_SEH ) && defined( CATCH_CONFIG_POSIX_SIGNALS )
#error "Inconsistent configuration: Windows' SEH handling and POSIX signals cannot be enabled at the same time"
#endif // CATCH_CONFIG_WINDOWS_SEH && CATCH_CONFIG_POSIX_SIGNALS
#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
namespace {
//! Signals fatal error message to the run context
void reportFatal( char const * const message ) {
Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
}
//! Minimal size Catch2 needs for its own fatal error handling.
//! Picked empirically, so it might not be sufficient on all
//! platforms, and for all configurations.
constexpr std::size_t minStackSizeForErrors = 32 * 1024;
} // end unnamed namespace
#endif // CATCH_CONFIG_WINDOWS_SEH || CATCH_CONFIG_POSIX_SIGNALS
#if defined( CATCH_CONFIG_WINDOWS_SEH )
namespace Catch {
struct SignalDefs { DWORD id; const char* name; };
// There is no 1-1 mapping between signals and windows exceptions.
// Windows can easily distinguish between SO and SigSegV,
// but SigInt, SigTerm, etc are handled differently.
static SignalDefs signalDefs[] = {
{ EXCEPTION_ILLEGAL_INSTRUCTION, "SIGILL - Illegal instruction signal" },
{ EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
{ EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
{ EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
};
static LONG CALLBACK topLevelExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) {
for (auto const& def : signalDefs) {
if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
reportFatal(def.name);
}
}
// If its not an exception we care about, pass it along.
// This stops us from eating debugger breaks etc.
return EXCEPTION_CONTINUE_SEARCH;
}
// Since we do not support multiple instantiations, we put these
// into global variables and rely on cleaning them up in outlined
// constructors/destructors
static LPTOP_LEVEL_EXCEPTION_FILTER previousTopLevelExceptionFilter = nullptr;
// For MSVC, we reserve part of the stack memory for handling
// memory overflow structured exception.
FatalConditionHandler::FatalConditionHandler() {
ULONG guaranteeSize = static_cast<ULONG>(minStackSizeForErrors);
if (!SetThreadStackGuarantee(&guaranteeSize)) {
// We do not want to fully error out, because needing
// the stack reserve should be rare enough anyway.
Catch::cerr()
<< "Failed to reserve piece of stack."
<< " Stack overflows will not be reported successfully.";
}
}
// We do not attempt to unset the stack guarantee, because
// Windows does not support lowering the stack size guarantee.
FatalConditionHandler::~FatalConditionHandler() = default;
void FatalConditionHandler::engage_platform() {
// Register as a the top level exception filter.
previousTopLevelExceptionFilter = SetUnhandledExceptionFilter(topLevelExceptionFilter);
}
void FatalConditionHandler::disengage_platform() noexcept {
if (SetUnhandledExceptionFilter(previousTopLevelExceptionFilter) != topLevelExceptionFilter) {
Catch::cerr()
<< "Unexpected SEH unhandled exception filter on disengage."
<< " The filter was restored, but might be rolled back unexpectedly.";
}
previousTopLevelExceptionFilter = nullptr;
}
} // end namespace Catch
#endif // CATCH_CONFIG_WINDOWS_SEH
#if defined( CATCH_CONFIG_POSIX_SIGNALS )
#include <signal.h>
namespace Catch {
struct SignalDefs {
int id;
const char* name;
};
static SignalDefs signalDefs[] = {
{ SIGINT, "SIGINT - Terminal interrupt signal" },
{ SIGILL, "SIGILL - Illegal instruction signal" },
{ SIGFPE, "SIGFPE - Floating point error signal" },
{ SIGSEGV, "SIGSEGV - Segmentation violation signal" },
{ SIGTERM, "SIGTERM - Termination request signal" },
{ SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
};
// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
// which is zero initialization, but not explicit. We want to avoid
// that.
#if defined(__GNUC__)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#endif
static char* altStackMem = nullptr;
static std::size_t altStackSize = 0;
static stack_t oldSigStack{};
static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]{};
static void restorePreviousSignalHandlers() noexcept {
// We set signal handlers back to the previous ones. Hopefully
// nobody overwrote them in the meantime, and doesn't expect
// their signal handlers to live past ours given that they
// installed them after ours..
for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
}
// Return the old stack
sigaltstack(&oldSigStack, nullptr);
}
static void handleSignal( int sig ) {
char const * name = "<unknown signal>";
for (auto const& def : signalDefs) {
if (sig == def.id) {
name = def.name;
break;
}
}
// We need to restore previous signal handlers and let them do
// their thing, so that the users can have the debugger break
// when a signal is raised, and so on.
restorePreviousSignalHandlers();
reportFatal( name );
raise( sig );
}
FatalConditionHandler::FatalConditionHandler() {
assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
if (altStackSize == 0) {
altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);
}
altStackMem = new char[altStackSize]();
}
FatalConditionHandler::~FatalConditionHandler() {
delete[] altStackMem;
// We signal that another instance can be constructed by zeroing
// out the pointer.
altStackMem = nullptr;
}
void FatalConditionHandler::engage_platform() {
stack_t sigStack;
sigStack.ss_sp = altStackMem;
sigStack.ss_size = altStackSize;
sigStack.ss_flags = 0;
sigaltstack(&sigStack, &oldSigStack);
struct sigaction sa = { };
sa.sa_handler = handleSignal;
sa.sa_flags = SA_ONSTACK;
for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
}
}
#if defined(__GNUC__)
# pragma GCC diagnostic pop
#endif
void FatalConditionHandler::disengage_platform() noexcept {
restorePreviousSignalHandlers();
}
} // end namespace Catch
#endif // CATCH_CONFIG_POSIX_SIGNALS
#include <cstring>
namespace Catch {
namespace Detail {
uint32_t convertToBits(float f) {
static_assert(sizeof(float) == sizeof(uint32_t), "Important ULP matcher assumption violated");
uint32_t i;
std::memcpy(&i, &f, sizeof(f));
return i;
}
uint64_t convertToBits(double d) {
static_assert(sizeof(double) == sizeof(uint64_t), "Important ULP matcher assumption violated");
uint64_t i;
std::memcpy(&i, &d, sizeof(d));
return i;
}
} // end namespace Detail
} // end namespace Catch
#include <cstdlib>
namespace Catch {
namespace Detail {
#if !defined (CATCH_CONFIG_GETENV)
char const* getEnv( char const* ) { return nullptr; }
#else
char const* getEnv( char const* varName ) {
# if defined( _MSC_VER )
# pragma warning( push )
# pragma warning( disable : 4996 ) // use getenv_s instead of getenv
# endif
return std::getenv( varName );
# if defined( _MSC_VER )
# pragma warning( pop )
# endif
}
#endif
} // namespace Detail
} // namespace Catch
#include <cstdio>
#include <fstream>
#include <sstream>
#include <vector>
namespace Catch {
Catch::IStream::~IStream() = default;
namespace Detail {
namespace {
template<typename WriterF, std::size_t bufferSize=256>
class StreamBufImpl final : public std::streambuf {
char data[bufferSize];
WriterF m_writer;
public:
StreamBufImpl() {
setp( data, data + sizeof(data) );
}
~StreamBufImpl() noexcept override {
StreamBufImpl::sync();
}
private:
int overflow( int c ) override {
sync();
if( c != EOF ) {
if( pbase() == epptr() )
m_writer( std::string( 1, static_cast<char>( c ) ) );
else
sputc( static_cast<char>( c ) );
}
return 0;
}
int sync() override {
if( pbase() != pptr() ) {
m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
setp( pbase(), epptr() );
}
return 0;
}
};
///////////////////////////////////////////////////////////////////////////
struct OutputDebugWriter {
void operator()( std::string const& str ) {
if ( !str.empty() ) {
writeToDebugConsole( str );
}
}
};
///////////////////////////////////////////////////////////////////////////
class FileStream final : public IStream {
std::ofstream m_ofs;
public:
FileStream( std::string const& filename ) {
m_ofs.open( filename.c_str() );
CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << '\'' );
m_ofs << std::unitbuf;
}
~FileStream() override = default;
public: // IStream
std::ostream& stream() override {
return m_ofs;
}
};
///////////////////////////////////////////////////////////////////////////
class CoutStream final : public IStream {
std::ostream m_os;
public:
// Store the streambuf from cout up-front because
// cout may get redirected when running tests
CoutStream() : m_os( Catch::cout().rdbuf() ) {}
~CoutStream() override = default;
public: // IStream
std::ostream& stream() override { return m_os; }
bool isConsole() const override { return true; }
};
class CerrStream : public IStream {
std::ostream m_os;
public:
// Store the streambuf from cerr up-front because
// cout may get redirected when running tests
CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
~CerrStream() override = default;
public: // IStream
std::ostream& stream() override { return m_os; }
bool isConsole() const override { return true; }
};
///////////////////////////////////////////////////////////////////////////
class DebugOutStream final : public IStream {
Detail::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
std::ostream m_os;
public:
DebugOutStream()
: m_streamBuf( Detail::make_unique<StreamBufImpl<OutputDebugWriter>>() ),
m_os( m_streamBuf.get() )
{}
~DebugOutStream() override = default;
public: // IStream
std::ostream& stream() override { return m_os; }
};
} // unnamed namespace
} // namespace Detail
///////////////////////////////////////////////////////////////////////////
auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream> {
if ( filename.empty() || filename == "-" ) {
return Detail::make_unique<Detail::CoutStream>();
}
if( filename[0] == '%' ) {
if ( filename == "%debug" ) {
return Detail::make_unique<Detail::DebugOutStream>();
} else if ( filename == "%stderr" ) {
return Detail::make_unique<Detail::CerrStream>();
} else if ( filename == "%stdout" ) {
return Detail::make_unique<Detail::CoutStream>();
} else {
CATCH_ERROR( "Unrecognised stream: '" << filename << '\'' );
}
}
return Detail::make_unique<Detail::FileStream>( filename );
}
}
namespace Catch {
auto operator << (std::ostream& os, LazyExpression const& lazyExpr) -> std::ostream& {
if (lazyExpr.m_isNegated)
os << '!';
if (lazyExpr) {
if (lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression())
os << '(' << *lazyExpr.m_transientExpression << ')';
else
os << *lazyExpr.m_transientExpression;
} else {
os << "{** error - unchecked empty expression requested **}";
}
return os;
}
} // namespace Catch
#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
#include <crtdbg.h>
namespace Catch {
LeakDetector::LeakDetector() {
int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
flag |= _CRTDBG_LEAK_CHECK_DF;
flag |= _CRTDBG_ALLOC_MEM_DF;
_CrtSetDbgFlag(flag);
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
// Change this to leaking allocation's number to break there
_CrtSetBreakAlloc(-1);
}
}
#else // ^^ Windows crt debug heap enabled // Windows crt debug heap disabled vv
Catch::LeakDetector::LeakDetector() {}
#endif // CATCH_CONFIG_WINDOWS_CRTDBG
Catch::LeakDetector::~LeakDetector() {
Catch::cleanUp();
}
namespace Catch {
namespace {
void listTests(IEventListener& reporter, IConfig const& config) {
auto const& testSpec = config.testSpec();
auto matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
reporter.listTests(matchedTestCases);
}
void listTags(IEventListener& reporter, IConfig const& config) {
auto const& testSpec = config.testSpec();
std::vector<TestCaseHandle> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
std::map<StringRef, TagInfo, Detail::CaseInsensitiveLess> tagCounts;
for (auto const& testCase : matchedTestCases) {
for (auto const& tagName : testCase.getTestCaseInfo().tags) {
auto it = tagCounts.find(tagName.original);
if (it == tagCounts.end())
it = tagCounts.insert(std::make_pair(tagName.original, TagInfo())).first;
it->second.add(tagName.original);
}
}
std::vector<TagInfo> infos; infos.reserve(tagCounts.size());
for (auto& tagc : tagCounts) {
infos.push_back(CATCH_MOVE(tagc.second));
}
reporter.listTags(infos);
}
void listReporters(IEventListener& reporter) {
std::vector<ReporterDescription> descriptions;
auto const& factories = getRegistryHub().getReporterRegistry().getFactories();
descriptions.reserve(factories.size());
for (auto const& fac : factories) {
descriptions.push_back({ fac.first, fac.second->getDescription() });
}
reporter.listReporters(descriptions);
}
void listListeners(IEventListener& reporter) {
std::vector<ListenerDescription> descriptions;
auto const& factories =
getRegistryHub().getReporterRegistry().getListeners();
descriptions.reserve( factories.size() );
for ( auto const& fac : factories ) {
descriptions.push_back( { fac->getName(), fac->getDescription() } );
}
reporter.listListeners( descriptions );
}
} // end anonymous namespace
void TagInfo::add( StringRef spelling ) {
++count;
spellings.insert( spelling );
}
std::string TagInfo::all() const {
// 2 per tag for brackets '[' and ']'
size_t size = spellings.size() * 2;
for (auto const& spelling : spellings) {
size += spelling.size();
}
std::string out; out.reserve(size);
for (auto const& spelling : spellings) {
out += '[';
out += spelling;
out += ']';
}
return out;
}
bool list( IEventListener& reporter, Config const& config ) {
bool listed = false;
if (config.listTests()) {
listed = true;
listTests(reporter, config);
}
if (config.listTags()) {
listed = true;
listTags(reporter, config);
}
if (config.listReporters()) {
listed = true;
listReporters(reporter);
}
if ( config.listListeners() ) {
listed = true;
listListeners( reporter );
}
return listed;
}
} // end namespace Catch
namespace Catch {
CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
static LeakDetector leakDetector;
CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
}
// Allow users of amalgamated .cpp file to remove our main and provide their own.
#if !defined(CATCH_AMALGAMATED_CUSTOM_MAIN)
#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
// Standard C/C++ Win32 Unicode wmain entry point
extern "C" int __cdecl wmain (int argc, wchar_t * argv[], wchar_t * []) {
#else
// Standard C/C++ main entry point
int main (int argc, char * argv[]) {
#endif
// We want to force the linker not to discard the global variable
// and its constructor, as it (optionally) registers leak detector
(void)&Catch::leakDetector;
return Catch::Session().run( argc, argv );
}
#endif // !defined(CATCH_AMALGAMATED_CUSTOM_MAIN
namespace Catch {
MessageInfo::MessageInfo( StringRef _macroName,
SourceLineInfo const& _lineInfo,
ResultWas::OfType _type )
: macroName( _macroName ),
lineInfo( _lineInfo ),
type( _type ),
sequence( ++globalCount )
{}
// This may need protecting if threading support is added
unsigned int MessageInfo::globalCount = 0;
} // end namespace Catch
#include <cstdio>
#include <cstring>
#include <sstream>
#if defined(CATCH_CONFIG_NEW_CAPTURE)
#if defined(_MSC_VER)
#include <io.h> //_dup and _dup2
#define dup _dup
#define dup2 _dup2
#define fileno _fileno
#else
#include <unistd.h> // dup and dup2
#endif
#endif
namespace Catch {
RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
: m_originalStream( originalStream ),
m_redirectionStream( redirectionStream ),
m_prevBuf( m_originalStream.rdbuf() )
{
m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
}
RedirectedStream::~RedirectedStream() {
m_originalStream.rdbuf( m_prevBuf );
}
RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
RedirectedStdErr::RedirectedStdErr()
: m_cerr( Catch::cerr(), m_rss.get() ),
m_clog( Catch::clog(), m_rss.get() )
{}
auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
: m_redirectedCout(redirectedCout),
m_redirectedCerr(redirectedCerr)
{}
RedirectedStreams::~RedirectedStreams() {
m_redirectedCout += m_redirectedStdOut.str();
m_redirectedCerr += m_redirectedStdErr.str();
}
#if defined(CATCH_CONFIG_NEW_CAPTURE)
#if defined(_MSC_VER)
TempFile::TempFile() {
if (tmpnam_s(m_buffer)) {
CATCH_RUNTIME_ERROR("Could not get a temp filename");
}
if (fopen_s(&m_file, m_buffer, "w+")) {
char buffer[100];
if (strerror_s(buffer, errno)) {
CATCH_RUNTIME_ERROR("Could not translate errno to a string");
}
CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
}
}
#else
TempFile::TempFile() {
m_file = std::tmpfile();
if (!m_file) {
CATCH_RUNTIME_ERROR("Could not create a temp file.");
}
}
#endif
TempFile::~TempFile() {
// TBD: What to do about errors here?
std::fclose(m_file);
// We manually create the file on Windows only, on Linux
// it will be autodeleted
#if defined(_MSC_VER)
std::remove(m_buffer);
#endif
}
FILE* TempFile::getFile() {
return m_file;
}
std::string TempFile::getContents() {
std::stringstream sstr;
char buffer[100] = {};
std::rewind(m_file);
while (std::fgets(buffer, sizeof(buffer), m_file)) {
sstr << buffer;
}
return sstr.str();
}
OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
m_originalStdout(dup(1)),
m_originalStderr(dup(2)),
m_stdoutDest(stdout_dest),
m_stderrDest(stderr_dest) {
dup2(fileno(m_stdoutFile.getFile()), 1);
dup2(fileno(m_stderrFile.getFile()), 2);
}
OutputRedirect::~OutputRedirect() {
Catch::cout() << std::flush;
fflush(stdout);
// Since we support overriding these streams, we flush cerr
// even though std::cerr is unbuffered
Catch::cerr() << std::flush;
Catch::clog() << std::flush;
fflush(stderr);
dup2(m_originalStdout, 1);
dup2(m_originalStderr, 2);
m_stdoutDest += m_stdoutFile.getContents();
m_stderrDest += m_stderrFile.getContents();
}
#endif // CATCH_CONFIG_NEW_CAPTURE
} // namespace Catch
#if defined(CATCH_CONFIG_NEW_CAPTURE)
#if defined(_MSC_VER)
#undef dup
#undef dup2
#undef fileno
#endif
#endif
#include <limits>
#include <stdexcept>
namespace Catch {
Optional<unsigned int> parseUInt(std::string const& input, int base) {
auto trimmed = trim( input );
// std::stoull is annoying and accepts numbers starting with '-',
// it just negates them into unsigned int
if ( trimmed.empty() || trimmed[0] == '-' ) {
return {};
}
CATCH_TRY {
size_t pos = 0;
const auto ret = std::stoull( trimmed, &pos, base );
// We did not consume the whole input, so there is an issue
// This can be bunch of different stuff, like multiple numbers
// in the input, or invalid digits/characters and so on. Either
// way, we do not want to return the partially parsed result.
if ( pos != trimmed.size() ) {
return {};
}
// Too large
if ( ret > std::numeric_limits<unsigned int>::max() ) {
return {};
}
return static_cast<unsigned int>(ret);
}
CATCH_CATCH_ANON( std::invalid_argument const& ) {
// no conversion could be performed
}
CATCH_CATCH_ANON( std::out_of_range const& ) {
// the input does not fit into an unsigned long long
}
return {};
}
} // namespace Catch
#include <cmath>
namespace Catch {
#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
bool isnan(float f) {
return std::isnan(f);
}
bool isnan(double d) {
return std::isnan(d);
}
#else
// For now we only use this for embarcadero
bool isnan(float f) {
return std::_isnan(f);
}
bool isnan(double d) {
return std::_isnan(d);
}
#endif
} // end namespace Catch
namespace Catch {
namespace {
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable:4146) // we negate uint32 during the rotate
#endif
// Safe rotr implementation thanks to John Regehr
uint32_t rotate_right(uint32_t val, uint32_t count) {
const uint32_t mask = 31;
count &= mask;
return (val >> count) | (val << (-count & mask));
}
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
}
SimplePcg32::SimplePcg32(result_type seed_) {
seed(seed_);
}
void SimplePcg32::seed(result_type seed_) {
m_state = 0;
(*this)();
m_state += seed_;
(*this)();
}
void SimplePcg32::discard(uint64_t skip) {
// We could implement this to run in O(log n) steps, but this
// should suffice for our use case.
for (uint64_t s = 0; s < skip; ++s) {
static_cast<void>((*this)());
}
}
SimplePcg32::result_type SimplePcg32::operator()() {
// prepare the output value
const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
const auto output = rotate_right(xorshifted, m_state >> 59u);
// advance state
m_state = m_state * 6364136223846793005ULL + s_inc;
return output;
}
bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
return lhs.m_state == rhs.m_state;
}
bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
return lhs.m_state != rhs.m_state;
}
}
#include <ctime>
#include <random>
namespace Catch {
std::uint32_t generateRandomSeed( GenerateFrom from ) {
switch ( from ) {
case GenerateFrom::Time:
return static_cast<std::uint32_t>( std::time( nullptr ) );
case GenerateFrom::Default:
case GenerateFrom::RandomDevice:
// In theory, a platform could have random_device that returns just
// 16 bits. That is still some randomness, so we don't care too much
return static_cast<std::uint32_t>( std::random_device{}() );
default:
CATCH_ERROR("Unknown generation method");
}
}
} // end namespace Catch
namespace Catch {
struct ReporterRegistry::ReporterRegistryImpl {
std::vector<Detail::unique_ptr<EventListenerFactory>> listeners;
std::map<std::string, IReporterFactoryPtr, Detail::CaseInsensitiveLess>
factories;
};
ReporterRegistry::ReporterRegistry():
m_impl( Detail::make_unique<ReporterRegistryImpl>() ) {
// Because it is impossible to move out of initializer list,
// we have to add the elements manually
m_impl->factories["Automake"] =
Detail::make_unique<ReporterFactory<AutomakeReporter>>();
m_impl->factories["compact"] =
Detail::make_unique<ReporterFactory<CompactReporter>>();
m_impl->factories["console"] =
Detail::make_unique<ReporterFactory<ConsoleReporter>>();
m_impl->factories["JUnit"] =
Detail::make_unique<ReporterFactory<JunitReporter>>();
m_impl->factories["SonarQube"] =
Detail::make_unique<ReporterFactory<SonarQubeReporter>>();
m_impl->factories["TAP"] =
Detail::make_unique<ReporterFactory<TAPReporter>>();
m_impl->factories["TeamCity"] =
Detail::make_unique<ReporterFactory<TeamCityReporter>>();
m_impl->factories["XML"] =
Detail::make_unique<ReporterFactory<XmlReporter>>();
}
ReporterRegistry::~ReporterRegistry() = default;
IEventListenerPtr
ReporterRegistry::create( std::string const& name,
ReporterConfig&& config ) const {
auto it = m_impl->factories.find( name );
if ( it == m_impl->factories.end() ) return nullptr;
return it->second->create( CATCH_MOVE( config ) );
}
void ReporterRegistry::registerReporter( std::string const& name,
IReporterFactoryPtr factory ) {
CATCH_ENFORCE( name.find( "::" ) == name.npos,
"'::' is not allowed in reporter name: '" + name +
'\'' );
auto ret = m_impl->factories.emplace( name, CATCH_MOVE( factory ) );
CATCH_ENFORCE( ret.second,
"reporter using '" + name +
"' as name was already registered" );
}
void ReporterRegistry::registerListener(
Detail::unique_ptr<EventListenerFactory> factory ) {
m_impl->listeners.push_back( CATCH_MOVE( factory ) );
}
std::map<std::string,
IReporterFactoryPtr,
Detail::CaseInsensitiveLess> const&
ReporterRegistry::getFactories() const {
return m_impl->factories;
}
std::vector<Detail::unique_ptr<EventListenerFactory>> const&
ReporterRegistry::getListeners() const {
return m_impl->listeners;
}
} // namespace Catch
#include <algorithm>
namespace Catch {
namespace {
struct kvPair {
StringRef key, value;
};
kvPair splitKVPair(StringRef kvString) {
auto splitPos = static_cast<size_t>(
std::find( kvString.begin(), kvString.end(), '=' ) -
kvString.begin() );
return { kvString.substr( 0, splitPos ),
kvString.substr( splitPos + 1, kvString.size() ) };
}
}
namespace Detail {
std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
static constexpr auto separator = "::";
static constexpr size_t separatorSize = 2;
size_t separatorPos = 0;
auto findNextSeparator = [&reporterSpec]( size_t startPos ) {
static_assert(
separatorSize == 2,
"The code below currently assumes 2 char separator" );
auto currentPos = startPos;
do {
while ( currentPos < reporterSpec.size() &&
reporterSpec[currentPos] != separator[0] ) {
++currentPos;
}
if ( currentPos + 1 < reporterSpec.size() &&
reporterSpec[currentPos + 1] == separator[1] ) {
return currentPos;
}
++currentPos;
} while ( currentPos < reporterSpec.size() );
return static_cast<size_t>( -1 );
};
std::vector<std::string> parts;
while ( separatorPos < reporterSpec.size() ) {
const auto nextSeparator = findNextSeparator( separatorPos );
parts.push_back( static_cast<std::string>( reporterSpec.substr(
separatorPos, nextSeparator - separatorPos ) ) );
if ( nextSeparator == static_cast<size_t>( -1 ) ) {
break;
}
separatorPos = nextSeparator + separatorSize;
}
// Handle a separator at the end.
// This is not a valid spec, but we want to do validation in a
// centralized place
if ( separatorPos == reporterSpec.size() ) {
parts.emplace_back();
}
return parts;
}
Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
if ( colourMode == "default" ) {
return ColourMode::PlatformDefault;
} else if ( colourMode == "ansi" ) {
return ColourMode::ANSI;
} else if ( colourMode == "win32" ) {
return ColourMode::Win32;
} else if ( colourMode == "none" ) {
return ColourMode::None;
} else {
return {};
}
}
} // namespace Detail
bool operator==( ReporterSpec const& lhs, ReporterSpec const& rhs ) {
return lhs.m_name == rhs.m_name &&
lhs.m_outputFileName == rhs.m_outputFileName &&
lhs.m_colourMode == rhs.m_colourMode &&
lhs.m_customOptions == rhs.m_customOptions;
}
Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec ) {
auto parts = Detail::splitReporterSpec( reporterSpec );
assert( parts.size() > 0 && "Split should never return empty vector" );
std::map<std::string, std::string> kvPairs;
Optional<std::string> outputFileName;
Optional<ColourMode> colourMode;
// First part is always reporter name, so we skip it
for ( size_t i = 1; i < parts.size(); ++i ) {
auto kv = splitKVPair( parts[i] );
auto key = kv.key, value = kv.value;
if ( key.empty() || value.empty() ) {
return {};
} else if ( key[0] == 'X' ) {
// This is a reporter-specific option, we don't check these
// apart from basic sanity checks
if ( key.size() == 1 ) {
return {};
}
auto ret = kvPairs.emplace( std::string(kv.key), std::string(kv.value) );
if ( !ret.second ) {
// Duplicated key. We might want to handle this differently,
// e.g. by overwriting the existing value?
return {};
}
} else if ( key == "out" ) {
// Duplicated key
if ( outputFileName ) {
return {};
}
outputFileName = static_cast<std::string>( value );
} else if ( key == "colour-mode" ) {
// Duplicated key
if ( colourMode ) {
return {};
}
colourMode = Detail::stringToColourMode( value );
// Parsing failed
if ( !colourMode ) {
return {};
}
} else {
// Unrecognized option
return {};
}
}
return ReporterSpec{ CATCH_MOVE( parts[0] ),
CATCH_MOVE( outputFileName ),
CATCH_MOVE( colourMode ),
CATCH_MOVE( kvPairs ) };
}
ReporterSpec::ReporterSpec(
std::string name,
Optional<std::string> outputFileName,
Optional<ColourMode> colourMode,
std::map<std::string, std::string> customOptions ):
m_name( CATCH_MOVE( name ) ),
m_outputFileName( CATCH_MOVE( outputFileName ) ),
m_colourMode( CATCH_MOVE( colourMode ) ),
m_customOptions( CATCH_MOVE( customOptions ) ) {}
} // namespace Catch
namespace Catch {
bool isOk( ResultWas::OfType resultType ) {
return ( resultType & ResultWas::FailureBit ) == 0;
}
bool isJustInfo( int flags ) {
return flags == ResultWas::Info;
}
ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
}
bool shouldContinueOnFailure( int flags ) { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
bool shouldSuppressFailure( int flags ) { return ( flags & ResultDisposition::SuppressFail ) != 0; }
} // end namespace Catch
#include <cstdio>
#include <sstream>
#include <vector>
namespace Catch {
// This class encapsulates the idea of a pool of ostringstreams that can be reused.
struct StringStreams {
std::vector<Detail::unique_ptr<std::ostringstream>> m_streams;
std::vector<std::size_t> m_unused;
std::ostringstream m_referenceStream; // Used for copy state/ flags from
auto add() -> std::size_t {
if( m_unused.empty() ) {
m_streams.push_back( Detail::make_unique<std::ostringstream>() );
return m_streams.size()-1;
}
else {
auto index = m_unused.back();
m_unused.pop_back();
return index;
}
}
void release( std::size_t index ) {
m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
m_unused.push_back(index);
}
};
ReusableStringStream::ReusableStringStream()
: m_index( Singleton<StringStreams>::getMutable().add() ),
m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
{}
ReusableStringStream::~ReusableStringStream() {
static_cast<std::ostringstream*>( m_oss )->str("");
m_oss->clear();
Singleton<StringStreams>::getMutable().release( m_index );
}
std::string ReusableStringStream::str() const {
return static_cast<std::ostringstream*>( m_oss )->str();
}
void ReusableStringStream::str( std::string const& str ) {
static_cast<std::ostringstream*>( m_oss )->str( str );
}
}
#include <cassert>
#include <algorithm>
namespace Catch {
namespace Generators {
namespace {
struct GeneratorTracker final : TestCaseTracking::TrackerBase,
IGeneratorTracker {
GeneratorBasePtr m_generator;
GeneratorTracker(
TestCaseTracking::NameAndLocation&& nameAndLocation,
TrackerContext& ctx,
ITracker* parent ):
TrackerBase( CATCH_MOVE( nameAndLocation ), ctx, parent ) {}
~GeneratorTracker() override = default;
static GeneratorTracker*
acquire( TrackerContext& ctx,
TestCaseTracking::NameAndLocationRef const&
nameAndLocation ) {
GeneratorTracker* tracker;
ITracker& currentTracker = ctx.currentTracker();
// Under specific circumstances, the generator we want
// to acquire is also the current tracker. If this is
// the case, we have to avoid looking through current
// tracker's children, and instead return the current
// tracker.
// A case where this check is important is e.g.
// for (int i = 0; i < 5; ++i) {
// int n = GENERATE(1, 2);
// }
//
// without it, the code above creates 5 nested generators.
if ( currentTracker.nameAndLocation() == nameAndLocation ) {
auto thisTracker = currentTracker.parent()->findChild(
nameAndLocation );
assert( thisTracker );
assert( thisTracker->isGeneratorTracker() );
tracker = static_cast<GeneratorTracker*>( thisTracker );
} else if ( ITracker* childTracker =
currentTracker.findChild(
nameAndLocation ) ) {
assert( childTracker );
assert( childTracker->isGeneratorTracker() );
tracker =
static_cast<GeneratorTracker*>( childTracker );
} else {
return nullptr;
}
if ( !tracker->isComplete() ) { tracker->open(); }
return tracker;
}
// TrackerBase interface
bool isGeneratorTracker() const override { return true; }
auto hasGenerator() const -> bool override {
return !!m_generator;
}
void close() override {
TrackerBase::close();
// If a generator has a child (it is followed by a section)
// and none of its children have started, then we must wait
// until later to start consuming its values.
// This catches cases where `GENERATE` is placed between two
// `SECTION`s.
// **The check for m_children.empty cannot be removed**.
// doing so would break `GENERATE` _not_ followed by
// `SECTION`s.
const bool should_wait_for_child = [&]() {
// No children -> nobody to wait for
if ( m_children.empty() ) { return false; }
// If at least one child started executing, don't wait
if ( std::find_if(
m_children.begin(),
m_children.end(),
[]( TestCaseTracking::ITrackerPtr const&
tracker ) {
return tracker->hasStarted();
} ) != m_children.end() ) {
return false;
}
// No children have started. We need to check if they
// _can_ start, and thus we should wait for them, or
// they cannot start (due to filters), and we shouldn't
// wait for them
ITracker* parent = m_parent;
// This is safe: there is always at least one section
// tracker in a test case tracking tree
while ( !parent->isSectionTracker() ) {
parent = parent->parent();
}
assert( parent &&
"Missing root (test case) level section" );
auto const& parentSection =
static_cast<SectionTracker const&>( *parent );
auto const& filters = parentSection.getFilters();
// No filters -> no restrictions on running sections
if ( filters.empty() ) { return true; }
for ( auto const& child : m_children ) {
if ( child->isSectionTracker() &&
std::find( filters.begin(),
filters.end(),
static_cast<SectionTracker const&>(
*child )
.trimmedName() ) !=
filters.end() ) {
return true;
}
}
return false;
}();
// This check is a bit tricky, because m_generator->next()
// has a side-effect, where it consumes generator's current
// value, but we do not want to invoke the side-effect if
// this generator is still waiting for any child to start.
assert( m_generator && "Tracker without generator" );
if ( should_wait_for_child ||
( m_runState == CompletedSuccessfully &&
m_generator->countedNext() ) ) {
m_children.clear();
m_runState = Executing;
}
}
// IGeneratorTracker interface
auto getGenerator() const -> GeneratorBasePtr const& override {
return m_generator;
}
void setGenerator( GeneratorBasePtr&& generator ) override {
m_generator = CATCH_MOVE( generator );
}
};
} // namespace
}
RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter)
: m_runInfo(_config->name()),
m_config(_config),
m_reporter(CATCH_MOVE(reporter)),
m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
{
getCurrentMutableContext().setResultCapture( this );
m_reporter->testRunStarting(m_runInfo);
}
RunContext::~RunContext() {
m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
}
Totals RunContext::runTest(TestCaseHandle const& testCase) {
const Totals prevTotals = m_totals;
auto const& testInfo = testCase.getTestCaseInfo();
m_reporter->testCaseStarting(testInfo);
m_activeTestCase = &testCase;
ITracker& rootTracker = m_trackerContext.startRun();
assert(rootTracker.isSectionTracker());
static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
// We intentionally only seed the internal RNG once per test case,
// before it is first invoked. The reason for that is a complex
// interplay of generator/section implementation details and the
// Random*Generator types.
//
// The issue boils down to us needing to seed the Random*Generators
// with different seed each, so that they return different sequences
// of random numbers. We do this by giving them a number from the
// shared RNG instance as their seed.
//
// However, this runs into an issue if the reseeding happens each
// time the test case is entered (as opposed to first time only),
// because multiple generators could get the same seed, e.g. in
// ```cpp
// TEST_CASE() {
// auto i = GENERATE(take(10, random(0, 100));
// SECTION("A") {
// auto j = GENERATE(take(10, random(0, 100));
// }
// SECTION("B") {
// auto k = GENERATE(take(10, random(0, 100));
// }
// }
// ```
// `i` and `j` would properly return values from different sequences,
// but `i` and `k` would return the same sequence, because their seed
// would be the same.
// (The reason their seeds would be the same is that the generator
// for k would be initialized when the test case is entered the second
// time, after the shared RNG instance was reset to the same value
// it had when the generator for i was initialized.)
seedRng( *m_config );
uint64_t testRuns = 0;
std::string redirectedCout;
std::string redirectedCerr;
do {
m_trackerContext.startCycle();
m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocationRef(testInfo.name, testInfo.lineInfo));
m_reporter->testCasePartialStarting(testInfo, testRuns);
const auto beforeRunTotals = m_totals;
std::string oneRunCout, oneRunCerr;
runCurrentTest(oneRunCout, oneRunCerr);
redirectedCout += oneRunCout;
redirectedCerr += oneRunCerr;
const auto singleRunTotals = m_totals.delta(beforeRunTotals);
auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, CATCH_MOVE(oneRunCout), CATCH_MOVE(oneRunCerr), aborting());
m_reporter->testCasePartialEnded(statsForOneRun, testRuns);
++testRuns;
} while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
Totals deltaTotals = m_totals.delta(prevTotals);
if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
deltaTotals.assertions.failed++;
deltaTotals.testCases.passed--;
deltaTotals.testCases.failed++;
}
m_totals.testCases += deltaTotals.testCases;
m_reporter->testCaseEnded(TestCaseStats(testInfo,
deltaTotals,
CATCH_MOVE(redirectedCout),
CATCH_MOVE(redirectedCerr),
aborting()));
m_activeTestCase = nullptr;
m_testCaseTracker = nullptr;
return deltaTotals;
}
void RunContext::assertionEnded(AssertionResult&& result) {
if (result.getResultType() == ResultWas::Ok) {
m_totals.assertions.passed++;
m_lastAssertionPassed = true;
} else if (result.getResultType() == ResultWas::ExplicitSkip) {
m_totals.assertions.skipped++;
m_lastAssertionPassed = true;
} else if (!result.succeeded()) {
m_lastAssertionPass
gitextract_w1n33c92/ ├── .editorconfig ├── .github/ │ ├── FUNDING.yml │ └── workflows/ │ └── ci.yml ├── .gitignore ├── CMakeLists.txt ├── README.md ├── catch2/ │ ├── catch_amalgamated.cpp │ └── catch_amalgamated.hpp ├── include/ │ └── tortellini.hh └── test.cc
Copy disabled (too large)
Download .txt
Showing preview only (305,352K chars total). Download the full file to get everything.
SYMBOL INDEX (1853 symbols across 4 files)
FILE: catch2/catch_amalgamated.cpp
type Catch (line 42) | namespace Catch {
type Benchmark (line 43) | namespace Benchmark {
type Detail (line 44) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 55) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 68) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 102) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 269) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Benchmark (line 54) | namespace Benchmark {
type Detail (line 44) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 55) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 68) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 102) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 269) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Benchmark (line 67) | namespace Benchmark {
type Detail (line 44) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 55) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 68) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 102) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 269) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Benchmark (line 101) | namespace Benchmark {
type Detail (line 44) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 55) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 68) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 102) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 269) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Benchmark (line 268) | namespace Benchmark {
type Detail (line 44) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 55) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 68) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 102) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 269) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
function Approx (line 432) | Approx Approx::custom() {
function Approx (line 436) | Approx Approx::operator-() const {
type literals (line 470) | namespace literals {
function Approx (line 471) | Approx operator "" _a(long double val) {
function Approx (line 474) | Approx operator "" _a(unsigned long long val) {
function StringRef (line 569) | StringRef AssertionResult::getMessage() const {
function SourceLineInfo (line 572) | SourceLineInfo AssertionResult::getSourceInfo() const {
function StringRef (line 576) | StringRef AssertionResult::getTestMacroName() const {
function getSeed (line 819) | std::uint32_t getSeed() {
class RegistryHub (line 939) | class RegistryHub : public IRegistryHub,
method RegistryHub (line 944) | RegistryHub() = default;
method ReporterRegistry (line 945) | ReporterRegistry const& getReporterRegistry() const override {
method ITestCaseRegistry (line 948) | ITestCaseRegistry const& getTestCaseRegistry() const override {
method IExceptionTranslatorRegistry (line 951) | IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry()...
method ITagAliasRegistry (line 954) | ITagAliasRegistry const& getTagAliasRegistry() const override {
method StartupExceptionRegistry (line 957) | StartupExceptionRegistry const& getStartupExceptionRegistry() const ...
method registerReporter (line 962) | void registerReporter( std::string const& name, IReporterFactoryPtr ...
method registerListener (line 965) | void registerListener( Detail::unique_ptr<EventListenerFactory> fact...
method registerTest (line 968) | void registerTest( Detail::unique_ptr<TestCaseInfo>&& testInfo, Deta...
method registerTranslator (line 971) | void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& ...
method registerTagAlias (line 974) | void registerTagAlias( std::string const& alias, std::string const& ...
method registerStartupException (line 977) | void registerStartupException() noexcept override {
method IMutableEnumValuesRegistry (line 984) | IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
function IRegistryHub (line 1000) | IRegistryHub const& getRegistryHub() {
function IMutableRegistryHub (line 1003) | IMutableRegistryHub& getMutableRegistryHub() {
function cleanUp (line 1006) | void cleanUp() {
function translateActiveException (line 1010) | std::string translateActiveException() {
function IEventListenerPtr (line 1030) | IEventListenerPtr createReporter(std::string const& reporterName, Repo...
function IEventListenerPtr (line 1037) | IEventListenerPtr prepareReporters(Config const* config) {
class TestGroup (line 1068) | class TestGroup {
method TestGroup (line 1070) | explicit TestGroup(IEventListenerPtr&& reporter, Config const* config):
method Totals (line 1098) | Totals execute() {
method hadUnmatchedTestSpecs (line 1117) | bool hadUnmatchedTestSpecs() const {
function applyFilenamesAsTags (line 1131) | void applyFilenamesAsTags() {
function TestCaseProperties (line 1386) | TestCaseProperties operator|(TestCaseProperties lhs, TestCasePropertie...
function TestCaseProperties (line 1392) | TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProper...
function TestCaseProperties (line 1399) | TestCaseProperties operator&(TestCaseProperties lhs, TestCasePropertie...
function applies (line 1405) | bool applies(TestCaseProperties tcp) {
function TestCaseProperties (line 1411) | TestCaseProperties parseSpecialTag( StringRef tag ) {
function isReservedTag (line 1427) | bool isReservedTag( StringRef tag ) {
function enforceNotReservedTag (line 1432) | void enforceNotReservedTag( StringRef tag, SourceLineInfo const& _line...
function makeDefaultName (line 1439) | std::string makeDefaultName() {
function StringRef (line 1444) | StringRef extractFilenamePart(StringRef filename) {
function sizeOfExtraTags (line 1460) | size_t sizeOfExtraTags(StringRef filepath) {
function makeTestCaseInfo (line 1476) | Detail::unique_ptr<TestCaseInfo>
function TestCaseInfo (line 1621) | TestCaseInfo const& TestCaseHandle::getTestCaseInfo() const {
function getCurrentNanosecondsSinceEpoch (line 1764) | static auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
type Detail (line 1796) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
function Counts (line 2037) | Counts Counts::operator - ( Counts const& other ) const {
function Counts (line 2046) | Counts& Counts::operator += ( Counts const& other ) {
function Totals (line 2064) | Totals Totals::operator - ( Totals const& other ) const {
function Totals (line 2071) | Totals& Totals::operator += ( Totals const& other ) {
function Totals (line 2077) | Totals Totals::delta( Totals const& prevTotals ) const {
type Detail (line 2096) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
function Version (line 2135) | Version const& libraryVersion() {
type Generators (line 2160) | namespace Generators {
type Detail (line 2162) | namespace Detail {
function throw_generator_exception (line 2164) | [[noreturn]]
function IGeneratorTracker (line 2172) | IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, ...
function IGeneratorTracker (line 2176) | IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
function StringRef (line 2230) | StringRef GeneratorUntypedBase::currentElementAsString() const {
type GeneratorTracker (line 5092) | struct GeneratorTracker final : TestCaseTracking::TrackerBase,
method GeneratorTracker (line 5096) | GeneratorTracker(
method GeneratorTracker (line 5103) | static GeneratorTracker*
method isGeneratorTracker (line 5144) | bool isGeneratorTracker() const override { return true; }
method hasGenerator (line 5145) | auto hasGenerator() const -> bool override {
method close (line 5148) | void close() override {
method getGenerator (line 5219) | auto getGenerator() const -> GeneratorBasePtr const& override {
method setGenerator (line 5222) | void setGenerator( GeneratorBasePtr&& generator ) override {
type Generators (line 2219) | namespace Generators {
type Detail (line 2162) | namespace Detail {
function throw_generator_exception (line 2164) | [[noreturn]]
function IGeneratorTracker (line 2172) | IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, ...
function IGeneratorTracker (line 2176) | IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
function StringRef (line 2230) | StringRef GeneratorUntypedBase::currentElementAsString() const {
type GeneratorTracker (line 5092) | struct GeneratorTracker final : TestCaseTracking::TrackerBase,
method GeneratorTracker (line 5096) | GeneratorTracker(
method GeneratorTracker (line 5103) | static GeneratorTracker*
method isGeneratorTracker (line 5144) | bool isGeneratorTracker() const override { return true; }
method hasGenerator (line 5145) | auto hasGenerator() const -> bool override {
method close (line 5148) | void close() override {
method getGenerator (line 5219) | auto getGenerator() const -> GeneratorBasePtr const& override {
method setGenerator (line 5222) | void setGenerator( GeneratorBasePtr&& generator ) override {
function IConfig (line 2270) | IConfig const * ReporterConfig::fullConfig() const { return m_fullConf...
function ColourMode (line 2271) | ColourMode ReporterConfig::colourMode() const { return m_colourMode; }
function handleExceptionMatchExpr (line 2413) | void handleExceptionMatchExpr( AssertionHandler& handler, std::string ...
type Detail (line 2425) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
type Clara (line 2474) | namespace Clara {
type Detail (line 2475) | namespace Detail {
function TokenStream (line 2524) | TokenStream& TokenStream::operator++() {
function ParserResult (line 2535) | ParserResult convertInto( std::string const& source,
function ParserResult (line 2541) | ParserResult convertInto( std::string const& source,
function InternalParseResult (line 2561) | InternalParseResult ParserBase::parse( Args const& args ) const {
function ParserResult (line 2569) | ParserResult BoundFlagRef::setFlag( bool flag ) {
function ParserResult (line 2721) | ParserResult ExeName::set(std::string const& newName) {
function Parser (line 2737) | Parser& Parser::operator|=( Parser const& other ) {
type ParserInfo (line 2817) | struct ParserInfo {
function makeCommandLineParser (line 2893) | Clara::Parser makeCommandLineParser( ConfigData& config ) {
class NoColourImpl (line 3255) | class NoColourImpl final : public ColourImpl {
method NoColourImpl (line 3257) | NoColourImpl( IStream* stream ): ColourImpl( stream ) {}
method use (line 3260) | void use( Colour::Code ) const override {}
class Win32ColourImpl (line 3273) | class Win32ColourImpl final : public ColourImpl {
method Win32ColourImpl (line 3275) | Win32ColourImpl(IStream* stream):
method useImplementationForStream (line 3284) | static bool useImplementationForStream(IStream const& stream) {
method use (line 3292) | void use( Colour::Code _colourCode ) const override {
method setTextAttribute (line 3316) | void setTextAttribute( WORD _textAttribute ) const {
class ANSIColourImpl (line 3339) | class ANSIColourImpl final : public ColourImpl {
method ANSIColourImpl (line 3341) | ANSIColourImpl( IStream* stream ): ColourImpl( stream ) {}
method useImplementationForStream (line 3343) | static bool useImplementationForStream(IStream const& stream) {
method use (line 3365) | void use( Colour::Code _colourCode ) const override {
function makeColourImpl (line 3400) | Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode implSelection,
function isColourImplAvailable (line 3429) | bool isColourImplAvailable( ColourMode colourSelection ) {
function cleanUpContext (line 3457) | void cleanUpContext() {
function Context (line 3465) | Context& getCurrentMutableContext() {
function SimplePcg32 (line 3477) | SimplePcg32& sharedRng() {
function writeToDebugConsole (line 3494) | void writeToDebugConsole( std::string const& text ) {
function writeToDebugConsole (line 3502) | void writeToDebugConsole( std::string const& text ) {
function writeToDebugConsole (line 3510) | void writeToDebugConsole( std::string const& text ) {
function isDebuggerActive (line 3541) | bool isDebuggerActive(){
function isDebuggerActive (line 3572) | bool isDebuggerActive() {
function isDebuggerActive (line 3591) | bool isDebuggerActive(){
function isDebuggerActive (line 3612) | bool isDebuggerActive() {
function isDebuggerActive (line 3619) | bool isDebuggerActive() {
function isDebuggerActive (line 3625) | bool isDebuggerActive() { return false; }
function formatReconstructedExpression (line 3636) | void formatReconstructedExpression( std::ostream &os, std::string cons...
function throw_exception (line 3653) | [[noreturn]]
function throw_logic_error (line 3661) | [[noreturn]]
function throw_domain_error (line 3666) | [[noreturn]]
function throw_runtime_error (line 3671) | [[noreturn]]
type Detail (line 3688) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
function tryTranslators (line 3763) | static std::string tryTranslators(
type SignalDefs (line 3895) | struct SignalDefs { DWORD id; const char* name; }
function LONG (line 3907) | static LONG CALLBACK topLevelExceptionFilter(PEXCEPTION_POINTERS Excep...
type SignalDefs (line 3966) | struct SignalDefs {
type sigaction (line 3991) | struct sigaction
function restorePreviousSignalHandlers (line 3993) | static void restorePreviousSignalHandlers() noexcept {
function handleSignal (line 4005) | static void handleSignal( int sig ) {
type sigaction (line 4042) | struct sigaction
type Detail (line 4070) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
type Detail (line 4097) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
type Detail (line 4131) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
function makeStream (line 4248) | auto makeStream( std::string const& filename ) -> Detail::unique_ptr<I...
function listTests (line 4327) | void listTests(IEventListener& reporter, IConfig const& config) {
function listTags (line 4333) | void listTags(IEventListener& reporter, IConfig const& config) {
function listReporters (line 4355) | void listReporters(IEventListener& reporter) {
function listListeners (line 4367) | void listListeners(IEventListener& reporter) {
function list (line 4403) | bool list( IEventListener& reporter, Config const& config ) {
function isnan (line 4664) | bool isnan(float f) {
function isnan (line 4667) | bool isnan(double d) {
function isnan (line 4672) | bool isnan(float f) {
function isnan (line 4675) | bool isnan(double d) {
function rotate_right (line 4693) | uint32_t rotate_right(uint32_t val, uint32_t count) {
function generateRandomSeed (line 4755) | std::uint32_t generateRandomSeed( GenerateFrom from ) {
type ReporterRegistry::ReporterRegistryImpl (line 4777) | struct ReporterRegistry::ReporterRegistryImpl {
function IEventListenerPtr (line 4807) | IEventListenerPtr
type kvPair (line 4852) | struct kvPair {
function kvPair (line 4856) | kvPair splitKVPair(StringRef kvString) {
type Detail (line 4866) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
function parseReporterSpec (line 4939) | Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec ) {
function isOk (line 5012) | bool isOk( ResultWas::OfType resultType ) {
function isJustInfo (line 5015) | bool isJustInfo( int flags ) {
function shouldContinueOnFailure (line 5023) | bool shouldContinueOnFailure( int flags ) { return ( flags & Result...
function shouldSuppressFailure (line 5024) | bool shouldSuppressFailure( int flags ) { return ( flags & Result...
type StringStreams (line 5037) | struct StringStreams {
method add (line 5042) | auto add() -> std::size_t {
method release (line 5054) | void release( std::size_t index ) {
type Generators (line 5090) | namespace Generators {
type Detail (line 2162) | namespace Detail {
function throw_generator_exception (line 2164) | [[noreturn]]
function IGeneratorTracker (line 2172) | IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, ...
function IGeneratorTracker (line 2176) | IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
function StringRef (line 2230) | StringRef GeneratorUntypedBase::currentElementAsString() const {
type GeneratorTracker (line 5092) | struct GeneratorTracker final : TestCaseTracking::TrackerBase,
method GeneratorTracker (line 5096) | GeneratorTracker(
method GeneratorTracker (line 5103) | static GeneratorTracker*
method isGeneratorTracker (line 5144) | bool isGeneratorTracker() const override { return true; }
method hasGenerator (line 5145) | auto hasGenerator() const -> bool override {
method close (line 5148) | void close() override {
method getGenerator (line 5219) | auto getGenerator() const -> GeneratorBasePtr const& override {
method setGenerator (line 5222) | void setGenerator( GeneratorBasePtr&& generator ) override {
function Totals (line 5244) | Totals RunContext::runTest(TestCaseHandle const& testCase) {
function IGeneratorTracker (line 5391) | IGeneratorTracker*
function IGeneratorTracker (line 5403) | IGeneratorTracker* RunContext::createGeneratorTracker(
function AssertionResult (line 5492) | const AssertionResult * RunContext::getLastResult() const {
function getSingletons (line 5814) | static auto getSingletons() -> std::vector<ISingleton*>*& {
function addSingleton (line 5824) | void addSingleton(ISingleton* singleton ) {
function cleanupSingletons (line 5827) | void cleanupSingletons() {
function startsWith (line 5911) | bool startsWith( std::string const& s, std::string const& prefix ) {
function startsWith (line 5914) | bool startsWith( StringRef s, char prefix ) {
function endsWith (line 5917) | bool endsWith( std::string const& s, std::string const& suffix ) {
function endsWith (line 5920) | bool endsWith( std::string const& s, char suffix ) {
function contains (line 5923) | bool contains( std::string const& s, std::string const& infix ) {
function toLowerInPlace (line 5926) | void toLowerInPlace( std::string& s ) {
function toLower (line 5931) | std::string toLower( std::string const& s ) {
function toLower (line 5936) | char toLower(char c) {
function trim (line 5940) | std::string trim( std::string const& str ) {
function StringRef (line 5948) | StringRef trim(StringRef ref) {
function replaceInPlace (line 5960) | bool replaceInPlace( std::string& str, std::string const& replaceThis,...
function splitStringRef (line 5974) | std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
function TagAlias (line 6064) | TagAlias const* TagAliasRegistry::find( std::string const& alias ) con...
function ITagAliasRegistry (line 6097) | ITagAliasRegistry const& ITagAliasRegistry::get() {
function enforceNoDuplicateTestCases (line 6144) | static void enforceNoDuplicateTestCases(
function matchTest (line 6166) | static bool matchTest( TestCaseHandle const& testCase,
function sortTests (line 6175) | std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vec...
function isThrowSafe (line 6227) | bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& confi...
function filterTests (line 6231) | std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> c...
type TestCaseTracking (line 6285) | namespace TestCaseTracking {
function ITracker (line 6303) | ITracker* ITracker::findChild( NameAndLocationRef const& nameAndLoca...
function ITracker (line 6336) | ITracker& TrackerContext::startRun() {
function SectionTracker (line 6447) | SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAn...
function StringRef (line 6491) | StringRef SectionTracker::trimmedName() const {
function throw_test_failure_exception (line 6508) | void throw_test_failure_exception() {
function throw_test_skip_exception (line 6516) | void throw_test_skip_exception() {
function StringRef (line 6535) | static StringRef extractClassName( StringRef classOrMethodName ) {
class TestInvokerAsFunction (line 6563) | class TestInvokerAsFunction final : public ITestInvoker {
method TestInvokerAsFunction (line 6568) | TestInvokerAsFunction( TestType testAsFunction ) noexcept:
method invoke (line 6571) | void invoke() const override { m_testAsFunction(); }
function makeTestInvoker (line 6576) | Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction...
function TestSpecParser (line 6605) | TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
function TestSpec (line 6623) | TestSpec TestSpecParser::testSpec() {
type TextFlow (line 6861) | namespace TextFlow {
function Column (line 6981) | Column Spacer( size_t spaceWidth ) {
function Columns (line 7055) | Columns Column::operator+( Column const& other ) {
function Columns (line 7062) | Columns& Columns::operator+=( Column const& col ) {
function Columns (line 7067) | Columns Columns::operator+( Column const& col ) {
function uncaught_exceptions (line 7082) | bool uncaught_exceptions() {
function trailingBytes (line 7145) | size_t trailingBytes(unsigned char c) {
function headerValue (line 7158) | uint32_t headerValue(unsigned char c) {
function hexEscapeChar (line 7171) | void hexEscapeChar(std::ostream& os, unsigned char c) {
function shouldNewline (line 7179) | bool shouldNewline(XmlFormatting fmt) {
function shouldIndent (line 7183) | bool shouldIndent(XmlFormatting fmt) {
function XmlFormatting (line 7189) | XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
function XmlFormatting (line 7196) | XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
function XmlWriter (line 7364) | XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormat...
function XmlWriter (line 7384) | XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
function XmlWriter (line 7403) | XmlWriter& XmlWriter::writeAttribute( StringRef name,
function XmlWriter (line 7410) | XmlWriter& XmlWriter::writeAttribute( StringRef name, bool attribute ) {
function XmlWriter (line 7415) | XmlWriter& XmlWriter::writeAttribute( StringRef name,
function XmlWriter (line 7421) | XmlWriter& XmlWriter::writeText( StringRef text, XmlFormatting fmt ) {
function XmlWriter (line 7435) | XmlWriter& XmlWriter::writeComment( StringRef text, XmlFormatting fmt ) {
type Matchers (line 7478) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
type Matchers (line 7496) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
type Matchers (line 7522) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function almostEqualUlps (line 7554) | bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
function nextafter (line 7569) | float nextafter(float x, float y) {
function nextafter (line 7573) | double nextafter(double x, double y) {
function FP (line 7580) | FP step(FP start, FP direction, uint64_t steps) {
function marginComparison (line 7593) | bool marginComparison(double lhs, double rhs, double margin) {
function write (line 7598) | void write(std::ostream& out, FloatingPoint num) {
type Matchers (line 7606) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
type Matchers (line 7783) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
type Matchers (line 7803) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
type Matchers (line 7906) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function handleExceptionMatchExpr (line 7946) | void handleExceptionMatchExpr( AssertionHandler& handler, StringMatche...
class AssertionPrinter (line 8044) | class AssertionPrinter {
method AssertionPrinter (line 8046) | AssertionPrinter& operator= (AssertionPrinter const&) = delete;
method AssertionPrinter (line 8047) | AssertionPrinter(AssertionPrinter const&) = delete;
method AssertionPrinter (line 8048) | AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats...
method print (line 8057) | void print() {
method printSourceInfo (line 8131) | void printSourceInfo() const {
method printResultType (line 8136) | void printResultType(Colour::Code colour, StringRef passOrFail) const {
method printIssue (line 8143) | void printIssue(char const* issue) const {
method printExpressionWas (line 8147) | void printExpressionWas() {
method printOriginalExpression (line 8157) | void printOriginalExpression() const {
method printReconstructedExpression (line 8163) | void printReconstructedExpression() const {
method printMessage (line 8170) | void printMessage() {
method printRemainingMessages (line 8177) | void printRemainingMessages(Colour::Code colour = compactDimColour) {
class ConsoleAssertionPrinter (line 8288) | class ConsoleAssertionPrinter {
method ConsoleAssertionPrinter (line 8290) | ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) ...
method ConsoleAssertionPrinter (line 8291) | ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
method ConsoleAssertionPrinter (line 8292) | ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const&...
method print (line 8380) | void print() const {
method printResultType (line 8393) | void printResultType() const {
method printOriginalExpression (line 8398) | void printOriginalExpression() const {
method printReconstructedExpression (line 8404) | void printReconstructedExpression() const {
method printMessage (line 8413) | void printMessage() const {
method printSourceInfo (line 8422) | void printSourceInfo() const {
function makeRatio (line 8438) | std::size_t makeRatio( std::uint64_t number, std::uint64_t total ) {
type Justification (line 8455) | enum class Justification { Left, Right }
type ColumnInfo (line 8457) | struct ColumnInfo {
type ColumnBreak (line 8462) | struct ColumnBreak {}
type RowBreak (line 8463) | struct RowBreak {}
class Duration (line 8465) | class Duration {
type Unit (line 8466) | enum class Unit {
method Duration (line 8483) | explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
method value (line 8501) | auto value() const -> double {
method StringRef (line 8515) | StringRef unitsAsString() const {
class TablePrinter (line 8538) | class TablePrinter {
method TablePrinter (line 8546) | TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
method columnInfos (line 8550) | auto columnInfos() const -> std::vector<ColumnInfo> const& {
method open (line 8554) | void open() {
method close (line 8571) | void close() {
method TablePrinter (line 8580) | TablePrinter& operator << (TablePrinter& tp, T const& value) {
method TablePrinter (line 8585) | TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
method TablePrinter (line 8607) | TablePrinter& operator << (TablePrinter& tp, RowBreak) {
type BySectionInfo (line 8909) | struct BySectionInfo {
method BySectionInfo (line 8910) | BySectionInfo( SectionInfo const& other ): m_other( other ) {}
method BySectionInfo (line 8911) | BySectionInfo( BySectionInfo const& other ):
type Detail (line 8928) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
function listTestNamesOnly (line 9099) | void listTestNamesOnly(std::ostream& out,
function getFormattedDuration (line 9120) | std::string getFormattedDuration( double duration ) {
function shouldShowDuration (line 9140) | bool shouldShowDuration( IConfig const& config, double duration ) {
function serializeFilters (line 9151) | std::string serializeFilters( std::vector<std::string> const& filters ) {
function defaultListReporters (line 9180) | void
function defaultListListeners (line 9214) | void defaultListListeners( std::ostream& out,
function defaultListTags (line 9246) | void defaultListTags( std::ostream& out,
function defaultListTests (line 9268) | void defaultListTests(std::ostream& out, ColourImpl* streamColour, std...
class SummaryColumn (line 9309) | class SummaryColumn {
method SummaryColumn (line 9311) | SummaryColumn( std::string suffix, Colour::Code colour ):
method SummaryColumn (line 9314) | SummaryColumn&& addRow( std::uint64_t count ) && {
method getColour (line 9330) | Colour::Code getColour() const { return m_colour; }
function printSummaryRow (line 9342) | void printSummaryRow( std::ostream& stream,
function printTestRunTotals (line 9368) | void printTestRunTotals( std::ostream& stream,
function getCurrentTimestamp (line 9426) | std::string getCurrentTimestamp() {
function fileNameTag (line 9450) | std::string fileNameTag(std::vector<Tag> const& tags) {
function formatDuration (line 9468) | std::string formatDuration( double seconds ) {
function normalizeNamespaceMarkers (line 9474) | static void normalizeNamespaceMarkers(std::string& str) {
type Detail (line 9903) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
function createMetadataString (line 9934) | std::string createMetadataString(IConfig const& config) {
class TapAssertionPrinter (line 10107) | class TapAssertionPrinter {
method TapAssertionPrinter (line 10109) | TapAssertionPrinter& operator= (TapAssertionPrinter const&) = delete;
method TapAssertionPrinter (line 10110) | TapAssertionPrinter(TapAssertionPrinter const&) = delete;
method TapAssertionPrinter (line 10111) | TapAssertionPrinter(std::ostream& _stream, AssertionStats const& _st...
method print (line 10120) | void print() {
method printResultType (line 10197) | void printResultType(StringRef passOrFail) const {
method printIssue (line 10203) | void printIssue(StringRef issue) const {
method printExpressionWas (line 10207) | void printExpressionWas() {
method printOriginalExpression (line 10216) | void printOriginalExpression() const {
method printReconstructedExpression (line 10222) | void printReconstructedExpression() const {
method printMessage (line 10232) | void printMessage() {
method printRemainingMessages (line 10239) | void printRemainingMessages(Colour::Code colour = tapDimColour) {
function printHeaderString (line 10320) | void printHeaderString(std::ostream& os, std::string const& _string, s...
function escape (line 10331) | std::string escape(StringRef str) {
type Catch (line 53) | namespace Catch {
type Benchmark (line 43) | namespace Benchmark {
type Detail (line 44) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 55) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 68) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 102) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 269) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Benchmark (line 54) | namespace Benchmark {
type Detail (line 44) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 55) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 68) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 102) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 269) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Benchmark (line 67) | namespace Benchmark {
type Detail (line 44) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 55) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 68) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 102) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 269) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Benchmark (line 101) | namespace Benchmark {
type Detail (line 44) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 55) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 68) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 102) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 269) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Benchmark (line 268) | namespace Benchmark {
type Detail (line 44) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 55) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 68) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 102) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
type Detail (line 269) | namespace Detail {
type optimized_away_error (line 69) | struct optimized_away_error : std::exception {
function throw_optimized_away_error (line 77) | void throw_optimized_away_error() {
function sample (line 106) | static sample
function outlier_variance (line 137) | static double outlier_variance( Estimate<double> mean,
function erf_inv (line 170) | static double erf_inv( double x ) {
function standard_deviation (line 246) | static double
function directCompare (line 275) | bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
function weighted_average_quantile (line 280) | double weighted_average_quantile(int k, int q, std::vector<double>...
function OutlierClassification (line 295) | OutlierClassification
function mean (line 325) | double mean( std::vector<double>::const_iterator first,
function erfc_inv (line 337) | double erfc_inv(double x) {
function normal_quantile (line 341) | double normal_quantile(double p) {
function bootstrap_analysis (line 357) | bootstrap_analysis analyse_samples(double confidence_level,
function Approx (line 432) | Approx Approx::custom() {
function Approx (line 436) | Approx Approx::operator-() const {
type literals (line 470) | namespace literals {
function Approx (line 471) | Approx operator "" _a(long double val) {
function Approx (line 474) | Approx operator "" _a(unsigned long long val) {
function StringRef (line 569) | StringRef AssertionResult::getMessage() const {
function SourceLineInfo (line 572) | SourceLineInfo AssertionResult::getSourceInfo() const {
function StringRef (line 576) | StringRef AssertionResult::getTestMacroName() const {
function getSeed (line 819) | std::uint32_t getSeed() {
class RegistryHub (line 939) | class RegistryHub : public IRegistryHub,
method RegistryHub (line 944) | RegistryHub() = default;
method ReporterRegistry (line 945) | ReporterRegistry const& getReporterRegistry() const override {
method ITestCaseRegistry (line 948) | ITestCaseRegistry const& getTestCaseRegistry() const override {
method IExceptionTranslatorRegistry (line 951) | IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry()...
method ITagAliasRegistry (line 954) | ITagAliasRegistry const& getTagAliasRegistry() const override {
method StartupExceptionRegistry (line 957) | StartupExceptionRegistry const& getStartupExceptionRegistry() const ...
method registerReporter (line 962) | void registerReporter( std::string const& name, IReporterFactoryPtr ...
method registerListener (line 965) | void registerListener( Detail::unique_ptr<EventListenerFactory> fact...
method registerTest (line 968) | void registerTest( Detail::unique_ptr<TestCaseInfo>&& testInfo, Deta...
method registerTranslator (line 971) | void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& ...
method registerTagAlias (line 974) | void registerTagAlias( std::string const& alias, std::string const& ...
method registerStartupException (line 977) | void registerStartupException() noexcept override {
method IMutableEnumValuesRegistry (line 984) | IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
function IRegistryHub (line 1000) | IRegistryHub const& getRegistryHub() {
function IMutableRegistryHub (line 1003) | IMutableRegistryHub& getMutableRegistryHub() {
function cleanUp (line 1006) | void cleanUp() {
function translateActiveException (line 1010) | std::string translateActiveException() {
function IEventListenerPtr (line 1030) | IEventListenerPtr createReporter(std::string const& reporterName, Repo...
function IEventListenerPtr (line 1037) | IEventListenerPtr prepareReporters(Config const* config) {
class TestGroup (line 1068) | class TestGroup {
method TestGroup (line 1070) | explicit TestGroup(IEventListenerPtr&& reporter, Config const* config):
method Totals (line 1098) | Totals execute() {
method hadUnmatchedTestSpecs (line 1117) | bool hadUnmatchedTestSpecs() const {
function applyFilenamesAsTags (line 1131) | void applyFilenamesAsTags() {
function TestCaseProperties (line 1386) | TestCaseProperties operator|(TestCaseProperties lhs, TestCasePropertie...
function TestCaseProperties (line 1392) | TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProper...
function TestCaseProperties (line 1399) | TestCaseProperties operator&(TestCaseProperties lhs, TestCasePropertie...
function applies (line 1405) | bool applies(TestCaseProperties tcp) {
function TestCaseProperties (line 1411) | TestCaseProperties parseSpecialTag( StringRef tag ) {
function isReservedTag (line 1427) | bool isReservedTag( StringRef tag ) {
function enforceNotReservedTag (line 1432) | void enforceNotReservedTag( StringRef tag, SourceLineInfo const& _line...
function makeDefaultName (line 1439) | std::string makeDefaultName() {
function StringRef (line 1444) | StringRef extractFilenamePart(StringRef filename) {
function sizeOfExtraTags (line 1460) | size_t sizeOfExtraTags(StringRef filepath) {
function makeTestCaseInfo (line 1476) | Detail::unique_ptr<TestCaseInfo>
function TestCaseInfo (line 1621) | TestCaseInfo const& TestCaseHandle::getTestCaseInfo() const {
function getCurrentNanosecondsSinceEpoch (line 1764) | static auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
type Detail (line 1796) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
function Counts (line 2037) | Counts Counts::operator - ( Counts const& other ) const {
function Counts (line 2046) | Counts& Counts::operator += ( Counts const& other ) {
function Totals (line 2064) | Totals Totals::operator - ( Totals const& other ) const {
function Totals (line 2071) | Totals& Totals::operator += ( Totals const& other ) {
function Totals (line 2077) | Totals Totals::delta( Totals const& prevTotals ) const {
type Detail (line 2096) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
function Version (line 2135) | Version const& libraryVersion() {
type Generators (line 2160) | namespace Generators {
type Detail (line 2162) | namespace Detail {
function throw_generator_exception (line 2164) | [[noreturn]]
function IGeneratorTracker (line 2172) | IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, ...
function IGeneratorTracker (line 2176) | IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
function StringRef (line 2230) | StringRef GeneratorUntypedBase::currentElementAsString() const {
type GeneratorTracker (line 5092) | struct GeneratorTracker final : TestCaseTracking::TrackerBase,
method GeneratorTracker (line 5096) | GeneratorTracker(
method GeneratorTracker (line 5103) | static GeneratorTracker*
method isGeneratorTracker (line 5144) | bool isGeneratorTracker() const override { return true; }
method hasGenerator (line 5145) | auto hasGenerator() const -> bool override {
method close (line 5148) | void close() override {
method getGenerator (line 5219) | auto getGenerator() const -> GeneratorBasePtr const& override {
method setGenerator (line 5222) | void setGenerator( GeneratorBasePtr&& generator ) override {
type Generators (line 2219) | namespace Generators {
type Detail (line 2162) | namespace Detail {
function throw_generator_exception (line 2164) | [[noreturn]]
function IGeneratorTracker (line 2172) | IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, ...
function IGeneratorTracker (line 2176) | IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
function StringRef (line 2230) | StringRef GeneratorUntypedBase::currentElementAsString() const {
type GeneratorTracker (line 5092) | struct GeneratorTracker final : TestCaseTracking::TrackerBase,
method GeneratorTracker (line 5096) | GeneratorTracker(
method GeneratorTracker (line 5103) | static GeneratorTracker*
method isGeneratorTracker (line 5144) | bool isGeneratorTracker() const override { return true; }
method hasGenerator (line 5145) | auto hasGenerator() const -> bool override {
method close (line 5148) | void close() override {
method getGenerator (line 5219) | auto getGenerator() const -> GeneratorBasePtr const& override {
method setGenerator (line 5222) | void setGenerator( GeneratorBasePtr&& generator ) override {
function IConfig (line 2270) | IConfig const * ReporterConfig::fullConfig() const { return m_fullConf...
function ColourMode (line 2271) | ColourMode ReporterConfig::colourMode() const { return m_colourMode; }
function handleExceptionMatchExpr (line 2413) | void handleExceptionMatchExpr( AssertionHandler& handler, std::string ...
type Detail (line 2425) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
type Clara (line 2474) | namespace Clara {
type Detail (line 2475) | namespace Detail {
function TokenStream (line 2524) | TokenStream& TokenStream::operator++() {
function ParserResult (line 2535) | ParserResult convertInto( std::string const& source,
function ParserResult (line 2541) | ParserResult convertInto( std::string const& source,
function InternalParseResult (line 2561) | InternalParseResult ParserBase::parse( Args const& args ) const {
function ParserResult (line 2569) | ParserResult BoundFlagRef::setFlag( bool flag ) {
function ParserResult (line 2721) | ParserResult ExeName::set(std::string const& newName) {
function Parser (line 2737) | Parser& Parser::operator|=( Parser const& other ) {
type ParserInfo (line 2817) | struct ParserInfo {
function makeCommandLineParser (line 2893) | Clara::Parser makeCommandLineParser( ConfigData& config ) {
class NoColourImpl (line 3255) | class NoColourImpl final : public ColourImpl {
method NoColourImpl (line 3257) | NoColourImpl( IStream* stream ): ColourImpl( stream ) {}
method use (line 3260) | void use( Colour::Code ) const override {}
class Win32ColourImpl (line 3273) | class Win32ColourImpl final : public ColourImpl {
method Win32ColourImpl (line 3275) | Win32ColourImpl(IStream* stream):
method useImplementationForStream (line 3284) | static bool useImplementationForStream(IStream const& stream) {
method use (line 3292) | void use( Colour::Code _colourCode ) const override {
method setTextAttribute (line 3316) | void setTextAttribute( WORD _textAttribute ) const {
class ANSIColourImpl (line 3339) | class ANSIColourImpl final : public ColourImpl {
method ANSIColourImpl (line 3341) | ANSIColourImpl( IStream* stream ): ColourImpl( stream ) {}
method useImplementationForStream (line 3343) | static bool useImplementationForStream(IStream const& stream) {
method use (line 3365) | void use( Colour::Code _colourCode ) const override {
function makeColourImpl (line 3400) | Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode implSelection,
function isColourImplAvailable (line 3429) | bool isColourImplAvailable( ColourMode colourSelection ) {
function cleanUpContext (line 3457) | void cleanUpContext() {
function Context (line 3465) | Context& getCurrentMutableContext() {
function SimplePcg32 (line 3477) | SimplePcg32& sharedRng() {
function writeToDebugConsole (line 3494) | void writeToDebugConsole( std::string const& text ) {
function writeToDebugConsole (line 3502) | void writeToDebugConsole( std::string const& text ) {
function writeToDebugConsole (line 3510) | void writeToDebugConsole( std::string const& text ) {
function isDebuggerActive (line 3541) | bool isDebuggerActive(){
function isDebuggerActive (line 3572) | bool isDebuggerActive() {
function isDebuggerActive (line 3591) | bool isDebuggerActive(){
function isDebuggerActive (line 3612) | bool isDebuggerActive() {
function isDebuggerActive (line 3619) | bool isDebuggerActive() {
function isDebuggerActive (line 3625) | bool isDebuggerActive() { return false; }
function formatReconstructedExpression (line 3636) | void formatReconstructedExpression( std::ostream &os, std::string cons...
function throw_exception (line 3653) | [[noreturn]]
function throw_logic_error (line 3661) | [[noreturn]]
function throw_domain_error (line 3666) | [[noreturn]]
function throw_runtime_error (line 3671) | [[noreturn]]
type Detail (line 3688) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
function tryTranslators (line 3763) | static std::string tryTranslators(
type SignalDefs (line 3895) | struct SignalDefs { DWORD id; const char* name; }
function LONG (line 3907) | static LONG CALLBACK topLevelExceptionFilter(PEXCEPTION_POINTERS Excep...
type SignalDefs (line 3966) | struct SignalDefs {
type sigaction (line 3991) | struct sigaction
function restorePreviousSignalHandlers (line 3993) | static void restorePreviousSignalHandlers() noexcept {
function handleSignal (line 4005) | static void handleSignal( int sig ) {
type sigaction (line 4042) | struct sigaction
type Detail (line 4070) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
type Detail (line 4097) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
type Detail (line 4131) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
function makeStream (line 4248) | auto makeStream( std::string const& filename ) -> Detail::unique_ptr<I...
function listTests (line 4327) | void listTests(IEventListener& reporter, IConfig const& config) {
function listTags (line 4333) | void listTags(IEventListener& reporter, IConfig const& config) {
function listReporters (line 4355) | void listReporters(IEventListener& reporter) {
function listListeners (line 4367) | void listListeners(IEventListener& reporter) {
function list (line 4403) | bool list( IEventListener& reporter, Config const& config ) {
function isnan (line 4664) | bool isnan(float f) {
function isnan (line 4667) | bool isnan(double d) {
function isnan (line 4672) | bool isnan(float f) {
function isnan (line 4675) | bool isnan(double d) {
function rotate_right (line 4693) | uint32_t rotate_right(uint32_t val, uint32_t count) {
function generateRandomSeed (line 4755) | std::uint32_t generateRandomSeed( GenerateFrom from ) {
type ReporterRegistry::ReporterRegistryImpl (line 4777) | struct ReporterRegistry::ReporterRegistryImpl {
function IEventListenerPtr (line 4807) | IEventListenerPtr
type kvPair (line 4852) | struct kvPair {
function kvPair (line 4856) | kvPair splitKVPair(StringRef kvString) {
type Detail (line 4866) | namespace Detail {
type Endianness (line 1801) | struct Endianness {
type Arch (line 1802) | enum Arch { Big, Little }
method Arch (line 1804) | static Arch which() {
function fpToString (line 1814) | std::string fpToString(T value, int precision) {
function convertIntoString (line 1834) | std::string convertIntoString(StringRef string, bool escape_invisibl...
function convertIntoString (line 1872) | std::string convertIntoString(StringRef string) {
function rawMemoryToString (line 1876) | std::string rawMemoryToString( const void *object, std::size_t size ) {
function registerTranslatorImpl (line 2097) | void registerTranslatorImpl(
function StringRef (line 3693) | StringRef extractInstanceName(StringRef enumInstance) {
function parseEnums (line 3703) | std::vector<StringRef> parseEnums( StringRef enums ) {
function StringRef (line 3715) | StringRef EnumInfo::lookup( int value ) const {
function makeEnumInfo (line 3723) | Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName...
function EnumInfo (line 3737) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
function convertToBits (line 4072) | uint32_t convertToBits(float f) {
function convertToBits (line 4079) | uint64_t convertToBits(double d) {
class StreamBufImpl (line 4134) | class StreamBufImpl final : public std::streambuf {
method StreamBufImpl (line 4139) | StreamBufImpl() {
method overflow (line 4148) | int overflow( int c ) override {
method sync (line 4160) | int sync() override {
type OutputDebugWriter (line 4171) | struct OutputDebugWriter {
class FileStream (line 4182) | class FileStream final : public IStream {
method FileStream (line 4185) | FileStream( std::string const& filename ) {
class CoutStream (line 4199) | class CoutStream final : public IStream {
method CoutStream (line 4204) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
method isConsole (line 4209) | bool isConsole() const override { return true; }
class CerrStream (line 4212) | class CerrStream : public IStream {
method CerrStream (line 4218) | CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
method isConsole (line 4223) | bool isConsole() const override { return true; }
class DebugOutStream (line 4228) | class DebugOutStream final : public IStream {
method DebugOutStream (line 4232) | DebugOutStream()
function splitReporterSpec (line 4867) | std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
function stringToColourMode (line 4916) | Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
function AssertionStats (line 8944) | AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
function registerReporterImpl (line 9905) | void registerReporterImpl( std::string const& name,
function parseReporterSpec (line 4939) | Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec ) {
function isOk (line 5012) | bool isOk( ResultWas::OfType resultType ) {
function isJustInfo (line 5015) | bool isJustInfo( int flags ) {
function shouldContinueOnFailure (line 5023) | bool shouldContinueOnFailure( int flags ) { return ( flags & Result...
function shouldSuppressFailure (line 5024) | bool shouldSuppressFailure( int flags ) { return ( flags & Result...
type StringStreams (line 5037) | struct StringStreams {
method add (line 5042) | auto add() -> std::size_t {
method release (line 5054) | void release( std::size_t index ) {
type Generators (line 5090) | namespace Generators {
type Detail (line 2162) | namespace Detail {
function throw_generator_exception (line 2164) | [[noreturn]]
function IGeneratorTracker (line 2172) | IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, ...
function IGeneratorTracker (line 2176) | IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
function StringRef (line 2230) | StringRef GeneratorUntypedBase::currentElementAsString() const {
type GeneratorTracker (line 5092) | struct GeneratorTracker final : TestCaseTracking::TrackerBase,
method GeneratorTracker (line 5096) | GeneratorTracker(
method GeneratorTracker (line 5103) | static GeneratorTracker*
method isGeneratorTracker (line 5144) | bool isGeneratorTracker() const override { return true; }
method hasGenerator (line 5145) | auto hasGenerator() const -> bool override {
method close (line 5148) | void close() override {
method getGenerator (line 5219) | auto getGenerator() const -> GeneratorBasePtr const& override {
method setGenerator (line 5222) | void setGenerator( GeneratorBasePtr&& generator ) override {
function Totals (line 5244) | Totals RunContext::runTest(TestCaseHandle const& testCase) {
function IGeneratorTracker (line 5391) | IGeneratorTracker*
function IGeneratorTracker (line 5403) | IGeneratorTracker* RunContext::createGeneratorTracker(
function AssertionResult (line 5492) | const AssertionResult * RunContext::getLastResult() const {
function getSingletons (line 5814) | static auto getSingletons() -> std::vector<ISingleton*>*& {
function addSingleton (line 5824) | void addSingleton(ISingleton* singleton ) {
function cleanupSingletons (line 5827) | void cleanupSingletons() {
function startsWith (line 5911) | bool startsWith( std::string const& s, std::string const& prefix ) {
function startsWith (line 5914) | bool startsWith( StringRef s, char prefix ) {
function endsWith (line 5917) | bool endsWith( std::string const& s, std::string const& suffix ) {
function endsWith (line 5920) | bool endsWith( std::string const& s, char suffix ) {
function contains (line 5923) | bool contains( std::string const& s, std::string const& infix ) {
function toLowerInPlace (line 5926) | void toLowerInPlace( std::string& s ) {
function toLower (line 5931) | std::string toLower( std::string const& s ) {
function toLower (line 5936) | char toLower(char c) {
function trim (line 5940) | std::string trim( std::string const& str ) {
function StringRef (line 5948) | StringRef trim(StringRef ref) {
function replaceInPlace (line 5960) | bool replaceInPlace( std::string& str, std::string const& replaceThis,...
function splitStringRef (line 5974) | std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
function TagAlias (line 6064) | TagAlias const* TagAliasRegistry::find( std::string const& alias ) con...
function ITagAliasRegistry (line 6097) | ITagAliasRegistry const& ITagAliasRegistry::get() {
function enforceNoDuplicateTestCases (line 6144) | static void enforceNoDuplicateTestCases(
function matchTest (line 6166) | static bool matchTest( TestCaseHandle const& testCase,
function sortTests (line 6175) | std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vec...
function isThrowSafe (line 6227) | bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& confi...
function filterTests (line 6231) | std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> c...
type TestCaseTracking (line 6285) | namespace TestCaseTracking {
function ITracker (line 6303) | ITracker* ITracker::findChild( NameAndLocationRef const& nameAndLoca...
function ITracker (line 6336) | ITracker& TrackerContext::startRun() {
function SectionTracker (line 6447) | SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAn...
function StringRef (line 6491) | StringRef SectionTracker::trimmedName() const {
function throw_test_failure_exception (line 6508) | void throw_test_failure_exception() {
function throw_test_skip_exception (line 6516) | void throw_test_skip_exception() {
function StringRef (line 6535) | static StringRef extractClassName( StringRef classOrMethodName ) {
class TestInvokerAsFunction (line 6563) | class TestInvokerAsFunction final : public ITestInvoker {
method TestInvokerAsFunction (line 6568) | TestInvokerAsFunction( TestType testAsFunction ) noexcept:
method invoke (line 6571) | void invoke() const override { m_testAsFunction(); }
function makeTestInvoker (line 6576) | Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction...
function TestSpecParser (line 6605) | TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
function TestSpec (line 6623) | TestSpec TestSpecParser::testSpec() {
type TextFlow (line 6861) | namespace TextFlow {
function Column (line 6981) | Column Spacer( size_t spaceWidth ) {
function Columns (line 7055) | Columns Column::operator+( Column const& other ) {
function Columns (line 7062) | Columns& Columns::operator+=( Column const& col ) {
function Columns (line 7067) | Columns Columns::operator+( Column const& col ) {
function uncaught_exceptions (line 7082) | bool uncaught_exceptions() {
function trailingBytes (line 7145) | size_t trailingBytes(unsigned char c) {
function headerValue (line 7158) | uint32_t headerValue(unsigned char c) {
function hexEscapeChar (line 7171) | void hexEscapeChar(std::ostream& os, unsigned char c) {
function shouldNewline (line 7179) | bool shouldNewline(XmlFormatting fmt) {
function shouldIndent (line 7183) | bool shouldIndent(XmlFormatting fmt) {
function XmlFormatting (line 7189) | XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
function XmlFormatting (line 7196) | XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
function XmlWriter (line 7364) | XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormat...
function XmlWriter (line 7384) | XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
function XmlWriter (line 7403) | XmlWriter& XmlWriter::writeAttribute( StringRef name,
function XmlWriter (line 7410) | XmlWriter& XmlWriter::writeAttribute( StringRef name, bool attribute ) {
function XmlWriter (line 7415) | XmlWriter& XmlWriter::writeAttribute( StringRef name,
function XmlWriter (line 7421) | XmlWriter& XmlWriter::writeText( StringRef text, XmlFormatting fmt ) {
function XmlWriter (line 7435) | XmlWriter& XmlWriter::writeComment( StringRef text, XmlFormatting fmt ) {
type Matchers (line 7478) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
type Matchers (line 7496) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
type Matchers (line 7522) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function almostEqualUlps (line 7554) | bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
function nextafter (line 7569) | float nextafter(float x, float y) {
function nextafter (line 7573) | double nextafter(double x, double y) {
function FP (line 7580) | FP step(FP start, FP direction, uint64_t steps) {
function marginComparison (line 7593) | bool marginComparison(double lhs, double rhs, double margin) {
function write (line 7598) | void write(std::ostream& out, FloatingPoint num) {
type Matchers (line 7606) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
type Matchers (line 7783) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
type Matchers (line 7803) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
type Matchers (line 7906) | namespace Matchers {
function IsEmptyMatcher (line 7508) | IsEmptyMatcher IsEmpty() {
function HasSizeMatcher (line 7512) | HasSizeMatcher SizeIs(std::size_t sz) {
function ExceptionMessageMatcher (line 7532) | ExceptionMessageMatcher Message(std::string const& message) {
type Detail (line 7607) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function WithinUlpsMatcher (line 7725) | WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
function WithinUlpsMatcher (line 7729) | WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
function WithinAbsMatcher (line 7733) | WithinAbsMatcher WithinAbs(double target, double margin) {
function WithinRelMatcher (line 7737) | WithinRelMatcher WithinRel(double target, double eps) {
function WithinRelMatcher (line 7741) | WithinRelMatcher WithinRel(double target) {
function WithinRelMatcher (line 7745) | WithinRelMatcher WithinRel(float target, float eps) {
function WithinRelMatcher (line 7749) | WithinRelMatcher WithinRel(float target) {
function IsNaNMatcher (line 7764) | IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
function AllTrueMatcher (line 7786) | AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
function NoneTrueMatcher (line 7790) | NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
function AnyTrueMatcher (line 7794) | AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
function StringRef (line 7814) | StringRef CasedString::caseSensitivitySuffix() const {
function StringEqualsMatcher (line 7883) | StringEqualsMatcher Equals( std::string const& str, CaseSensitive ca...
function StringContainsMatcher (line 7886) | StringContainsMatcher ContainsSubstring( std::string const& str, Cas...
function EndsWithMatcher (line 7889) | EndsWithMatcher EndsWith( std::string const& str, CaseSensitive case...
function StartsWithMatcher (line 7892) | StartsWithMatcher StartsWith( std::string const& str, CaseSensitive ...
function RegexMatcher (line 7896) | RegexMatcher Matches(std::string const& regex, CaseSensitive caseSen...
type Detail (line 7909) | namespace Detail {
type FloatingPointKind (line 7609) | enum class FloatingPointKind : uint8_t {
function describe_multi_matcher (line 7911) | std::string describe_multi_matcher(StringRef combine, std::string ...
function handleExceptionMatchExpr (line 7946) | void handleExceptionMatchExpr( AssertionHandler& handler, StringMatche...
Condensed preview — 10 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (937K chars).
[
{
"path": ".editorconfig",
"chars": 704,
"preview": "root = true\n\n[*]\nindent_style = tab\nindent_size = 4\ntab_width = 4\nend_of_line = lf\ncharset = utf-8\ntrim_trailing_whitesp"
},
{
"path": ".github/FUNDING.yml",
"chars": 13,
"preview": "github: qix-\n"
},
{
"path": ".github/workflows/ci.yml",
"chars": 489,
"preview": "name: Test\non: [push]\n\njobs:\n buildlinux:\n name: Test\n runs-on: ubuntu-latest\n timeout-minutes: 3\n steps:\n "
},
{
"path": ".gitignore",
"chars": 17,
"preview": "/build/\n/.cache/\n"
},
{
"path": "CMakeLists.txt",
"chars": 688,
"preview": "project (tortellini)\ncmake_minimum_required (VERSION 3.2)\n\nadd_library (tortellini INTERFACE)\ntarget_include_directories"
},
{
"path": "README.md",
"chars": 7899,
"preview": "<h1 align=\"center\">\n\t<img height=\"250\" src=\"logo.png\" alt=\"Tortellini\">\n</h1>\n\nThe stupid - _and I mean really, really s"
},
{
"path": "catch2/catch_amalgamated.cpp",
"chars": 382038,
"preview": "// Copyright Catch2 Authors\n// Distributed under the Boost Software License, Version 1.0.\n// (See accompa"
},
{
"path": "catch2/catch_amalgamated.hpp",
"chars": 487988,
"preview": "// Copyright Catch2 Authors\n// Distributed under the Boost Software License, Version 1.0.\n// (See accompa"
},
{
"path": "include/tortellini.hh",
"chars": 13160,
"preview": "#ifndef TORTELLINI_HH__\n#define TORTELLINI_HH__\n#pragma once\n\n#ifndef NOMINMAX\n#\tdefine _TORTELLINI_UNDEFINE_NOMINMAX_PL"
},
{
"path": "test.cc",
"chars": 12024,
"preview": "#define CATCH_CONFIG_MAIN\n#include \"catch2/catch_amalgamated.hpp\"\n#include \"../include/tortellini.hh\"\n\n#include <iostrea"
}
]
About this extraction
This page contains the full source code of the Qix-/tortellini GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 10 files (883.8 KB), approximately 198.6k tokens, and a symbol index with 1853 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.