Full Code of eglimi/cpptime for AI

master 08abf1d8605a cached

8 files

665.5 KB

154.6k tokens

1462 symbols

1 requests

Download .txt

Showing preview only (683K chars total). Download the full file or copy to clipboard to get everything.

Repository: eglimi/cpptime
Branch: master
Commit: 08abf1d8605a
Files: 8
Total size: 665.5 KB

Directory structure:
gitextract_mca2lcic/

├── .clang-format
├── .github/
│   └── workflows/
│       └── main.yml
├── .gitignore
├── LICENSE
├── README.md
├── cpptime.h
└── tests/
    ├── catch.hpp
    └── timer_test.cpp

================================================
FILE CONTENTS
================================================

================================================
FILE: .clang-format
================================================
---
Language:        Cpp
# BasedOnStyle:  Mozilla
AccessModifierOffset: -4
AlignAfterOpenBracket: false
AlignEscapedNewlinesLeft: true
AlignOperands:   true
AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: true
AllowShortIfStatementsOnASingleLine: true
AllowShortLoopsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Empty
AlwaysBreakAfterDefinitionReturnType: false
AlwaysBreakTemplateDeclarations: false
AlwaysBreakBeforeMultilineStrings: false
BreakBeforeBinaryOperators: None
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BinPackParameters: true
BinPackArguments: true
ColumnLimit:     100
ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 4
DerivePointerAlignment: true
ExperimentalAutoDetectBinPacking: false
IndentCaseLabels: true
IndentWrappedFunctionNames: false
IndentFunctionDeclarationAfterType: false
MaxEmptyLinesToKeep: 1
KeepEmptyLinesAtTheStartOfBlocks: true
NamespaceIndentation: None
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: true
ObjCSpaceBeforeProtocolList: false
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakString: 1000
PenaltyBreakFirstLessLess: 120
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Left
SpacesBeforeTrailingComments: 1
Cpp11BracedListStyle: true
Standard:        Cpp11
IndentWidth:     4
TabWidth:        4
UseTab:          ForIndentation
BreakBeforeBraces: Linux
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpacesInAngles:  false
SpaceInEmptyParentheses: false
SpacesInCStyleCastParentheses: false
SpaceAfterCStyleCast: false
SpacesInContainerLiterals: true
SpaceBeforeAssignmentOperators: true
ContinuationIndentWidth: 4
CommentPragmas:  '^ IWYU pragma:'
ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
SpaceBeforeParens: Never
DisableFormat:   false
...



================================================
FILE: .github/workflows/main.yml
================================================
name: cpptime CI

on: push

jobs:
  unit_test:
    name: Run Tests
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Compile and run tests
        run: |
          g++ -std=c++11 -Wall -Wextra -o test tests/timer_test.cpp -l pthread
          ./test


================================================
FILE: .gitignore
================================================
# The test binary
test


================================================
FILE: LICENSE
================================================
The MIT License (MIT)

Copyright (c) 2015 Michael Egli

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: README.md
================================================
# C++ Timeouts

A portable, header-only C++11 timer component.

It manages a set of timeouts that, when expired, invoke a callback. It uses
features of C++11 in order to avoid platform specific code.

It supports one-shot and periodic timeouts.

## Documentation

Please see the documentation in [cpptime.h](./cpptime.h) for more detailed
information about the implementation.

## Implementation Status

We use this timer implementation in some of our products without issues.
Judging from the GitHub stars and forks, it seems to be used in other projects
as well. Since it was implemented in 2015 and has not seen many issue reports,
we assume it is quite stable.

But note that this is not a guarantee and if you find any issues, please report
them.

## Use Cases and Limitations

Naturally the implementation makes some trade-offs. This makes it useful for
some cases, and less so for others.

- The timer runs completely in user space. This makes it slightly less
  efficient than other solutions, such as `timer_create()` or
  `timerfd_create()`. However, in many cases, this overhead is acceptable.

- Given a C++11 capable compiler, the code is portable.

- The API to add or remove a timeout is arguably nicer than the platform
  specific alternatives. E.g.

```cpp
timer.add(seconds(2), [](CppTime::timer_id) { ... });
```

- The implementation is small and easy to understand. You can change or extend
  it to make it better suitable for your use-cases.

## Examples

A one shot timer.

~~~
using namespace std::chrono;
CppTime::Timer t;
t.add(seconds(2), [](CppTime::timer_id) { std::cout << "yes\n"; });
std::this_thread::sleep_for(seconds(3));
~~~

A periodic timer that is first executed after 2 seconds, and after this every
second. The timeout event is then removed after 10 seconds. When a timeout
event is removed, its attached handler is also freed to clean-up any attached
resources.

~~~
using namespace std::chrono;
CppTime::Timer t;
auto id = t.add(seconds(2), [](CppTime::timer_id) { std::cout << "yes\n"; }, seconds(1));
std::this_thread::sleep_for(seconds(10));
t.remove(id);
~~~

See the tests for more examples.

## Usage

To use the timer component, Simply copy [cpptime.h](./cpptime.h) into you
project. Everything is contained in this single header file.

Tests can be compiled and executed with the following commands, assuming you
are on a POSIX machine.

~~~
g++ -std=c++11 -Wall -Wextra -o test tests/timer_test.cpp -l pthread
./test
~~~

## Possible Features

While the current implementation serves us well, there are some features that
might potentially be interesting for other use cases. Contact us in case you
are interested.

- [x] Ability to have multiple timer components running.
- [x] Distribute it as a header only library.
- [ ] Optionally avoid locking.
- [ ] API to use client thread instead of creating its own.
- [ ] API to use client mutex instead of its own.

## Known issues

GCC up to version 10 (e.g. used in Ubuntu 20.04 LTS) has [an issue][gcc-clock] where `conditional_variable` doesn't use the monotonic clock. This leads to unreliable programs when the system clock is moved backwards. See #5 for more details. The fix is to update to a GCC version with the fix applied, e.g. version 10 or greater.

[gcc-clock]: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=41861

## Contributions

Contributions, suggestions, and feature requests are welcome. Please use the
GitHub issue tracker.


================================================
FILE: cpptime.h
================================================
#ifndef CPPTIME_H_
#define CPPTIME_H_

/**
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 Michael Egli
 *
 * 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.
 *
 * \author    Michael Egli
 * \copyright Michael Egli
 * \date      11-Jul-2015
 *
 * \file cpptime.h
 *
 * C++11 timer component
 * =====================
 *
 * A portable, header-only C++11 timer component.
 *
 * Overview
 * --------
 *
 * This component can be used to manage a set of timeouts. It is implemented in
 * pure C++11. It is therefore very portable given a compliant compiler.
 *
 * A timeout can be added with one of the `add()` functions, and removed with
 * the `remove()` function. A timeout can be set to be either one-shot or
 * periodic. If it is one-shot, the callback is invoked once and the timeout
 * event is then automatically removed. If the timeout is periodic, it is
 * always renewed and never automatically removed.
 *
 * When a timeout is removed or when a one-shot timeout expires, the handler
 * will be deleted to clean-up any resources.
 *
 * Removing a timeout is possible from within the callback. In this case, you
 * must be careful not to access any captured variables, if any, after calling
 * `remove()`, because they are no longer valid.
 *
 * Timeout Units
 * -------------
 *
 * The preferred functions for adding timeouts are those that take a
 * `std::chrono::...` argument. However, for convenience, there is also an API
 * that takes a uint64_t. When using this API, all values are expected to be
 * given in microseconds (us).
 *
 * For periodic timeouts, a separate timeout can be specified for the initial
 * (first) timeout, and the periodicity after that.
 *
 * To avoid drifts, times are added by simply adding the period to the initially
 * calculated (or provided) time. Also, we use `wait until` type of API to wait
 * for a timeout instead of a `wait for` API.
 *
 * Data Structure
 * --------------
 *
 * Internally, a std::vector is used to store timeout events. The timer_id
 * returned from the `add` functions are used as index to this vector.
 *
 * In addition, a std::multiset is used that holds all time points when
 * timeouts expire.
 *
 * Using a vector to store timeout events has some implications. It is very
 * fast to remove an event, because the timer_id is the vector's index. On the
 * other hand, this makes it also more complicated to manage the timer_ids. The
 * current solution is to keep track of ids that are freed in order to re-use
 * them. A stack is used for this.
 *
 * Examples
 * --------
 *
 * More examples can be found in the `tests` folder.
 *
 * ~~~
 * CppTime::Timer t;
 * t.add(std::chrono::seconds(1), [](CppTime::timer_id){ std::cout << "got it!"; });
 * std::this_thread::sleep_for(std::chrono::seconds(2));
 * ~~~
 */

// Includes
#include <algorithm>
#include <chrono>
#include <condition_variable>
#include <functional>
#include <mutex>
#include <set>
#include <stack>
#include <thread>
#include <vector>

namespace CppTime
{

// Public types
using timer_id = std::size_t;
using handler_t = std::function<void(timer_id)>;
using clock = std::chrono::steady_clock;
using timestamp = std::chrono::time_point<clock>;
using duration = std::chrono::microseconds;

// Private definitions. Do not rely on this namespace.
namespace detail
{

// The event structure that holds the information about a timer.
struct Event {
	timer_id id;
	timestamp start;
	duration period;
	handler_t handler;
	bool valid;
	Event()
	    : id(0), start(duration::zero()), period(duration::zero()), handler(nullptr), valid(false)
	{
	}
	template <typename Func>
	Event(timer_id id, timestamp start, duration period, Func &&handler)
	    : id(id), start(start), period(period), handler(std::forward<Func>(handler)), valid(true)
	{
	}
	Event(Event &&r) = default;
	Event &operator=(Event &&ev) = default;
	Event(const Event &r) = delete;
	Event &operator=(const Event &r) = delete;
};

// A time event structure that holds the next timeout and a reference to its
// Event struct.
struct Time_event {
	timestamp next;
	timer_id ref;
};

inline bool operator<(const Time_event &l, const Time_event &r)
{
	return l.next < r.next;
}

} // end namespace detail

class Timer
{
	using scoped_m = std::unique_lock<std::mutex>;

	// Thread and locking variables.
	std::mutex m;
	std::condition_variable cond;
	std::thread worker;

	// Use to terminate the timer thread.
	bool done = false;

	// The vector that holds all active events.
	std::vector<detail::Event> events;
	// Sorted queue that has the next timeout at its top.
	std::multiset<detail::Time_event> time_events;

	// A list of ids to be re-used. If possible, ids are used from this pool.
	std::stack<CppTime::timer_id> free_ids;

public:
	Timer() : m{}, cond{}, worker{}, events{}, time_events{}, free_ids{}
	{
		scoped_m lock(m);
		done = false;
		worker = std::thread([this] { run(); });
	}

	~Timer()
	{
		scoped_m lock(m);
		done = true;
		lock.unlock();
		cond.notify_all();
		worker.join();
		events.clear();
		time_events.clear();
		while(!free_ids.empty()) {
			free_ids.pop();
		}
	}

	/**
	 * Add a new timer.
	 *
	 * \param when The time at which the handler is invoked.
	 * \param handler The callable that is invoked when the timer fires.
	 * \param period The periodicity at which the timer fires. Only used for periodic timers.
	 */
	timer_id add(
	    const timestamp &when, handler_t &&handler, const duration &period = duration::zero())
	{
		scoped_m lock(m);
		timer_id id = 0;
		// Add a new event. Prefer an existing and free id. If none is available, add
		// a new one.
		if(free_ids.empty()) {
			id = events.size();
			detail::Event e(id, when, period, std::move(handler));
			events.push_back(std::move(e));
		} else {
			id = free_ids.top();
			free_ids.pop();
			detail::Event e(id, when, period, std::move(handler));
			events[id] = std::move(e);
		}
		time_events.insert(detail::Time_event{when, id});
		lock.unlock();
		cond.notify_all();
		return id;
	}

	/**
	 * Overloaded `add` function that uses a `std::chrono::duration` instead of a
	 * `time_point` for the first timeout.
	 */
	template <class Rep, class Period>
	inline timer_id add(const std::chrono::duration<Rep, Period> &when, handler_t &&handler,
	    const duration &period = duration::zero())
	{
		return add(clock::now() + std::chrono::duration_cast<std::chrono::microseconds>(when),
		    std::move(handler), period);
	}

	/**
	 * Overloaded `add` function that uses a uint64_t instead of a `time_point` for
	 * the first timeout and the period.
	 */
	inline timer_id add(const uint64_t when, handler_t &&handler, const uint64_t period = 0)
	{
		return add(duration(when), std::move(handler), duration(period));
	}

	/**
	 * Removes the timer with the given id.
	 */
	bool remove(timer_id id)
	{
		scoped_m lock(m);
		if(events.size() == 0 || events.size() <= id) {
			return false;
		}
		events[id].valid = false;
		events[id].handler = nullptr;
		auto it = std::find_if(time_events.begin(), time_events.end(),
		    [&](const detail::Time_event &te) { return te.ref == id; });
		if(it != time_events.end()) {
			free_ids.push(it->ref);
			time_events.erase(it);
		}
		lock.unlock();
		cond.notify_all();
		return true;
	}

private:
	void run()
	{
		scoped_m lock(m);

		while(!done) {

			if(time_events.empty()) {
				// Wait for work
				cond.wait(lock);
			} else {
				detail::Time_event te = *time_events.begin();
				if(CppTime::clock::now() >= te.next) {

					// Remove time event
					time_events.erase(time_events.begin());

					// Invoke the handler
					lock.unlock();
					events[te.ref].handler(te.ref);
					lock.lock();

					if(events[te.ref].valid && events[te.ref].period.count() > 0) {
						// The event is valid and a periodic timer.
						te.next += events[te.ref].period;
						time_events.insert(te);
					} else {
						// The event is either no longer valid because it was removed in the
						// callback, or it is a one-shot timer.
						events[te.ref].valid = false;
						events[te.ref].handler = nullptr;
						free_ids.push(te.ref);
					}
				} else {
					cond.wait_until(lock, te.next);
				}
			}
		}
	}
};

} // end namespace CppTime

#endif // CPPTIME_H_


================================================
FILE: tests/catch.hpp
================================================
/*
 *  Catch v2.13.8
 *  Generated: 2022-01-03 21:20:09.589503
 *  ----------------------------------------------------------
 *  This file has been merged from multiple headers. Please don't edit it directly
 *  Copyright (c) 2022 Two Blue Cubes Ltd. All rights reserved.
 *
 *  Distributed under the Boost Software License, Version 1.0. (See accompanying
 *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 */
#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
// start catch.hpp


#define CATCH_VERSION_MAJOR 2
#define CATCH_VERSION_MINOR 13
#define CATCH_VERSION_PATCH 8

#ifdef __clang__
#    pragma clang system_header
#elif defined __GNUC__
#    pragma GCC system_header
#endif

// start catch_suppress_warnings.h

#ifdef __clang__
#   ifdef __ICC // icpc defines the __clang__ macro
#       pragma warning(push)
#       pragma warning(disable: 161 1682)
#   else // __ICC
#       pragma clang diagnostic push
#       pragma clang diagnostic ignored "-Wpadded"
#       pragma clang diagnostic ignored "-Wswitch-enum"
#       pragma clang diagnostic ignored "-Wcovered-switch-default"
#    endif
#elif defined __GNUC__
     // Because REQUIREs trigger GCC's -Wparentheses, and because still
     // supported version of g++ have only buggy support for _Pragmas,
     // Wparentheses have to be suppressed globally.
#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details

#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wunused-variable"
#    pragma GCC diagnostic ignored "-Wpadded"
#endif
// end catch_suppress_warnings.h
#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
#  define CATCH_IMPL
#  define CATCH_CONFIG_ALL_PARTS
#endif

// In the impl file, we want to have access to all parts of the headers
// Can also be used to sanely support PCHs
#if defined(CATCH_CONFIG_ALL_PARTS)
#  define CATCH_CONFIG_EXTERNAL_INTERFACES
#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
#    undef CATCH_CONFIG_DISABLE_MATCHERS
#  endif
#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
#  endif
#endif

#if !defined(CATCH_CONFIG_IMPL_ONLY)
// start catch_platform.h

// See e.g.:
// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html
#ifdef __APPLE__
#  include <TargetConditionals.h>
#  if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \
      (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)
#    define CATCH_PLATFORM_MAC
#  elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)
#    define CATCH_PLATFORM_IPHONE
#  endif

#elif defined(linux) || defined(__linux) || defined(__linux__)
#  define CATCH_PLATFORM_LINUX

#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
#  define CATCH_PLATFORM_WINDOWS
#endif

// end catch_platform.h

#ifdef CATCH_IMPL
#  ifndef CLARA_CONFIG_MAIN
#    define CLARA_CONFIG_MAIN_NOT_DEFINED
#    define CLARA_CONFIG_MAIN
#  endif
#endif

// start catch_user_interfaces.h

namespace Catch {
    unsigned int rngSeed();
}

// end catch_user_interfaces.h
// start catch_tag_alias_autoregistrar.h

// start catch_common.h

// start catch_compiler_capabilities.h

// Detect a number of compiler features - by compiler
// The following features are defined:
//
// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
// ****************
// Note to maintainers: if new toggles are added please document them
// in configuration.md, too
// ****************

// In general each macro has a _NO_<feature name> form
// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
// Many features, at point of detection, define an _INTERNAL_ macro, so they
// can be combined, en-mass, with the _NO_ forms later.

#ifdef __cplusplus

#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
#    define CATCH_CPP14_OR_GREATER
#  endif

#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
#    define CATCH_CPP17_OR_GREATER
#  endif

#endif

// Only GCC compiler should be used in this block, so other compilers trying to
// mask themselves as GCC should be ignored.
#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__)
#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )

#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)

#endif

#if defined(__clang__)

#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )

// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
// which results in calls to destructors being emitted for each temporary,
// without a matching initialization. In practice, this can result in something
// like `std::string::~string` being called on an uninitialized value.
//
// For example, this code will likely segfault under IBM XL:
// ```
// REQUIRE(std::string("12") + "34" == "1234")
// ```
//
// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
#  if !defined(__ibmxl__) && !defined(__CUDACC__)
#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
#  endif

#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")

#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )

#    define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )

#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )

#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )

#endif // __clang__

////////////////////////////////////////////////////////////////////////////////
// Assume that non-Windows platforms support posix signals by default
#if !defined(CATCH_PLATFORM_WINDOWS)
    #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
#endif

////////////////////////////////////////////////////////////////////////////////
// We know some environments not to support full POSIX signals
#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
    #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
#endif

#ifdef __OS400__
#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
#       define CATCH_CONFIG_COLOUR_NONE
#endif

////////////////////////////////////////////////////////////////////////////////
// Android somehow still does not support std::to_string
#if defined(__ANDROID__)
#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
#endif

////////////////////////////////////////////////////////////////////////////////
// Not all Windows environments support SEH properly
#if defined(__MINGW32__)
#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
#endif

////////////////////////////////////////////////////////////////////////////////
// PS4
#if defined(__ORBIS__)
#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
#endif

////////////////////////////////////////////////////////////////////////////////
// Cygwin
#ifdef __CYGWIN__

// Required for some versions of Cygwin to declare gettimeofday
// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
#   define _BSD_SOURCE
// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))

#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING

# endif
#endif // __CYGWIN__

////////////////////////////////////////////////////////////////////////////////
// Visual C++
#if defined(_MSC_VER)

// Universal Windows platform does not support SEH
// Or console colours (or console at all...)
#  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
#    define CATCH_CONFIG_COLOUR_NONE
#  else
#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
#  endif

#  if !defined(__clang__) // Handle Clang masquerading for msvc

// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#    endif // MSVC_TRADITIONAL

// Only do this if we're not using clang on Windows, which uses `diagnostic push` & `diagnostic pop`
#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
#  endif // __clang__

#endif // _MSC_VER

#if defined(_REENTRANT) || defined(_MSC_VER)
// Enable async processing, as -pthread is specified or no additional linking is required
# define CATCH_INTERNAL_CONFIG_USE_ASYNC
#endif // _MSC_VER

////////////////////////////////////////////////////////////////////////////////
// Check if we are compiled with -fno-exceptions or equivalent
#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
#endif

////////////////////////////////////////////////////////////////////////////////
// DJGPP
#ifdef __DJGPP__
#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
#endif // __DJGPP__

////////////////////////////////////////////////////////////////////////////////
// Embarcadero C++Build
#if defined(__BORLANDC__)
    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
#endif

////////////////////////////////////////////////////////////////////////////////

// Use of __COUNTER__ is suppressed during code analysis in
// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
// handled by it.
// Otherwise all supported compilers support COUNTER macro,
// but user still might want to turn it off
#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
    #define CATCH_INTERNAL_CONFIG_COUNTER
#endif

////////////////////////////////////////////////////////////////////////////////

// RTX is a special version of Windows that is real time.
// This means that it is detected as Windows, but does not provide
// the same set of capabilities as real Windows does.
#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
    #define CATCH_CONFIG_COLOUR_NONE
#endif

#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
#endif

// Various stdlib support checks that require __has_include
#if defined(__has_include)
  // Check if string_view is available and usable
  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
  #endif

  // Check if optional is available and usable
  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)

  // Check if byte is available and usable
  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
  #    include <cstddef>
  #    if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0)
  #      define CATCH_INTERNAL_CONFIG_CPP17_BYTE
  #    endif
  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)

  // Check if variant is available and usable
  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
  #    if defined(__clang__) && (__clang_major__ < 8)
         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
         // fix should be in clang 8, workaround in libstdc++ 8.2
  #      include <ciso646>
  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
  #        define CATCH_CONFIG_NO_CPP17_VARIANT
  #      else
  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
  #    else
  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
  #    endif // defined(__clang__) && (__clang_major__ < 8)
  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
#endif // defined(__has_include)

#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
#   define CATCH_CONFIG_COUNTER
#endif
#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
#   define CATCH_CONFIG_WINDOWS_SEH
#endif
// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
#   define CATCH_CONFIG_POSIX_SIGNALS
#endif
// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
#   define CATCH_CONFIG_WCHAR
#endif

#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
#    define CATCH_CONFIG_CPP11_TO_STRING
#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
#  define CATCH_CONFIG_CPP17_OPTIONAL
#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
#  define CATCH_CONFIG_CPP17_STRING_VIEW
#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
#  define CATCH_CONFIG_CPP17_VARIANT
#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
#  define CATCH_CONFIG_CPP17_BYTE
#endif

#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
#endif

#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
#  define CATCH_CONFIG_NEW_CAPTURE
#endif

#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
#endif

#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
#  define CATCH_CONFIG_POLYFILL_ISNAN
#endif

#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
#  define CATCH_CONFIG_USE_ASYNC
#endif

#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
#  define CATCH_CONFIG_ANDROID_LOGWRITE
#endif

#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
#endif

// Even if we do not think the compiler has that warning, we still have
// to provide a macro that can be used by the code.
#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
#endif
#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
#endif
#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
#endif

// The goal of this macro is to avoid evaluation of the arguments, but
// still have the compiler warn on problems inside...
#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
#endif

#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
#elif defined(__clang__) && (__clang_major__ < 5)
#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
#endif

#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
#endif

#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
#define CATCH_TRY if ((true))
#define CATCH_CATCH_ALL if ((false))
#define CATCH_CATCH_ANON(type) if ((false))
#else
#define CATCH_TRY try
#define CATCH_CATCH_ALL catch (...)
#define CATCH_CATCH_ANON(type) catch (type)
#endif

#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#endif

// end catch_compiler_capabilities.h
#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
#ifdef CATCH_CONFIG_COUNTER
#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
#else
#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
#endif

#include <iosfwd>
#include <string>
#include <cstdint>

// We need a dummy global operator<< so we can bring it into Catch namespace later
struct Catch_global_namespace_dummy {};
std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);

namespace Catch {

    struct CaseSensitive { enum Choice {
        Yes,
        No
    }; };

    class NonCopyable {
        NonCopyable( NonCopyable const& )              = delete;
        NonCopyable( NonCopyable && )                  = delete;
        NonCopyable& operator = ( NonCopyable const& ) = delete;
        NonCopyable& operator = ( NonCopyable && )     = delete;

    protected:
        NonCopyable();
        virtual ~NonCopyable();
    };

    struct SourceLineInfo {

        SourceLineInfo() = delete;
        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
        :   file( _file ),
            line( _line )
        {}

        SourceLineInfo( SourceLineInfo const& other )            = default;
        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;

        bool empty() const noexcept { return file[0] == '\0'; }
        bool operator == ( SourceLineInfo const& other ) const noexcept;
        bool operator < ( SourceLineInfo const& other ) const noexcept;

        char const* file;
        std::size_t line;
    };

    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );

    // Bring in operator<< from global namespace into Catch namespace
    // This is necessary because the overload of operator<< above makes
    // lookup stop at namespace Catch
    using ::operator<<;

    // Use this in variadic streaming macros to allow
    //    >> +StreamEndStop
    // as well as
    //    >> stuff +StreamEndStop
    struct StreamEndStop {
        std::string operator+() const;
    };
    template<typename T>
    T const& operator + ( T const& value, StreamEndStop ) {
        return value;
    }
}

#define CATCH_INTERNAL_LINEINFO \
    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )

// end catch_common.h
namespace Catch {

    struct RegistrarForTagAliases {
        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
    };

} // end namespace Catch

#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

// end catch_tag_alias_autoregistrar.h
// start catch_test_registry.h

// start catch_interfaces_testcase.h

#include <vector>

namespace Catch {

    class TestSpec;

    struct ITestInvoker {
        virtual void invoke () const = 0;
        virtual ~ITestInvoker();
    };

    class TestCase;
    struct IConfig;

    struct ITestCaseRegistry {
        virtual ~ITestCaseRegistry();
        virtual std::vector<TestCase> const& getAllTests() const = 0;
        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
    };

    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );

}

// end catch_interfaces_testcase.h
// start catch_stringref.h

#include <cstddef>
#include <string>
#include <iosfwd>
#include <cassert>

namespace Catch {

    /// A non-owning string class (similar to the forthcoming std::string_view)
    /// Note that, because a StringRef may be a substring of another string,
    /// it may not be null terminated.
    class StringRef {
    public:
        using size_type = std::size_t;
        using const_iterator = const char*;

    private:
        static constexpr char const* const s_empty = "";

        char const* m_start = s_empty;
        size_type m_size = 0;

    public: // construction
        constexpr StringRef() noexcept = default;

        StringRef( char const* rawChars ) noexcept;

        constexpr StringRef( char const* rawChars, size_type size ) noexcept
        :   m_start( rawChars ),
            m_size( size )
        {}

        StringRef( std::string const& stdString ) noexcept
        :   m_start( stdString.c_str() ),
            m_size( stdString.size() )
        {}

        explicit operator std::string() const {
            return std::string(m_start, m_size);
        }

    public: // operators
        auto operator == ( StringRef const& other ) const noexcept -> bool;
        auto operator != (StringRef const& other) const noexcept -> bool {
            return !(*this == other);
        }

        auto operator[] ( size_type index ) const noexcept -> char {
            assert(index < m_size);
            return m_start[index];
        }

    public: // named queries
        constexpr auto empty() const noexcept -> bool {
            return m_size == 0;
        }
        constexpr auto size() const noexcept -> size_type {
            return m_size;
        }

        // Returns the current start pointer. If the StringRef is not
        // null-terminated, throws std::domain_exception
        auto c_str() const -> char const*;

    public: // substrings and searches
        // Returns a substring of [start, start + length).
        // If start + length > size(), then the substring is [start, size()).
        // If start > size(), then the substring is empty.
        auto substr( size_type start, size_type length ) const noexcept -> StringRef;

        // Returns the current start pointer. May not be null-terminated.
        auto data() const noexcept -> char const*;

        constexpr auto isNullTerminated() const noexcept -> bool {
            return m_start[m_size] == '\0';
        }

    public: // iterators
        constexpr const_iterator begin() const { return m_start; }
        constexpr const_iterator end() const { return m_start + m_size; }
    };

    auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
    auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;

    constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
        return StringRef( rawChars, size );
    }
} // namespace Catch

constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
    return Catch::StringRef( rawChars, size );
}

// end catch_stringref.h
// start catch_preprocessor.hpp


#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))

#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
// MSVC needs more evaluations
#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
#else
#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
#endif

#define CATCH_REC_END(...)
#define CATCH_REC_OUT

#define CATCH_EMPTY()
#define CATCH_DEFER(id) id CATCH_EMPTY()

#define CATCH_REC_GET_END2() 0, CATCH_REC_END
#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)

#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )

#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )

// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
// and passes userdata as the first parameter to each invocation,
// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))

#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))

#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
#else
// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
#endif

#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)

#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
#else
#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
#endif

#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)

#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)
#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)

#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N

#define INTERNAL_CATCH_TYPE_GEN\
    template<typename...> struct TypeList {};\
    template<typename...Ts>\
    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
    template<template<typename...> class...> struct TemplateTypeList{};\
    template<template<typename...> class...Cs>\
    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
    template<typename...>\
    struct append;\
    template<typename...>\
    struct rewrap;\
    template<template<typename...> class, typename...>\
    struct create;\
    template<template<typename...> class, typename>\
    struct convert;\
    \
    template<typename T> \
    struct append<T> { using type = T; };\
    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
    template< template<typename...> class L1, typename...E1, typename...Rest>\
    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
    \
    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
    \
    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };

#define INTERNAL_CATCH_NTTP_1(signature, ...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
    \
    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };

#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    static void TestName()
#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    static void TestName()

#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    static void TestName()
#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    static void TestName()

#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
    template<typename Type>\
    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
    }

#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
    }

#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
    template<typename Type>\
    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
    }

#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
    }

#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
    template<typename TestType> \
    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
        void test();\
    }

#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
        void test();\
    }

#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
    template<typename TestType> \
    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define INTERNAL_CATCH_NTTP_0
#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
#else
#define INTERNAL_CATCH_NTTP_0(signature)
#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
#endif

// end catch_preprocessor.hpp
// start catch_meta.hpp


#include <type_traits>

namespace Catch {
    template<typename T>
    struct always_false : std::false_type {};

    template <typename> struct true_given : std::true_type {};
    struct is_callable_tester {
        template <typename Fun, typename... Args>
        true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
        template <typename...>
        std::false_type static test(...);
    };

    template <typename T>
    struct is_callable;

    template <typename Fun, typename... Args>
    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};

#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
    // replaced with std::invoke_result here.
    template <typename Func, typename... U>
    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U...>>>;
#else
    // Keep ::type here because we still support C++11
    template <typename Func, typename... U>
    using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U...)>::type>::type>::type;
#endif

} // namespace Catch

namespace mpl_{
    struct na;
}

// end catch_meta.hpp
namespace Catch {

template<typename C>
class TestInvokerAsMethod : public ITestInvoker {
    void (C::*m_testAsMethod)();
public:
    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}

    void invoke() const override {
        C obj;
        (obj.*m_testAsMethod)();
    }
};

auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;

template<typename C>
auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
}

struct NameAndTags {
    NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
    StringRef name;
    StringRef tags;
};

struct AutoReg : NonCopyable {
    AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
    ~AutoReg();
};

} // end namespace Catch

#if defined(CATCH_CONFIG_DISABLE)
    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
        static void TestName()
    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
        namespace{                        \
            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
                void test();              \
            };                            \
        }                                 \
        void TestName::test()
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
        namespace{                                                                                  \
            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
        }                                                                                           \
        }                                                                                           \
        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))

    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename TestType, __VA_ARGS__ )
    #else
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
    #endif

    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ )
    #else
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ ) )
    #endif

    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
    #else
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
    #endif

    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
    #else
        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
    #endif
#endif

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
        static void TestName(); \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        static void TestName()
    #define INTERNAL_CATCH_TESTCASE( ... ) \
        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ), __VA_ARGS__ )

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        namespace{ \
            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
                void test(); \
            }; \
            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
        } \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        void TestName::test()
    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ), ClassName, __VA_ARGS__ )

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

    ///////////////////////////////////////////////////////////////////////////////
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
            INTERNAL_CATCH_TYPE_GEN\
            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            template<typename...Types> \
            struct TestName{\
                TestName(){\
                    int index = 0;                                    \
                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
                    using expander = int[];\
                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
                }\
            };\
            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
            return 0;\
        }();\
        }\
        }\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename TestType, __VA_ARGS__ )
#else
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
#endif

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ )
#else
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ ) )
#endif

    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS              \
        template<typename TestType> static void TestFuncName();       \
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
            INTERNAL_CATCH_TYPE_GEN                                                  \
            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
            template<typename... Types>                               \
            struct TestName {                                         \
                void reg_tests() {                                          \
                    int index = 0;                                    \
                    using expander = int[];                           \
                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++)... };/* NOLINT */\
                }                                                     \
            };                                                        \
            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
                TestInit t;                                           \
                t.reg_tests();                                        \
                return 0;                                             \
            }();                                                      \
        }                                                             \
        }                                                             \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
        template<typename TestType>                                   \
        static void TestFuncName()

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename T,__VA_ARGS__)
#else
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename T, __VA_ARGS__ ) )
#endif

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__)
#else
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ ) )
#endif

    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        template<typename TestType> static void TestFunc();       \
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
        INTERNAL_CATCH_TYPE_GEN\
        template<typename... Types>                               \
        struct TestName {                                         \
            void reg_tests() {                                          \
                int index = 0;                                    \
                using expander = int[];                           \
                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
            }                                                     \
        };\
        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
                using TestInit = typename convert<TestName, TmplList>::type; \
                TestInit t;                                           \
                t.reg_tests();                                        \
                return 0;                                             \
            }();                                                      \
        }}\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
        template<typename TestType>                                   \
        static void TestFunc()

    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, TmplList )

    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
            INTERNAL_CATCH_TYPE_GEN\
            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            template<typename...Types> \
            struct TestNameClass{\
                TestNameClass(){\
                    int index = 0;                                    \
                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
                    using expander = int[];\
                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
                }\
            };\
            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
                return 0;\
        }();\
        }\
        }\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
#else
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
#endif

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
#else
    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
#endif

    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        template<typename TestType> \
            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
                void test();\
            };\
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
            INTERNAL_CATCH_TYPE_GEN                  \
            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            template<typename...Types>\
            struct TestNameClass{\
                void reg_tests(){\
                    int index = 0;\
                    using expander = int[];\
                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++)... };/* NOLINT */ \
                }\
            };\
            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
                TestInit t;\
                t.reg_tests();\
                return 0;\
            }(); \
        }\
        }\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        template<typename TestType> \
        void TestName<TestType>::test()

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
#else
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
#endif

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
#else
    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
#endif

    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        template<typename TestType> \
        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
            void test();\
        };\
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
            INTERNAL_CATCH_TYPE_GEN\
            template<typename...Types>\
            struct TestNameClass{\
                void reg_tests(){\
                    int index = 0;\
                    using expander = int[];\
                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
                }\
            };\
            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
                using TestInit = typename convert<TestNameClass, TmplList>::type;\
                TestInit t;\
                t.reg_tests();\
                return 0;\
            }(); \
        }}\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        template<typename TestType> \
        void TestName<TestType>::test()

#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, TmplList )

// end catch_test_registry.h
// start catch_capture.hpp

// start catch_assertionhandler.h

// start catch_assertioninfo.h

// start catch_result_type.h

namespace Catch {

    // ResultWas::OfType enum
    struct ResultWas { enum OfType {
        Unknown = -1,
        Ok = 0,
        Info = 1,
        Warning = 2,

        FailureBit = 0x10,

        ExpressionFailed = FailureBit | 1,
        ExplicitFailure = FailureBit | 2,

        Exception = 0x100 | FailureBit,

        ThrewException = Exception | 1,
        DidntThrowException = Exception | 2,

        FatalErrorCondition = 0x200 | FailureBit

    }; };

    bool isOk( ResultWas::OfType resultType );
    bool isJustInfo( int flags );

    // ResultDisposition::Flags enum
    struct ResultDisposition { enum Flags {
        Normal = 0x01,

        ContinueOnFailure = 0x02,   // Failures fail test, but execution continues
        FalseTest = 0x04,           // Prefix expression with !
        SuppressFail = 0x08         // Failures are reported but do not fail the test
    }; };

    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );

    bool shouldContinueOnFailure( int flags );
    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
    bool shouldSuppressFailure( int flags );

} // end namespace Catch

// end catch_result_type.h
namespace Catch {

    struct AssertionInfo
    {
        StringRef macroName;
        SourceLineInfo lineInfo;
        StringRef capturedExpression;
        ResultDisposition::Flags resultDisposition;

        // We want to delete this constructor but a compiler bug in 4.8 means
        // the struct is then treated as non-aggregate
        //AssertionInfo() = delete;
    };

} // end namespace Catch

// end catch_assertioninfo.h
// start catch_decomposer.h

// start catch_tostring.h

#include <vector>
#include <cstddef>
#include <type_traits>
#include <string>
// start catch_stream.h

#include <iosfwd>
#include <cstddef>
#include <ostream>

namespace Catch {

    std::ostream& cout();
    std::ostream& cerr();
    std::ostream& clog();

    class StringRef;

    struct IStream {
        virtual ~IStream();
        virtual std::ostream& stream() const = 0;
    };

    auto makeStream( StringRef const &filename ) -> IStream const*;

    class ReusableStringStream : NonCopyable {
        std::size_t m_index;
        std::ostream* m_oss;
    public:
        ReusableStringStream();
        ~ReusableStringStream();

        auto str() const -> std::string;

        template<typename T>
        auto operator << ( T const& value ) -> ReusableStringStream& {
            *m_oss << value;
            return *this;
        }
        auto get() -> std::ostream& { return *m_oss; }
    };
}

// end catch_stream.h
// start catch_interfaces_enum_values_registry.h

#include <vector>

namespace Catch {

    namespace Detail {
        struct EnumInfo {
            StringRef m_name;
            std::vector<std::pair<int, StringRef>> m_values;

            ~EnumInfo();

            StringRef lookup( int value ) const;
        };
    } // namespace Detail

    struct IMutableEnumValuesRegistry {
        virtual ~IMutableEnumValuesRegistry();

        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;

        template<typename E>
        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
            std::vector<int> intValues;
            intValues.reserve( values.size() );
            for( auto enumValue : values )
                intValues.push_back( static_cast<int>( enumValue ) );
            return registerEnum( enumName, allEnums, intValues );
        }
    };

} // Catch

// end catch_interfaces_enum_values_registry.h

#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
#include <string_view>
#endif

#ifdef __OBJC__
// start catch_objc_arc.hpp

#import <Foundation/Foundation.h>

#ifdef __has_feature
#define CATCH_ARC_ENABLED __has_feature(objc_arc)
#else
#define CATCH_ARC_ENABLED 0
#endif

void arcSafeRelease( NSObject* obj );
id performOptionalSelector( id obj, SEL sel );

#if !CATCH_ARC_ENABLED
inline void arcSafeRelease( NSObject* obj ) {
    [obj release];
}
inline id performOptionalSelector( id obj, SEL sel ) {
    if( [obj respondsToSelector: sel] )
        return [obj performSelector: sel];
    return nil;
}
#define CATCH_UNSAFE_UNRETAINED
#define CATCH_ARC_STRONG
#else
inline void arcSafeRelease( NSObject* ){}
inline id performOptionalSelector( id obj, SEL sel ) {
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
#endif
    if( [obj respondsToSelector: sel] )
        return [obj performSelector: sel];
#ifdef __clang__
#pragma clang diagnostic pop
#endif
    return nil;
}
#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained
#define CATCH_ARC_STRONG __strong
#endif

// end catch_objc_arc.hpp
#endif

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
#endif

namespace Catch {
    namespace Detail {

        extern const std::string unprintableString;

        std::string rawMemoryToString( const void *object, std::size_t size );

        template<typename T>
        std::string rawMemoryToString( const T& object ) {
          return rawMemoryToString( &object, sizeof(object) );
        }

        template<typename T>
        class IsStreamInsertable {
            template<typename Stream, typename U>
            static auto test(int)
                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());

            template<typename, typename>
            static auto test(...)->std::false_type;

        public:
            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
        };

        template<typename E>
        std::string convertUnknownEnumToString( E e );

        template<typename T>
        typename std::enable_if<
            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
        std::string>::type convertUnstreamable( T const& ) {
            return Detail::unprintableString;
        }
        template<typename T>
        typename std::enable_if<
            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
         std::string>::type convertUnstreamable(T const& ex) {
            return ex.what();
        }

        template<typename T>
        typename std::enable_if<
            std::is_enum<T>::value
        , std::string>::type convertUnstreamable( T const& value ) {
            return convertUnknownEnumToString( value );
        }

#if defined(_MANAGED)
        //! Convert a CLR string to a utf8 std::string
        template<typename T>
        std::string clrReferenceToString( T^ ref ) {
            if (ref == nullptr)
                return std::string("null");
            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
            cli::pin_ptr<System::Byte> p = &bytes[0];
            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
        }
#endif

    } // namespace Detail

    // If we decide for C++14, change these to enable_if_ts
    template <typename T, typename = void>
    struct StringMaker {
        template <typename Fake = T>
        static
        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
            convert(const Fake& value) {
                ReusableStringStream rss;
                // NB: call using the function-like syntax to avoid ambiguity with
                // user-defined templated operator<< under clang.
                rss.operator<<(value);
                return rss.str();
        }

        template <typename Fake = T>
        static
        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
            convert( const Fake& value ) {
#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
            return Detail::convertUnstreamable(value);
#else
            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
#endif
        }
    };

    namespace Detail {

        // This function dispatches all stringification requests inside of Catch.
        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
        template <typename T>
        std::string stringify(const T& e) {
            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
        }

        template<typename E>
        std::string convertUnknownEnumToString( E e ) {
            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
        }

#if defined(_MANAGED)
        template <typename T>
        std::string stringify( T^ e ) {
            return ::Catch::StringMaker<T^>::convert(e);
        }
#endif

    } // namespace Detail

    // Some predefined specializations

    template<>
    struct StringMaker<std::string> {
        static std::string convert(const std::string& str);
    };

#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
    template<>
    struct StringMaker<std::string_view> {
        static std::string convert(std::string_view str);
    };
#endif

    template<>
    struct StringMaker<char const *> {
        static std::string convert(char const * str);
    };
    template<>
    struct StringMaker<char *> {
        static std::string convert(char * str);
    };

#ifdef CATCH_CONFIG_WCHAR
    template<>
    struct StringMaker<std::wstring> {
        static std::string convert(const std::wstring& wstr);
    };

# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
    template<>
    struct StringMaker<std::wstring_view> {
        static std::string convert(std::wstring_view str);
    };
# endif

    template<>
    struct StringMaker<wchar_t const *> {
        static std::string convert(wchar_t const * str);
    };
    template<>
    struct StringMaker<wchar_t *> {
        static std::string convert(wchar_t * str);
    };
#endif

    // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
    //      while keeping string semantics?
    template<int SZ>
    struct StringMaker<char[SZ]> {
        static std::string convert(char const* str) {
            return ::Catch::Detail::stringify(std::string{ str });
        }
    };
    template<int SZ>
    struct StringMaker<signed char[SZ]> {
        static std::string convert(signed char const* str) {
            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
        }
    };
    template<int SZ>
    struct StringMaker<unsigned char[SZ]> {
        static std::string convert(unsigned char const* str) {
            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
        }
    };

#if defined(CATCH_CONFIG_CPP17_BYTE)
    template<>
    struct StringMaker<std::byte> {
        static std::string convert(std::byte value);
    };
#endif // defined(CATCH_CONFIG_CPP17_BYTE)
    template<>
    struct StringMaker<int> {
        static std::string convert(int value);
    };
    template<>
    struct StringMaker<long> {
        static std::string convert(long value);
    };
    template<>
    struct StringMaker<long long> {
        static std::string convert(long long value);
    };
    template<>
    struct StringMaker<unsigned int> {
        static std::string convert(unsigned int value);
    };
    template<>
    struct StringMaker<unsigned long> {
        static std::string convert(unsigned long value);
    };
    template<>
    struct StringMaker<unsigned long long> {
        static std::string convert(unsigned long long value);
    };

    template<>
    struct StringMaker<bool> {
        static std::string convert(bool b);
    };

    template<>
    struct StringMaker<char> {
        static std::string convert(char c);
    };
    template<>
    struct StringMaker<signed char> {
        static std::string convert(signed char c);
    };
    template<>
    struct StringMaker<unsigned char> {
        static std::string convert(unsigned char c);
    };

    template<>
    struct StringMaker<std::nullptr_t> {
        static std::string convert(std::nullptr_t);
    };

    template<>
    struct StringMaker<float> {
        static std::string convert(float value);
        static int precision;
    };

    template<>
    struct StringMaker<double> {
        static std::string convert(double value);
        static int precision;
    };

    template <typename T>
    struct StringMaker<T*> {
        template <typename U>
        static std::string convert(U* p) {
            if (p) {
                return ::Catch::Detail::rawMemoryToString(p);
            } else {
                return "nullptr";
            }
        }
    };

    template <typename R, typename C>
    struct StringMaker<R C::*> {
        static std::string convert(R C::* p) {
            if (p) {
                return ::Catch::Detail::rawMemoryToString(p);
            } else {
                return "nullptr";
            }
        }
    };

#if defined(_MANAGED)
    template <typename T>
    struct StringMaker<T^> {
        static std::string convert( T^ ref ) {
            return ::Catch::Detail::clrReferenceToString(ref);
        }
    };
#endif

    namespace Detail {
        template<typename InputIterator, typename Sentinel = InputIterator>
        std::string rangeToString(InputIterator first, Sentinel last) {
            ReusableStringStream rss;
            rss << "{ ";
            if (first != last) {
                rss << ::Catch::Detail::stringify(*first);
                for (++first; first != last; ++first)
                    rss << ", " << ::Catch::Detail::stringify(*first);
            }
            rss << " }";
            return rss.str();
        }
    }

#ifdef __OBJC__
    template<>
    struct StringMaker<NSString*> {
        static std::string convert(NSString * nsstring) {
            if (!nsstring)
                return "nil";
            return std::string("@") + [nsstring UTF8String];
        }
    };
    template<>
    struct StringMaker<NSObject*> {
        static std::string convert(NSObject* nsObject) {
            return ::Catch::Detail::stringify([nsObject description]);
        }

    };
    namespace Detail {
        inline std::string stringify( NSString* nsstring ) {
            return StringMaker<NSString*>::convert( nsstring );
        }

    } // namespace Detail
#endif // __OBJC__

} // namespace Catch

//////////////////////////////////////////////////////
// Separate std-lib types stringification, so it can be selectively enabled
// This means that we do not bring in

#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
#endif

// Separate std::pair specialization
#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
#include <utility>
namespace Catch {
    template<typename T1, typename T2>
    struct StringMaker<std::pair<T1, T2> > {
        static std::string convert(const std::pair<T1, T2>& pair) {
            ReusableStringStream rss;
            rss << "{ "
                << ::Catch::Detail::stringify(pair.first)
                << ", "
                << ::Catch::Detail::stringify(pair.second)
                << " }";
            return rss.str();
        }
    };
}
#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER

#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
#include <optional>
namespace Catch {
    template<typename T>
    struct StringMaker<std::optional<T> > {
        static std::string convert(const std::optional<T>& optional) {
            ReusableStringStream rss;
            if (optional.has_value()) {
                rss << ::Catch::Detail::stringify(*optional);
            } else {
                rss << "{ }";
            }
            return rss.str();
        }
    };
}
#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER

// Separate std::tuple specialization
#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
#include <tuple>
namespace Catch {
    namespace Detail {
        template<
            typename Tuple,
            std::size_t N = 0,
            bool = (N < std::tuple_size<Tuple>::value)
            >
            struct TupleElementPrinter {
            static void print(const Tuple& tuple, std::ostream& os) {
                os << (N ? ", " : " ")
                    << ::Catch::Detail::stringify(std::get<N>(tuple));
                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
            }
        };

        template<
            typename Tuple,
            std::size_t N
        >
            struct TupleElementPrinter<Tuple, N, false> {
            static void print(const Tuple&, std::ostream&) {}
        };

    }

    template<typename ...Types>
    struct StringMaker<std::tuple<Types...>> {
        static std::string convert(const std::tuple<Types...>& tuple) {
            ReusableStringStream rss;
            rss << '{';
            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
            rss << " }";
            return rss.str();
        }
    };
}
#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER

#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
#include <variant>
namespace Catch {
    template<>
    struct StringMaker<std::monostate> {
        static std::string convert(const std::monostate&) {
            return "{ }";
        }
    };

    template<typename... Elements>
    struct StringMaker<std::variant<Elements...>> {
        static std::string convert(const std::variant<Elements...>& variant) {
            if (variant.valueless_by_exception()) {
                return "{valueless variant}";
            } else {
                return std::visit(
                    [](const auto& value) {
                        return ::Catch::Detail::stringify(value);
                    },
                    variant
                );
            }
        }
    };
}
#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER

namespace Catch {
    // Import begin/ end from std here
    using std::begin;
    using std::end;

    namespace detail {
        template <typename...>
        struct void_type {
            using type = void;
        };

        template <typename T, typename = void>
        struct is_range_impl : std::false_type {
        };

        template <typename T>
        struct is_range_impl<T, typename void_type<decltype(begin(std::declval<T>()))>::type> : std::true_type {
        };
    } // namespace detail

    template <typename T>
    struct is_range : detail::is_range_impl<T> {
    };

#if defined(_MANAGED) // Managed types are never ranges
    template <typename T>
    struct is_range<T^> {
        static const bool value = false;
    };
#endif

    template<typename Range>
    std::string rangeToString( Range const& range ) {
        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
    }

    // Handle vector<bool> specially
    template<typename Allocator>
    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
        ReusableStringStream rss;
        rss << "{ ";
        bool first = true;
        for( bool b : v ) {
            if( first )
                first = false;
            else
                rss << ", ";
            rss << ::Catch::Detail::stringify( b );
        }
        rss << " }";
        return rss.str();
    }

    template<typename R>
    struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
        static std::string convert( R const& range ) {
            return rangeToString( range );
        }
    };

    template <typename T, int SZ>
    struct StringMaker<T[SZ]> {
        static std::string convert(T const(&arr)[SZ]) {
            return rangeToString(arr);
        }
    };

} // namespace Catch

// Separate std::chrono::duration specialization
#if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
#include <ctime>
#include <ratio>
#include <chrono>

namespace Catch {

template <class Ratio>
struct ratio_string {
    static std::string symbol();
};

template <class Ratio>
std::string ratio_string<Ratio>::symbol() {
    Catch::ReusableStringStream rss;
    rss << '[' << Ratio::num << '/'
        << Ratio::den << ']';
    return rss.str();
}
template <>
struct ratio_string<std::atto> {
    static std::string symbol();
};
template <>
struct ratio_string<std::femto> {
    static std::string symbol();
};
template <>
struct ratio_string<std::pico> {
    static std::string symbol();
};
template <>
struct ratio_string<std::nano> {
    static std::string symbol();
};
template <>
struct ratio_string<std::micro> {
    static std::string symbol();
};
template <>
struct ratio_string<std::milli> {
    static std::string symbol();
};

    ////////////
    // std::chrono::duration specializations
    template<typename Value, typename Ratio>
    struct StringMaker<std::chrono::duration<Value, Ratio>> {
        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
            ReusableStringStream rss;
            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
            return rss.str();
        }
    };
    template<typename Value>
    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
            ReusableStringStream rss;
            rss << duration.count() << " s";
            return rss.str();
        }
    };
    template<typename Value>
    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
            ReusableStringStream rss;
            rss << duration.count() << " m";
            return rss.str();
        }
    };
    template<typename Value>
    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
            ReusableStringStream rss;
            rss << duration.count() << " h";
            return rss.str();
        }
    };

    ////////////
    // std::chrono::time_point specialization
    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
    template<typename Clock, typename Duration>
    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
        }
    };
    // std::chrono::time_point<system_clock> specialization
    template<typename Duration>
    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
            auto converted = std::chrono::system_clock::to_time_t(time_point);

#ifdef _MSC_VER
            std::tm timeInfo = {};
            gmtime_s(&timeInfo, &converted);
#else
            std::tm* timeInfo = std::gmtime(&converted);
#endif

            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
            char timeStamp[timeStampSize];
            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";

#ifdef _MSC_VER
            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
#else
            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
#endif
            return std::string(timeStamp);
        }
    };
}
#endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER

#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
namespace Catch { \
    template<> struct StringMaker<enumName> { \
        static std::string convert( enumName value ) { \
            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
        } \
    }; \
}

#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )

#ifdef _MSC_VER
#pragma warning(pop)
#endif

// end catch_tostring.h
#include <iosfwd>

#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
#pragma warning(disable:4018) // more "signed/unsigned mismatch"
#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
#pragma warning(disable:4180) // qualifier applied to function type has no meaning
#pragma warning(disable:4800) // Forcing result to true or false
#endif

namespace Catch {

    struct ITransientExpression {
        auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
        auto getResult() const -> bool { return m_result; }
        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;

        ITransientExpression( bool isBinaryExpression, bool result )
        :   m_isBinaryExpression( isBinaryExpression ),
            m_result( result )
        {}

        // We don't actually need a virtual destructor, but many static analysers
        // complain if it's not here :-(
        virtual ~ITransientExpression();

        bool m_isBinaryExpression;
        bool m_result;

    };

    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );

    template<typename LhsT, typename RhsT>
    class BinaryExpr  : public ITransientExpression {
        LhsT m_lhs;
        StringRef m_op;
        RhsT m_rhs;

        void streamReconstructedExpression( std::ostream &os ) const override {
            formatReconstructedExpression
                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
        }

    public:
        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
        :   ITransientExpression{ true, comparisonResult },
            m_lhs( lhs ),
            m_op( op ),
            m_rhs( rhs )
        {}

        template<typename T>
        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename T>
        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<T>::value,
            "chained comparisons are not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }
    };

    template<typename LhsT>
    class UnaryExpr : public ITransientExpression {
        LhsT m_lhs;

        void streamReconstructedExpression( std::ostream &os ) const override {
            os << Catch::Detail::stringify( m_lhs );
        }

    public:
        explicit UnaryExpr( LhsT lhs )
        :   ITransientExpression{ false, static_cast<bool>(lhs) },
            m_lhs( lhs )
        {}
    };

    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
    template<typename LhsT, typename RhsT>
    auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
    template<typename T>
    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
    template<typename T>
    auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
    template<typename T>
    auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
    template<typename T>
    auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }

    template<typename LhsT, typename RhsT>
    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
    template<typename T>
    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
    template<typename T>
    auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
    template<typename T>
    auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
    template<typename T>
    auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }

    template<typename LhsT>
    class ExprLhs {
        LhsT m_lhs;
    public:
        explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}

        template<typename RhsT>
        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
        }
        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
            return { m_lhs == rhs, m_lhs, "==", rhs };
        }

        template<typename RhsT>
        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
        }
        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
            return { m_lhs != rhs, m_lhs, "!=", rhs };
        }

        template<typename RhsT>
        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
        }
        template<typename RhsT>
        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
        }
        template<typename RhsT>
        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
        }
        template<typename RhsT>
        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
        }
        template <typename RhsT>
        auto operator | (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
            return { static_cast<bool>(m_lhs | rhs), m_lhs, "|", rhs };
        }
        template <typename RhsT>
        auto operator & (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
            return { static_cast<bool>(m_lhs & rhs), m_lhs, "&", rhs };
        }
        template <typename RhsT>
        auto operator ^ (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
            return { static_cast<bool>(m_lhs ^ rhs), m_lhs, "^", rhs };
        }

        template<typename RhsT>
        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<RhsT>::value,
            "operator&& is not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        template<typename RhsT>
        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
            static_assert(always_false<RhsT>::value,
            "operator|| is not supported inside assertions, "
            "wrap the expression inside parentheses, or decompose it");
        }

        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
            return UnaryExpr<LhsT>{ m_lhs };
        }
    };

    void handleExpression( ITransientExpression const& expr );

    template<typename T>
    void handleExpression( ExprLhs<T> const& expr ) {
        handleExpression( expr.makeUnaryExpr() );
    }

    struct Decomposer {
        template<typename T>
        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
            return ExprLhs<T const&>{ lhs };
        }

        auto operator <=( bool value ) -> ExprLhs<bool> {
            return ExprLhs<bool>{ value };
        }
    };

} // end namespace Catch

#ifdef _MSC_VER
#pragma warning(pop)
#endif

// end catch_decomposer.h
// start catch_interfaces_capture.h

#include <string>
#include <chrono>

namespace Catch {

    class AssertionResult;
    struct AssertionInfo;
    struct SectionInfo;
    struct SectionEndInfo;
    struct MessageInfo;
    struct MessageBuilder;
    struct Counts;
    struct AssertionReaction;
    struct SourceLineInfo;

    struct ITransientExpression;
    struct IGeneratorTracker;

#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
    struct BenchmarkInfo;
    template <typename Duration = std::chrono::duration<double, std::nano>>
    struct BenchmarkStats;
#endif // CATCH_CONFIG_ENABLE_BENCHMARKING

    struct IResultCapture {

        virtual ~IResultCapture();

        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
                                        Counts& assertions ) = 0;
        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;

        virtual auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;

#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
        virtual void benchmarkPreparing( std::string const& name ) = 0;
        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
        virtual void benchmarkFailed( std::string const& error ) = 0;
#endif // CATCH_CONFIG_ENABLE_BENCHMARKING

        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
        virtual void popScopedMessage( MessageInfo const& message ) = 0;

        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;

        virtual void handleFatalErrorCondition( StringRef message ) = 0;

        virtual void handleExpr
                (   AssertionInfo const& info,
                    ITransientExpression const& expr,
                    AssertionReaction& reaction ) = 0;
        virtual void handleMessage
                (   AssertionInfo const& info,
                    ResultWas::OfType resultType,
                    StringRef const& message,
                    AssertionReaction& reaction ) = 0;
        virtual void handleUnexpectedExceptionNotThrown
                (   AssertionInfo const& info,
                    AssertionReaction& reaction ) = 0;
        virtual void handleUnexpectedInflightException
                (   AssertionInfo const& info,
                    std::string const& message,
                    AssertionReaction& reaction ) = 0;
        virtual void handleIncomplete
                (   AssertionInfo const& info ) = 0;
        virtual void handleNonExpr
                (   AssertionInfo const &info,
                    ResultWas::OfType resultType,
                    AssertionReaction &reaction ) = 0;

        virtual bool lastAssertionPassed() = 0;
        virtual void assertionPassed() = 0;

        // Deprecated, do not use:
        virtual std::string getCurrentTestName() const = 0;
        virtual const AssertionResult* getLastResult() const = 0;
        virtual void exceptionEarlyReported() = 0;
    };

    IResultCapture& getResultCapture();
}

// end catch_interfaces_capture.h
namespace Catch {

    struct TestFailureException{};
    struct AssertionResultData;
    struct IResultCapture;
    class RunContext;

    class LazyExpression {
        friend class AssertionHandler;
        friend struct AssertionStats;
        friend class RunContext;

        ITransientExpression const* m_transientExpression = nullptr;
        bool m_isNegated;
    public:
        LazyExpression( bool isNegated );
        LazyExpression( LazyExpression const& other );
        LazyExpression& operator = ( LazyExpression const& ) = delete;

        explicit operator bool() const;

        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
    };

    struct AssertionReaction {
        bool shouldDebugBreak = false;
        bool shouldThrow = false;
    };

    class AssertionHandler {
        AssertionInfo m_assertionInfo;
        AssertionReaction m_reaction;
        bool m_completed = false;
        IResultCapture& m_resultCapture;

    public:
        AssertionHandler
            (   StringRef const& macroName,
                SourceLineInfo const& lineInfo,
                StringRef capturedExpression,
                ResultDisposition::Flags resultDisposition );
        ~AssertionHandler() {
            if ( !m_completed ) {
                m_resultCapture.handleIncomplete( m_assertionInfo );
            }
        }

        template<typename T>
        void handleExpr( ExprLhs<T> const& expr ) {
            handleExpr( expr.makeUnaryExpr() );
        }
        void handleExpr( ITransientExpression const& expr );

        void handleMessage(ResultWas::OfType resultType, StringRef const& message);

        void handleExceptionThrownAsExpected();
        void handleUnexpectedExceptionNotThrown();
        void handleExceptionNotThrownAsExpected();
        void handleThrowingCallSkipped();
        void handleUnexpectedInflightException();

        void complete();
        void setCompleted();

        // query
        auto allowThrows() const -> bool;
    };

    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );

} // namespace Catch

// end catch_assertionhandler.h
// start catch_message.h

#include <string>
#include <vector>

namespace Catch {

    struct MessageInfo {
        MessageInfo(    StringRef const& _macroName,
                        SourceLineInfo const& _lineInfo,
                        ResultWas::OfType _type );

        StringRef macroName;
        std::string message;
        SourceLineInfo lineInfo;
        ResultWas::OfType type;
        unsigned int sequence;

        bool operator == ( MessageInfo const& other ) const;
        bool operator < ( MessageInfo const& other ) const;
    private:
        static unsigned int globalCount;
    };

    struct MessageStream {

        template<typename T>
        MessageStream& operator << ( T const& value ) {
            m_stream << value;
            return *this;
        }

        ReusableStringStream m_stream;
    };

    struct MessageBuilder : MessageStream {
        MessageBuilder( StringRef const& macroName,
                        SourceLineInfo const& lineInfo,
                        ResultWas::OfType type );

        template<typename T>
        MessageBuilder& operator << ( T const& value ) {
            m_stream << value;
            return *this;
        }

        MessageInfo m_info;
    };

    class ScopedMessage {
    public:
        explicit ScopedMessage( MessageBuilder const& builder );
        ScopedMessage( ScopedMessage& duplicate ) = delete;
        ScopedMessage( ScopedMessage&& old );
        ~ScopedMessage();

        MessageInfo m_info;
        bool m_moved;
    };

    class Capturer {
        std::vector<MessageInfo> m_messages;
        IResultCapture& m_resultCapture = getResultCapture();
        size_t m_captured = 0;
    public:
        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
        ~Capturer();

        void captureValue( size_t index, std::string const& value );

        template<typename T>
        void captureValues( size_t index, T const& value ) {
            captureValue( index, Catch::Detail::stringify( value ) );
        }

        template<typename T, typename... Ts>
        void captureValues( size_t index, T const& value, Ts const&... values ) {
            captureValue( index, Catch::Detail::stringify(value) );
            captureValues( index+1, values... );
        }
    };

} // end namespace Catch

// end catch_message.h
#if !defined(CATCH_CONFIG_DISABLE)

#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
#else
  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
#endif

#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)

///////////////////////////////////////////////////////////////////////////////
// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
// macros.
#define INTERNAL_CATCH_TRY
#define INTERNAL_CATCH_CATCH( capturer )

#else // CATCH_CONFIG_FAST_COMPILE

#define INTERNAL_CATCH_TRY try
#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }

#endif

#define INTERNAL_CATCH_REACT( handler ) handler.complete();

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
    do { \
        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
        INTERNAL_CATCH_TRY { \
            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
    if( Catch::getResultCapture().lastAssertionPassed() )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
    if( !Catch::getResultCapture().lastAssertionPassed() )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
        try { \
            static_cast<void>(__VA_ARGS__); \
            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
        } \
        catch( ... ) { \
            catchAssertionHandler.handleUnexpectedInflightException(); \
        } \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                static_cast<void>(__VA_ARGS__); \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( ... ) { \
                catchAssertionHandler.handleExceptionThrownAsExpected(); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                static_cast<void>(expr); \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( exceptionType const& ) { \
                catchAssertionHandler.handleExceptionThrownAsExpected(); \
            } \
            catch( ... ) { \
                catchAssertionHandler.handleUnexpectedInflightException(); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
    varName.captureValues( 0, __VA_ARGS__ )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_INFO( macroName, log ) \
    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )

///////////////////////////////////////////////////////////////////////////////
// Although this is matcher-based, it can be used with just a string
#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                static_cast<void>(__VA_ARGS__); \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( ... ) { \
                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

#endif // CATCH_CONFIG_DISABLE

// end catch_capture.hpp
// start catch_section.h

// start catch_section_info.h

// start catch_totals.h

#include <cstddef>

namespace Catch {

    struct Counts {
        Counts operator - ( Counts const& other ) const;
        Counts& operator += ( Counts const& other );

        std::size_t total() const;
        bool allPassed() const;
        bool allOk() const;

        std::size_t passed = 0;
        std::size_t failed = 0;
        std::size_t failedButOk = 0;
    };

    struct Totals {

        Totals operator - ( Totals const& other ) const;
        Totals& operator += ( Totals const& other );

        Totals delta( Totals const& prevTotals ) const;

        int error = 0;
        Counts assertions;
        Counts testCases;
    };
}

// end catch_totals.h
#include <string>

namespace Catch {

    struct SectionInfo {
        SectionInfo
            (   SourceLineInfo const& _lineInfo,
                std::string const& _name );

        // Deprecated
        SectionInfo
            (   SourceLineInfo const& _lineInfo,
                std::string const& _name,
                std::string const& ) : SectionInfo( _lineInfo, _name ) {}

        std::string name;
        std::string description; // !Deprecated: this will always be empty
        SourceLineInfo lineInfo;
    };

    struct SectionEndInfo {
        SectionInfo sectionInfo;
        Counts prevAssertions;
        double durationInSeconds;
    };

} // end namespace Catch

// end catch_section_info.h
// start catch_timer.h

#include <cstdint>

namespace Catch {

    auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
    auto getEstimatedClockResolution() -> uint64_t;

    class Timer {
        uint64_t m_nanoseconds = 0;
    public:
        void start();
        auto getElapsedNanoseconds() const -> uint64_t;
        auto getElapsedMicroseconds() const -> uint64_t;
        auto getElapsedMilliseconds() const -> unsigned int;
        auto getElapsedSeconds() const -> double;
    };

} // namespace Catch

// end catch_timer.h
#include <string>

namespace Catch {

    class Section : NonCopyable {
    public:
        Section( SectionInfo const& info );
        ~Section();

        // This indicates whether the section should be executed or not
        explicit operator bool() const;

    private:
        SectionInfo m_info;

        std::string m_name;
        Counts m_assertions;
        bool m_sectionIncluded;
        Timer m_timer;
    };

} // end namespace Catch

#define INTERNAL_CATCH_SECTION( ... ) \
    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

// end catch_section.h
// start catch_interfaces_exception.h

// start catch_interfaces_registry_hub.h

#include <string>
#include <memory>

namespace Catch {

    class TestCase;
    struct ITestCaseRegistry;
    struct IExceptionTranslatorRegistry;
    struct IExceptionTranslator;
    struct IReporterRegistry;
    struct IReporterFactory;
    struct ITagAliasRegistry;
    struct IMutableEnumValuesRegistry;

    class StartupExceptionRegistry;

    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;

    struct IRegistryHub {
        virtual ~IRegistryHub();

        virtual IReporterRegistry const& getReporterRegistry() const = 0;
        virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
        virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;

        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
    };

    struct IMutableRegistryHub {
        virtual ~IMutableRegistryHub();
        virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
        virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
        virtual void registerTest( TestCase const& testInfo ) = 0;
        virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
        virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
        virtual void registerStartupException() noexcept = 0;
        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
    };

    IRegistryHub const& getRegistryHub();
    IMutableRegistryHub& getMutableRegistryHub();
    void cleanUp();
    std::string translateActiveException();

}

// end catch_interfaces_registry_hub.h
#if defined(CATCH_CONFIG_DISABLE)
    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
        static std::string translatorName( signature )
#endif

#include <exception>
#include <string>
#include <vector>

namespace Catch {
    using exceptionTranslateFunction = std::string(*)();

    struct IExceptionTranslator;
    using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;

    struct IExceptionTranslator {
        virtual ~IExceptionTranslator();
        virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
    };

    struct IExceptionTranslatorRegistry {
        virtual ~IExceptionTranslatorRegistry();

        virtual std::string translateActiveException() const = 0;
    };

    class ExceptionTranslatorRegistrar {
        template<typename T>
        class ExceptionTranslator : public IExceptionTranslator {
        public:

            ExceptionTranslator( std::string(*translateFunction)( T& ) )
            : m_translateFunction( translateFunction )
            {}

            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
                return "";
#else
                try {
                    if( it == itEnd )
                        std::rethrow_exception(std::current_exception());
                    else
                        return (*it)->translate( it+1, itEnd );
                }
                catch( T& ex ) {
                    return m_translateFunction( ex );
                }
#endif
            }

        protected:
            std::string(*m_translateFunction)( T& );
        };

    public:
        template<typename T>
        ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
            getMutableRegistryHub().registerTranslator
                ( new ExceptionTranslator<T>( translateFunction ) );
        }
    };
}

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
    static std::string translatorName( signature ); \
    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
    static std::string translatorName( signature )

#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )

// end catch_interfaces_exception.h
// start catch_approx.h

#include <type_traits>

namespace Catch {
namespace Detail {

    class Approx {
    private:
        bool equalityComparisonImpl(double other) const;
        // Validates the new margin (margin >= 0)
        // out-of-line to avoid including stdexcept in the header
        void setMargin(double margin);
        // Validates the new epsilon (0 < epsilon < 1)
        // out-of-line to avoid including stdexcept in the header
        void setEpsilon(double epsilon);

    public:
        explicit Approx ( double value );

        static Approx custom();

        Approx operator-() const;

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        Approx operator()( T const& value ) const {
            Approx approx( static_cast<double>(value) );
            approx.m_epsilon = m_epsilon;
            approx.m_margin = m_margin;
            approx.m_scale = m_scale;
            return approx;
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        explicit Approx( T const& value ): Approx(static_cast<double>(value))
        {}

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        friend bool operator == ( const T& lhs, Approx const& rhs ) {
            auto lhs_v = static_cast<double>(lhs);
            return rhs.equalityComparisonImpl(lhs_v);
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        friend bool operator == ( Approx const& lhs, const T& rhs ) {
            return operator==( rhs, lhs );
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        friend bool operator != ( T const& lhs, Approx const& rhs ) {
            return !operator==( lhs, rhs );
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        friend bool operator != ( Approx const& lhs, T const& rhs ) {
            return !operator==( rhs, lhs );
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        Approx& epsilon( T const& newEpsilon ) {
            double epsilonAsDouble = static_cast<double>(newEpsilon);
            setEpsilon(epsilonAsDouble);
            return *this;
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        Approx& margin( T const& newMargin ) {
            double marginAsDouble = static_cast<double>(newMargin);
            setMargin(marginAsDouble);
            return *this;
        }

        template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
        Approx& scale( T const& newScale ) {
            m_scale = static_cast<double>(newScale);
            return *this;
        }

        std::string toString() const;

    private:
        double m_epsilon;
        double m_margin;
        double m_scale;
        double m_value;
    };
} // end namespace Detail

namespace literals {
    Detail::Approx operator "" _a(long double val);
    Detail::Approx operator "" _a(unsigned long long val);
} // end namespace literals

template<>
struct StringMaker<Catch::Detail::Approx> {
    static std::string convert(Catch::Detail::Approx const& value);
};

} // end namespace Catch

// end catch_approx.h
// start catch_string_manip.h

#include <string>
#include <iosfwd>
#include <vector>

namespace Catch {

    bool startsWith( std::string const& s, std::string const& prefix );
    bool startsWith( std::string const& s, char prefix );
    bool endsWith( std::string const& s, std::string const& suffix );
    bool endsWith( std::string const& s, char suffix );
    bool contains( std::string const& s, std::string const& infix );
    void toLowerInPlace( std::string& s );
    std::string toLower( std::string const& s );
    //! Returns a new string without whitespace at the start/end
    std::string trim( std::string const& str );
    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
    StringRef trim(StringRef ref);

    // !!! Be aware, returns refs into original string - make sure original string outlives them
    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );

    struct pluralise {
        pluralise( std::size_t count, std::string const& label );

        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );

        std::size_t m_count;
        std::string m_label;
    };
}

// end catch_string_manip.h
#ifndef CATCH_CONFIG_DISABLE_MATCHERS
// start catch_capture_matchers.h

// start catch_matchers.h

#include <string>
#include <vector>

namespace Catch {
namespace Matchers {
    namespace Impl {

        template<typename ArgT> struct MatchAllOf;
        template<typename ArgT> struct MatchAnyOf;
        template<typename ArgT> struct MatchNotOf;

        class MatcherUntypedBase {
        public:
            MatcherUntypedBase() = default;
            MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
            MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
            std::string toString() const;

        protected:
            virtual ~MatcherUntypedBase();
            virtual std::string describe() const = 0;
            mutable std::string m_cachedToString;
        };

#ifdef __clang__
#    pragma clang diagnostic push
#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
#endif

        template<typename ObjectT>
        struct MatcherMethod {
            virtual bool match( ObjectT const& arg ) const = 0;
        };

#if defined(__OBJC__)
        // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
        // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
        template<>
        struct MatcherMethod<NSString*> {
            virtual bool match( NSString* arg ) const = 0;
        };
#endif

#ifdef __clang__
#    pragma clang diagnostic pop
#endif

        template<typename T>
        struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {

            MatchAllOf<T> operator && ( MatcherBase const& other ) const;
            MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
            MatchNotOf<T> operator ! () const;
        };

        template<typename ArgT>
        struct MatchAllOf : MatcherBase<ArgT> {
            bool match( ArgT const& arg ) const override {
                for( auto matcher : m_matchers ) {
                    if (!matcher->match(arg))
                        return false;
                }
                return true;
            }
            std::string describe() const override {
                std::string description;
                description.reserve( 4 + m_matchers.size()*32 );
                description += "( ";
                bool first = true;
                for( auto matcher : m_matchers ) {
                    if( first )
                        first = false;
                    else
                        description += " and ";
                    description += matcher->toString();
                }
                description += " )";
                return description;
            }

            MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
                auto copy(*this);
                copy.m_matchers.push_back( &other );
                return copy;
            }

            std::vector<MatcherBase<ArgT> const*> m_matchers;
        };
        template<typename ArgT>
        struct MatchAnyOf : MatcherBase<ArgT> {

            bool match( ArgT const& arg ) const override {
                for( auto matcher : m_matchers ) {
                    if (matcher->match(arg))
                        return true;
                }
                return false;
            }
            std::string describe() const override {
                std::string description;
                description.reserve( 4 + m_matchers.size()*32 );
                description += "( ";
                bool first = true;
                for( auto matcher : m_matchers ) {
                    if( first )
                        first = false;
                    else
                        description += " or ";
                    description += matcher->toString();
                }
                description += " )";
                return description;
            }

            MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
                auto copy(*this);
                copy.m_matchers.push_back( &other );
                return copy;
            }

            std::vector<MatcherBase<ArgT> const*> m_matchers;
        };

        template<typename ArgT>
        struct MatchNotOf : MatcherBase<ArgT> {

            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}

            bool match( ArgT const& arg ) const override {
                return !m_underlyingMatcher.match( arg );
            }

            std::string describe() const override {
                return "not " + m_underlyingMatcher.toString();
            }
            MatcherBase<ArgT> const& m_underlyingMatcher;
        };

        template<typename T>
        MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
            return MatchAllOf<T>() && *this && other;
        }
        template<typename T>
        MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
            return MatchAnyOf<T>() || *this || other;
        }
        template<typename T>
        MatchNotOf<T> MatcherBase<T>::operator ! () const {
            return MatchNotOf<T>( *this );
        }

    } // namespace Impl

} // namespace Matchers

using namespace Matchers;
using Matchers::Impl::MatcherBase;

} // namespace Catch

// end catch_matchers.h
// start catch_matchers_exception.hpp

namespace Catch {
namespace Matchers {
namespace Exception {

class ExceptionMessageMatcher : public MatcherBase<std::exception> {
    std::string m_message;
public:

    ExceptionMessageMatcher(std::string const& message):
        m_message(message)
    {}

    bool match(std::exception const& ex) const override;

    std::string describe() const override;
};

} // namespace Exception

Exception::ExceptionMessageMatcher Message(std::string const& message);

} // namespace Matchers
} // namespace Catch

// end catch_matchers_exception.hpp
// start catch_matchers_floating.h

namespace Catch {
namespace Matchers {

    namespace Floating {

        enum class FloatingPointKind : uint8_t;

        struct WithinAbsMatcher : MatcherBase<double> {
            WithinAbsMatcher(double target, double margin);
            bool match(double const& matchee) const override;
            std::string describe() const override;
        private:
            double m_target;
            double m_margin;
        };

        struct WithinUlpsMatcher : MatcherBase<double> {
            WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType);
            bool match(double const& matchee) const override;
            std::string describe() const override;
        private:
            double m_target;
            uint64_t m_ulps;
            FloatingPointKind m_type;
        };

        // Given IEEE-754 format for floats and doubles, we can assume
        // that float -> double promotion is lossless. Given this, we can
        // assume that if we do the standard relative comparison of
        // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
        // the same result if we do this for floats, as if we do this for
        // doubles that were promoted from floats.
        struct WithinRelMatcher : MatcherBase<double> {
            WithinRelMatcher(double target, double epsilon);
            bool match(double const& matchee) const override;
            std::string describe() const override;
        private:
            double m_target;
            double m_epsilon;
        };

    } // namespace Floating

    // The following functions create the actual matcher objects.
    // This allows the types to be inferred
    Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
    Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
    Floating::WithinAbsMatcher WithinAbs(double target, double margin);
    Floating::WithinRelMatcher WithinRel(double target, double eps);
    // defaults epsilon to 100*numeric_limits<double>::epsilon()
    Floating::WithinRelMatcher WithinRel(double target);
    Floating::WithinRelMatcher WithinRel(float target, float eps);
    // defaults epsilon to 100*numeric_limits<float>::epsilon()
    Floating::WithinRelMatcher WithinRel(float target);

} // namespace Matchers
} // namespace Catch

// end catch_matchers_floating.h
// start catch_matchers_generic.hpp

#include <functional>
#include <string>

namespace Catch {
namespace Matchers {
namespace Generic {

namespace Detail {
    std::string finalizeDescription(const std::string& desc);
}

template <typename T>
class PredicateMatcher : public MatcherBase<T> {
    std::function<bool(T const&)> m_predicate;
    std::string m_description;
public:

    PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
        :m_predicate(std::move(elem)),
        m_description(Detail::finalizeDescription(descr))
    {}

    bool match( T const& item ) const override {
        return m_predicate(item);
    }

    std::string describe() const override {
        return m_description;
    }
};

} // namespace Generic

    // The following functions create the actual matcher objects.
    // The user has to explicitly specify type to the function, because
    // inferring std::function<bool(T const&)> is hard (but possible) and
    // requires a lot of TMP.
    template<typename T>
    Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
        return Generic::PredicateMatcher<T>(predicate, description);
    }

} // namespace Matchers
} // namespace Catch

// end catch_matchers_generic.hpp
// start catch_matchers_string.h

#include <string>

namespace Catch {
namespace Matchers {

    namespace StdString {

        struct CasedString
        {
            CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity );
            std::string adjustString( std::string const& str ) const;
            std::string caseSensitivitySuffix() const;

            CaseSensitive::Choice m_caseSensitivity;
            std::string m_str;
        };

        struct StringMatcherBase : MatcherBase<std::string> {
            StringMatcherBase( std::string const& operation, CasedString const& comparator );
            std::string describe() const override;

            CasedString m_comparator;
            std::string m_operation;
        };

        struct EqualsMatcher : StringMatcherBase {
            EqualsMatcher( CasedString const& comparator );
            bool match( std::string const& source ) const override;
        };
        struct ContainsMatcher : StringMatcherBase {
            ContainsMatcher( CasedString const& comparator );
            bool match( std::string const& source ) const override;
        };
        struct StartsWithMatcher : StringMatcherBase {
            StartsWithMatcher( CasedString const& comparator );
            bool match( std::string const& source ) const override;
        };
        struct EndsWithMatcher : StringMatcherBase {
            EndsWithMatcher( CasedString const& comparator );
            bool match( std::string const& source ) const override;
        };

        struct RegexMatcher : MatcherBase<std::string> {
            RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
            bool match( std::string const& matchee ) const override;
            std::string describe() const override;

        private:
            std::string m_regex;
            CaseSensitive::Choice m_caseSensitivity;
        };

    } // namespace StdString

    // The following functions create the actual matcher objects.
    // This allows the types to be inferred

    StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
    StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
    StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
    StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
    StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );

} // namespace Matchers
} // namespace Catch

// end catch_matchers_string.h
// start catch_matchers_vector.h

#include <algorithm>

namespace Catch {
namespace Matchers {

    namespace Vector {
        template<typename T, typename Alloc>
        struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {

            ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}

            bool match(std::vector<T, Alloc> const &v) const override {
                for (auto const& el : v) {
                    if (el == m_comparator) {
                        return true;
                    }
                }
                return false;
            }

            std::string describe() const override {
                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
            }

            T const& m_comparator;
        };

        template<typename T, typename AllocComp, typename AllocMatch>
        struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {

            ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m_comparator( comparator ) {}

            bool match(std::vector<T, AllocMatch> const &v) const override {
                // !TBD: see note in EqualsMatcher
                if (m_comparator.size() > v.size())
                    return false;
                for (auto const& comparator : m_comparator) {
                    auto present = false;
                    for (const auto& el : v) {
                        if (el == comparator) {
                            present = true;
                            break;
                        }
                    }
                    if (!present) {
                        return false;
                    }
                }
                return true;
            }
            std::string describe() const override {
                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
            }

            std::vector<T, AllocComp> const& m_comparator;
        };

        template<typename T, typename AllocComp, typename AllocMatch>
        struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {

            EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_comparator( comparator ) {}

            bool match(std::vector<T, AllocMatch> const &v) const override {
                // !TBD: This currently works if all elements can be compared using !=
                // - a more general approach would be via a compare template that defaults
                // to using !=. but could be specialised for, e.g. std::vector<T, Alloc> etc
                // - then just call that directly
                if (m_comparator.size() != v.size())
                    return false;
                for (std::size_t i = 0; i < v.size(); ++i)
                    if (m_comparator[i] != v[i])
                        return false;
                return true;
            }
            std::string describe() const override {
                return "Equals: " + ::Catch::Detail::stringify( m_comparator );
            }
            std::vector<T, AllocComp> const& m_comparator;
        };

        template<typename T, typename AllocComp, typename AllocMatch>
        struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {

            ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_comparator( comparator ) {}

            bool match(std::vector<T, AllocMatch> const &v) const override {
                if (m_comparator.size() != v.size())
                    return false;
                for (std::size_t i = 0; i < v.size(); ++i)
                    if (m_comparator[i] != approx(v[i]))
                        return false;
                return true;
            }
            std::string describe() const override {
                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
            }
            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
            ApproxMatcher& epsilon( T const& newEpsilon ) {
                approx.epsilon(newEpsilon);
                return *this;
            }
            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
            ApproxMatcher& margin( T const& newMargin ) {
                approx.margin(newMargin);
                return *this;
            }
            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
            ApproxMatcher& scale( T const& newScale ) {
                approx.scale(newScale);
                return *this;
            }

            std::vector<T, AllocComp> const& m_comparator;
            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
        };

        template<typename T, typename AllocComp, typename AllocMatch>
        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
            UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) : m_target(target) {}
            bool match(std::vector<T, AllocMatch> const& vec) const override {
                if (m_target.size() != vec.size()) {
                    return false;
                }
                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
            }

            std::string describe() const override {
                return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
            }
        private:
            std::vector<T, AllocComp> const& m_target;
        };

    } // namespace Vector

    // The following functions create the actual matcher objects.
    // This allows the types to be inferred

    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
    Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vector<T, AllocComp> const& comparator ) {
        return Vector::ContainsMatcher<T, AllocComp, AllocMatch>( comparator );
    }

    template<typename T, typename Alloc = std::allocator<T>>
    Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& comparator ) {
        return Vector::ContainsElementMatcher<T, Alloc>( comparator );
    }

    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
    Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<T, AllocComp> const& comparator ) {
        return Vector::EqualsMatcher<T, AllocComp, AllocMatch>( comparator );
    }

    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
    Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<T, AllocComp> const& comparator ) {
        return Vector::ApproxMatcher<T, AllocComp, AllocMatch>( comparator );
    }

    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
    Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEquals(std::vector<T, AllocComp> const& target) {
        return Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch>( target );
    }

} // namespace Matchers
} // namespace Catch

// end catch_matchers_vector.h
namespace Catch {

    template<typename ArgT, typename MatcherT>
    class MatchExpr : public ITransientExpression {
        ArgT const& m_arg;
        MatcherT m_matcher;
        StringRef m_matcherString;
    public:
        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
        :   ITransientExpression{ true, matcher.match( arg ) },
            m_arg( arg ),
            m_matcher( matcher ),
            m_matcherString( matcherString )
        {}

        void streamReconstructedExpression( std::ostream &os ) const override {
            auto matcherAsString = m_matcher.toString();
            os << Catch::Detail::stringify( m_arg ) << ' ';
            if( matcherAsString == Detail::unprintableString )
                os << m_matcherString;
            else
                os << matcherAsString;
        }
    };

    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;

    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );

    template<typename ArgT, typename MatcherT>
    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
    }

} // namespace Catch

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
        INTERNAL_CATCH_TRY { \
            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                static_cast<void>(__VA_ARGS__ ); \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( exceptionType const& ex ) { \
                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
            } \
            catch( ... ) { \
                catchAssertionHandler.handleUnexpectedInflightException(); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

// end catch_capture_matchers.h
#endif
// start catch_generators.hpp

// start catch_interfaces_generatortracker.h


#include <memory>

namespace Catch {

    namespace Generators {
        class GeneratorUntypedBase {
        public:
            GeneratorUntypedBase() = default;
            virtual ~GeneratorUntypedBase();
            // Attempts to move the generator to the next element
             //
             // Returns true iff the move succeeded (and a valid element
             // can be retrieved).
            virtual bool next() = 0;
        };
        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;

    } // namespace Generators

    struct IGeneratorTracker {
        virtual ~IGeneratorTracker();
        virtual auto hasGenerator() const -> bool = 0;
        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
    };

} // namespace Catch

// end catch_interfaces_generatortracker.h
// start catch_enforce.h

#include <exception>

namespace Catch {
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
    template <typename Ex>
    [[noreturn]]
    void throw_exception(Ex const& e) {
        throw e;
    }
#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
    [[noreturn]]
    void throw_exception(std::exception const& e);
#endif

    [[noreturn]]
    void throw_logic_error(std::string const& msg);
    [[noreturn]]
    void throw_domain_error(std::string const& msg);
    [[noreturn]]
    void throw_runtime_error(std::string const& msg);

} // namespace Catch;

#define CATCH_MAKE_MSG(...) \
    (Catch::ReusableStringStream() << __VA_ARGS__).str()

#define CATCH_INTERNAL_ERROR(...) \
    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))

#define CATCH_ERROR(...) \
    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))

#define CATCH_RUNTIME_ERROR(...) \
    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))

#define CATCH_ENFORCE( condition, ... ) \
    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)

// end catch_enforce.h
#include <memory>
#include <vector>
#include <cassert>

#include <utility>
#include <exception>

namespace Catch {

class GeneratorException : public std::exception {
    const char* const m_msg = "";

public:
    GeneratorException(const char* msg):
        m_msg(msg)
    {}

    const char* what() const noexcept override final;
};

namespace Generators {

    // !TBD move this into its own location?
    namespace pf{
        template<typename T, typename... Args>
        std::unique_ptr<T> make_unique( Args&&... args ) {
            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
        }
    }

    template<typename T>
    struct IGenerator : GeneratorUntypedBase {
        virtual ~IGenerator() = default;

        // Returns the current element of the generator
        //
        // \Precondition The generator is either freshly constructed,
        // or the last call to `next()` returned true
        virtual T const& get() const = 0;
        using type = T;
    };

    template<typename T>
    class SingleValueGenerator final : public IGenerator<T> {
        T m_value;
    public:
        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}

        T const& get() const override {
            return m_value;
        }
        bool next() override {
            return false;
        }
    };

    template<typename T>
    class FixedValuesGenerator final : public IGenerator<T> {
        static_assert(!std::is_same<T, bool>::value,
            "FixedValuesGenerator does not support bools because of std::vector<bool>"
            "specialization, use SingleValue Generator instead.");
        std::vector<T> m_values;
        size_t m_idx = 0;
    public:
        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}

        T const& get() const override {
            return m_values[m_idx];
        }
        bool next() override {
            ++m_idx;
            return m_idx < m_values.size();
        }
    };

    template <typename T>
    class GeneratorWrapper final {
        std::unique_ptr<IGenerator<T>> m_generator;
    public:
        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
            m_generator(std::move(generator))
        {}
        T const& get() const {
            return m_generator->get();
        }
        bool next() {
            return m_generator->next();
        }
    };

    template <typename T>
    GeneratorWrapper<T> value(T&& value) {
        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
    }
    template <typename T>
    GeneratorWrapper<T> values(std::initializer_list<T> values) {
        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
    }

    template<typename T>
    class Generators : public IGenerator<T> {
        std::vector<GeneratorWrapper<T>> m_generators;
        size_t m_current = 0;

        void populate(GeneratorWrapper<T>&& generator) {
            m_generators.emplace_back(std::move(generator));
        }
        void populate(T&& val) {
            m_generators.emplace_back(value(std::forward<T>(val)));
        }
        template<typename U>
        void populate(U&& val) {
            populate(T(std::forward<U>(val)));
        }
        template<typename U, typename... Gs>
        void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
            populate(std::forward<U>(valueOrGenerator));
            populate(std::forward<Gs>(moreGenerators)...);
        }

    public:
        template <typename... Gs>
        Generators(Gs &&... moreGenerators) {
            m_generators.reserve(sizeof...(Gs));
            populate(std::forward<Gs>(moreGenerators)...);
        }

        T const& get() const override {
            return m_generators[m_current].get();
        }

        bool next() override {
            if (m_current >= m_generators.size()) {
                return false;
            }
            const bool current_status = m_generators[m_current].next();
            if (!current_status) {
                ++m_current;
            }
            return m_current < m_generators.size();
        }
    };

    template<typename... Ts>
    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
        return values<std::tuple<Ts...>>( tuples );
    }

    // Tag type to signal that a generator sequence should convert arguments to a specific type
    template <typename T>
    struct as {};

    template<typename T, typename... Gs>
    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
    }
    template<typename T>
    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
        return Generators<T>(std::move(generator));
    }
    template<typename T, typename... Gs>
    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<T> {
        return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
    }
    template<typename T, typename U, typename... Gs>
    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
        return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
    }

    auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;

    template<typename L>
    // Note: The type after -> is weird, because VS2015 cannot parse
    //       the expression used in the typedef inside, when it is in
    //       return type. Yeah.
    auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
        using UnderlyingType = typename decltype(generatorExpression())::type;

        IGeneratorTracker& tracker = acquireGeneratorTracker( generatorName, lineInfo );
        if (!tracker.hasGenerator()) {
            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
        }

        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
        return generator.get();
    }

} // namespace Generators
} // namespace Catch

#define GENERATE( ... ) \
    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
                                 CATCH_INTERNAL_LINEINFO, \
                                 [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
#define GENERATE_COPY( ... ) \
    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
                                 CATCH_INTERNAL_LINEINFO, \
                                 [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
#define GENERATE_REF( ... ) \
    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
                                 CATCH_INTERNAL_LINEINFO, \
                                 [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)

// end catch_generators.hpp
// start catch_generators_generic.hpp

namespace Catch {
namespace Generators {

    template <typename T>
    class TakeGenerator : public IGenerator<T> {
        GeneratorWrapper<T> m_generator;
        size_t m_returned = 0;
        size_t m_target;
    public:
        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
            m_generator(std::move(generator)),
            m_target(target)
        {
            assert(target != 0 && "Empty generators are not allowed");
        }
        T const& get() const override {
            return m_generator.get();
        }
        bool next() override {
            ++m_returned;
            if (m_returned >= m_target) {
                return false;
            }

            const auto success = m_generator.next();
            // If the underlying generator does not contain enough values
            // then we cut short as well
            if (!success) {
                m_returned = m_target;
            }
            return success;
        }
    };

    template <typename T>
    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
    }

    template <typename T, typename Predicate>
    class FilterGenerator : public IGenerator<T> {
        GeneratorWrapper<T> m_generator;
        Predicate m_predicate;
    public:
        template <typename P = Predicate>
        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
            m_generator(std::move(generator)),
            m_predicate(std::forward<P>(pred))
        {
            if (!m_predicate(m_generator.get())) {
                // It might happen that there are no values that pass the
                // filter. In that case we throw an exception.
                auto has_initial_value = nextImpl();
                if (!has_initial_value) {
                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
                }
            }
        }

        T const& get() const override {
            return m_generator.get();
        }

        bool next() override {
            return nextImpl();
        }

    private:
        bool nextImpl() {
            bool success = m_generator.next();
            if (!success) {
                return false;
            }
            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
            return success;
        }
    };

    template <typename T, typename Predicate>
    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
    }

    template <typename T>
    class RepeatGenerator : public IGenerator<T> {
        static_assert(!std::is_same<T, bool>::value,
            "RepeatGenerator currently does not support bools"
            "because of std::vector<bool> specialization");
        GeneratorWrapper<T> m_generator;
        mutable std::vector<T> m_returned;
        size_t m_target_repeats;
        size_t m_current_repeat = 0;
        size_t m_repeat_index = 0;
    public:
        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
            m_generator(std::move(generator)),
            m_target_repeats(repeats)
        {
            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
        }

        T const& get() const override {
            if (m_current_repeat == 0) {
                m_returned.push_back(m_generator.get());
                return m_returned.back();
            }
            return m_returned[m_repeat_index];
        }

        bool next() override {
            // There are 2 basic cases:
            // 1) We are still reading the generator
            // 2) We are reading our own cache

            // In the first case, we need to poke the underlying generator.
            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
            if (m_current_repeat == 0) {
                const auto success = m_generator.next();
                if (!success) {
                    ++m_current_repeat;
                }
                return m_current_repeat < m_target_repeats;
            }

            // In the second case, we need to move indices forward and check that we haven't run up against the end
            ++m_repeat_index;
            if (m_repeat_index == m_returned.size()) {
                m_repeat_index = 0;
                ++m_current_repeat;
            }
            return m_current_repeat < m_target_repeats;
        }
    };

    template <typename T>
    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
    }

    template <typename T, typename U, typename Func>
    class MapGenerator : public IGenerator<T> {
        // TBD: provide static assert for mapping function, for friendly error message
        GeneratorWrapper<U> m_generator;
        Func m_function;
        // To avoid returning dangling reference, we have to save the values
        T m_cache;
    public:
        template <typename F2 = Func>
        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
            m_generator(std::move(generator)),
            m_function(std::forward<F2>(function)),
            m_cache(m_function(m_generator.get()))
        {}

        T const& get() const override {
            return m_cache;
        }
        bool next() override {
            const auto success = m_generator.next();
            if (success) {
                m_cache = m_function(m_generator.get());
            }
            return success;
        }
    };

    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
        return GeneratorWrapper<T>(
            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
        );
    }

    template <typename T, typename U, typename Func>
    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
        return GeneratorWrapper<T>(
            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
        );
    }

    template <typename T>
    class ChunkGenerator final : public IGenerator<std::vector<T>> {
        std::vector<T> m_chunk;
        size_t m_chunk_size;
        GeneratorWrapper<T> m_generator;
        bool m_used_up = false;
    public:
        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
            m_chunk_size(size), m_generator(std::move(generator))
        {
            m_chunk.reserve(m_chunk_size);
            if (m_chunk_size != 0) {
                m_chunk.push_back(m_generator.get());
                for (size_t i = 1; i < m_chunk_size; ++i) {
                    if (!m_generator.next()) {
                        Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
                    }
                    m_chunk.push_back(m_generator.get());
                }
            }
        }
        std::vector<T> const& get() const override {
            return m_chunk;
        }
        bool next() override {
            m_chunk.clear();
            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
                if (!m_generator.next()) {
                    return false;
                }
                m_chunk.push_back(m_generator.get());
            }
            return true;
        }
    };

    template <typename T>
    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
        return GeneratorWrapper<std::vector<T>>(
            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
        );
    }

} // namespace Generators
} // namespace Catch

// end catch_generators_generic.hpp
// start catch_generators_specific.hpp

// start catch_context.h

#include <memory>

namespace Catch {

    struct IResultCapture;
    struct IRunner;
    struct IConfig;
    struct IMutableContext;

    using IConfigPtr = std::shared_ptr<IConfig const>;

    struct IContext
    {
        virtual ~IContext();

        virtual IResultCapture* getResultCapture() = 0;
        virtual IRunner* getRunner() = 0;
        virtual IConfigPtr const& getConfig() const = 0;
    };

    struct IMutableContext : IContext
    {
        virtual ~IMutableContext();
        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
        virtual void setRunner( IRunner* runner ) = 0;
        virtual void setConfig( IConfigPtr const& config ) = 0;

    private:
        static IMutableContext *currentContext;
        friend IMutableContext& getCurrentMutableContext();
        friend void cleanUpContext();
        static void createContext();
    };

    inline IMutableContext& getCurrentMutableContext()
    {
        if( !IMutableContext::currentContext )
            IMutableContext::createContext();
        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
        return *IMutableContext::currentContext;
    }

    inline IContext& getCurrentContext()
    {
        return getCurrentMutableContext();
    }

    void cleanUpContext();

    class SimplePcg32;
    SimplePcg32& rng();
}

// end catch_context.h
// start catch_interfaces_config.h

// start catch_option.hpp

namespace Catch {

    // An optional type
    template<typename T>
    class Option {
    public:
        Option() : nullableValue( nullptr ) {}
        Option( T const& _value )
        : nullableValue( new( storage ) T( _value ) )
        {}
        Option( Option const& _other )
        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
        {}

        ~Option() {
            reset();
        }

        Option& operator= ( Option const& _other ) {
            if( &_other != this ) {
                reset();
                if( _other )
                    nullableValue = new( storage ) T( *_other );
            }
            return *this;
        }
        Option& operator = ( T const& _value ) {
            reset();
            nullableValue = new( storage ) T( _value );
            return *this;
        }

        void reset() {
            if( nullableValue )
                nullableValue->~T();
            nullableValue = nullptr;
        }

        T& operator*() { return *nullableValue; }
        T const& operator*() const { return *nullableValue; }
        T* operator->() { return nullableValue; }
        const T* operator->() const { return nullableValue; }

        T valueOr( T const& defaultValue ) const {
            return nullableValue ? *nullableValue : defaultValue;
        }

        bool some() const { return nullableValue != nullptr; }
        bool none() const { return nullableValue == nullptr; }

        bool operator !() const { return nullableValue == nullptr; }
        explicit operator bool() const {
            return some();
        }

    private:

Download .txt

gitextract_mca2lcic/

├── .clang-format
├── .github/
│   └── workflows/
│       └── main.yml
├── .gitignore
├── LICENSE
├── README.md
├── cpptime.h
└── tests/
    ├── catch.hpp
    └── timer_test.cpp

Copy disabled (too large) Download .txt

Showing preview only (376,758K chars total). Download the full file to get everything.

SYMBOL INDEX (1462 symbols across 3 files)

FILE: cpptime.h
  function namespace (line 110) | namespace CppTime
  function timer_id (line 209) | timer_id add(
  function timer_id (line 237) | timer_id add(const std::chrono::duration<Rep, Period> &when, handler_t &...
  function remove (line 256) | bool remove(timer_id id)

FILE: tests/catch.hpp
  type Catch (line 98) | namespace Catch {
    type CaseSensitive (line 486) | struct CaseSensitive { enum Choice {
      type Choice (line 486) | enum Choice {
    class NonCopyable (line 491) | class NonCopyable {
      method NonCopyable (line 492) | NonCopyable( NonCopyable const& )              = delete;
      method NonCopyable (line 493) | NonCopyable( NonCopyable && )                  = delete;
      method NonCopyable (line 494) | NonCopyable& operator = ( NonCopyable const& ) = delete;
      method NonCopyable (line 495) | NonCopyable& operator = ( NonCopyable && )     = delete;
    type SourceLineInfo (line 502) | struct SourceLineInfo {
      method SourceLineInfo (line 504) | SourceLineInfo() = delete;
      method SourceLineInfo (line 505) | SourceLineInfo( char const* _file, std::size_t _line ) noexcept
      method SourceLineInfo (line 510) | SourceLineInfo( SourceLineInfo const& other )            = default;
      method SourceLineInfo (line 511) | SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
      method SourceLineInfo (line 512) | SourceLineInfo( SourceLineInfo&& )              noexcept = default;
      method SourceLineInfo (line 513) | SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
      method empty (line 515) | bool empty() const noexcept { return file[0] == '\0'; }
    type StreamEndStop (line 534) | struct StreamEndStop {
    function T (line 538) | T const& operator + ( T const& value, StreamEndStop ) {
    type RegistrarForTagAliases (line 549) | struct RegistrarForTagAliases {
    class TestSpec (line 570) | class TestSpec
      class Pattern (line 5112) | class Pattern {
      class NamePattern (line 5123) | class NamePattern : public Pattern {
      class TagPattern (line 5131) | class TagPattern : public Pattern {
      class ExcludedPattern (line 5139) | class ExcludedPattern : public Pattern {
      type Filter (line 5147) | struct Filter {
      type FilterMatch (line 5155) | struct FilterMatch {
    type ITestInvoker (line 572) | struct ITestInvoker {
    class TestCase (line 577) | class TestCase
    type IConfig (line 578) | struct IConfig
    type ITestCaseRegistry (line 580) | struct ITestCaseRegistry {
    class StringRef (line 606) | class StringRef {
      method StringRef (line 618) | constexpr StringRef() noexcept = default;
      method StringRef (line 622) | constexpr StringRef( char const* rawChars, size_type size ) noexcept
      method StringRef (line 627) | StringRef( std::string const& stdString ) noexcept
      method empty (line 648) | constexpr auto empty() const noexcept -> bool {
      method size (line 651) | constexpr auto size() const noexcept -> size_type {
      method isNullTerminated (line 668) | constexpr auto isNullTerminated() const noexcept -> bool {
      method const_iterator (line 673) | constexpr const_iterator begin() const { return m_start; }
      method const_iterator (line 674) | constexpr const_iterator end() const { return m_start + m_size; }
    type always_false (line 925) | struct always_false : std::false_type {}
    type true_given (line 927) | struct true_given : std::true_type {}
    type is_callable_tester (line 928) | struct is_callable_tester {
    type is_callable (line 936) | struct is_callable
    class TestInvokerAsMethod (line 962) | class TestInvokerAsMethod : public ITestInvoker {
      method TestInvokerAsMethod (line 965) | TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAs...
      method invoke (line 967) | void invoke() const override {
    function makeTestInvoker (line 976) | auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInv...
    type NameAndTags (line 980) | struct NameAndTags {
    type AutoReg (line 986) | struct AutoReg : NonCopyable {
    type ResultWas (line 1353) | struct ResultWas { enum OfType {
      type OfType (line 1353) | enum OfType {
    type ResultDisposition (line 1377) | struct ResultDisposition { enum Flags {
      type Flags (line 1377) | enum Flags {
    function isFalseTest (line 1388) | inline bool isFalseTest( int flags ) { return ( flags & ResultDisposit...
    type AssertionInfo (line 1396) | struct AssertionInfo
    class StringRef (line 1431) | class StringRef
      method StringRef (line 618) | constexpr StringRef() noexcept = default;
      method StringRef (line 622) | constexpr StringRef( char const* rawChars, size_type size ) noexcept
      method StringRef (line 627) | StringRef( std::string const& stdString ) noexcept
      method empty (line 648) | constexpr auto empty() const noexcept -> bool {
      method size (line 651) | constexpr auto size() const noexcept -> size_type {
      method isNullTerminated (line 668) | constexpr auto isNullTerminated() const noexcept -> bool {
      method const_iterator (line 673) | constexpr const_iterator begin() const { return m_start; }
      method const_iterator (line 674) | constexpr const_iterator end() const { return m_start + m_size; }
    type IStream (line 1433) | struct IStream {
    class ReusableStringStream (line 1440) | class ReusableStringStream : NonCopyable {
      method get (line 1454) | auto get() -> std::ostream& { return *m_oss; }
    type Detail (line 1465) | namespace Detail {
      type EnumInfo (line 1466) | struct EnumInfo {
      function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 1564) | class IsStreamInsertable {
      function convertUnstreamable (line 1580) | typename std::enable_if<
      function convertUnstreamable (line 1586) | typename std::enable_if<
      function convertUnstreamable (line 1593) | typename std::enable_if<
      function stringify (line 1644) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
      function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
        method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 3078) | class Approx {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7885) | Approx Approx::custom() {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7889) | Approx Approx::operator-() const {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
      function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
      function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
      function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
      function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
      function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
      class StreamBufImpl (line 13645) | class StreamBufImpl : public std::streambuf {
        method StreamBufImpl (line 13650) | StreamBufImpl() {
        method overflow (line 13659) | int overflow( int c ) override {
        method sync (line 13671) | int sync() override {
      type OutputDebugWriter (line 13682) | struct OutputDebugWriter {
      class FileStream (line 13691) | class FileStream : public IStream {
        method FileStream (line 13694) | FileStream( StringRef filename ) {
      class CoutStream (line 13707) | class CoutStream : public IStream {
        method CoutStream (line 13712) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
      class DebugOutStream (line 13721) | class DebugOutStream : public IStream {
        method DebugOutStream (line 13725) | DebugOutStream()
      type Endianness (line 15025) | struct Endianness {
        type Arch (line 15026) | enum Arch { Big, Little }
        method Arch (line 15028) | static Arch which() {
      function rawMemoryToString (line 15038) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type IMutableEnumValuesRegistry (line 1476) | struct IMutableEnumValuesRegistry {
    type Detail (line 1552) | namespace Detail {
      type EnumInfo (line 1466) | struct EnumInfo {
      function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 1564) | class IsStreamInsertable {
      function convertUnstreamable (line 1580) | typename std::enable_if<
      function convertUnstreamable (line 1586) | typename std::enable_if<
      function convertUnstreamable (line 1593) | typename std::enable_if<
      function stringify (line 1644) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
      function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
        method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 3078) | class Approx {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7885) | Approx Approx::custom() {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7889) | Approx Approx::operator-() const {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
      function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
      function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
      function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
      function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
      function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
      class StreamBufImpl (line 13645) | class StreamBufImpl : public std::streambuf {
        method StreamBufImpl (line 13650) | StreamBufImpl() {
        method overflow (line 13659) | int overflow( int c ) override {
        method sync (line 13671) | int sync() override {
      type OutputDebugWriter (line 13682) | struct OutputDebugWriter {
      class FileStream (line 13691) | class FileStream : public IStream {
        method FileStream (line 13694) | FileStream( StringRef filename ) {
      class CoutStream (line 13707) | class CoutStream : public IStream {
        method CoutStream (line 13712) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
      class DebugOutStream (line 13721) | class DebugOutStream : public IStream {
        method DebugOutStream (line 13725) | DebugOutStream()
      type Endianness (line 15025) | struct Endianness {
        type Arch (line 15026) | enum Arch { Big, Little }
        method Arch (line 15028) | static Arch which() {
      function rawMemoryToString (line 15038) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type StringMaker (line 1615) | struct StringMaker {
      method convert (line 1617) | static
      method convert (line 1628) | static
    type Detail (line 1639) | namespace Detail {
      type EnumInfo (line 1466) | struct EnumInfo {
      function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 1564) | class IsStreamInsertable {
      function convertUnstreamable (line 1580) | typename std::enable_if<
      function convertUnstreamable (line 1586) | typename std::enable_if<
      function convertUnstreamable (line 1593) | typename std::enable_if<
      function stringify (line 1644) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
      function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
        method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 3078) | class Approx {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7885) | Approx Approx::custom() {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7889) | Approx Approx::operator-() const {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
      function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
      function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
      function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
      function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
      function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
      class StreamBufImpl (line 13645) | class StreamBufImpl : public std::streambuf {
        method StreamBufImpl (line 13650) | StreamBufImpl() {
        method overflow (line 13659) | int overflow( int c ) override {
        method sync (line 13671) | int sync() override {
      type OutputDebugWriter (line 13682) | struct OutputDebugWriter {
      class FileStream (line 13691) | class FileStream : public IStream {
        method FileStream (line 13694) | FileStream( StringRef filename ) {
      class CoutStream (line 13707) | class CoutStream : public IStream {
        method CoutStream (line 13712) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
      class DebugOutStream (line 13721) | class DebugOutStream : public IStream {
        method DebugOutStream (line 13725) | DebugOutStream()
      type Endianness (line 15025) | struct Endianness {
        type Arch (line 15026) | enum Arch { Big, Little }
        method Arch (line 15028) | static Arch which() {
      function rawMemoryToString (line 15038) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type StringMaker<std::string> (line 1665) | struct StringMaker<std::string> {
    type StringMaker<std::string_view> (line 1671) | struct StringMaker<std::string_view> {
    type StringMaker<char const *> (line 1677) | struct StringMaker<char const *> {
    type StringMaker<char *> (line 1681) | struct StringMaker<char *> {
    type StringMaker<std::wstring> (line 1687) | struct StringMaker<std::wstring> {
    type StringMaker<std::wstring_view> (line 1693) | struct StringMaker<std::wstring_view> {
    type StringMaker<wchar_t const *> (line 1699) | struct StringMaker<wchar_t const *> {
    type StringMaker<wchar_t *> (line 1703) | struct StringMaker<wchar_t *> {
    type StringMaker<char[SZ]> (line 1711) | struct StringMaker<char[SZ]> {
      method convert (line 1712) | static std::string convert(char const* str) {
    type StringMaker<signed char[SZ]> (line 1717) | struct StringMaker<signed char[SZ]> {
      method convert (line 1718) | static std::string convert(signed char const* str) {
    type StringMaker<unsigned char[SZ]> (line 1723) | struct StringMaker<unsigned char[SZ]> {
      method convert (line 1724) | static std::string convert(unsigned char const* str) {
    type StringMaker<std::byte> (line 1731) | struct StringMaker<std::byte> {
    type StringMaker<int> (line 1736) | struct StringMaker<int> {
    type StringMaker<long> (line 1740) | struct StringMaker<long> {
    type StringMaker<long long> (line 1744) | struct StringMaker<long long> {
    type StringMaker<unsigned int> (line 1748) | struct StringMaker<unsigned int> {
    type StringMaker<unsigned long> (line 1752) | struct StringMaker<unsigned long> {
    type StringMaker<unsigned long long> (line 1756) | struct StringMaker<unsigned long long> {
    type StringMaker<bool> (line 1761) | struct StringMaker<bool> {
    type StringMaker<char> (line 1766) | struct StringMaker<char> {
    type StringMaker<signed char> (line 1770) | struct StringMaker<signed char> {
    type StringMaker<unsigned char> (line 1774) | struct StringMaker<unsigned char> {
    type StringMaker<std::nullptr_t> (line 1779) | struct StringMaker<std::nullptr_t> {
    type StringMaker<float> (line 1784) | struct StringMaker<float> {
    type StringMaker<double> (line 1790) | struct StringMaker<double> {
    type StringMaker<T*> (line 1796) | struct StringMaker<T*> {
      method convert (line 1798) | static std::string convert(U* p) {
    type StringMaker<R C::*> (line 1808) | struct StringMaker<R C::*> {
      method convert (line 1809) | static std::string convert(R C::* p) {
    type StringMaker<T^> (line 1820) | struct StringMaker<T^> {
      method convert (line 1821) | static std::string convert( T^ ref ) {
    type Detail (line 1827) | namespace Detail {
      type EnumInfo (line 1466) | struct EnumInfo {
      function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 1564) | class IsStreamInsertable {
      function convertUnstreamable (line 1580) | typename std::enable_if<
      function convertUnstreamable (line 1586) | typename std::enable_if<
      function convertUnstreamable (line 1593) | typename std::enable_if<
      function stringify (line 1644) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
      function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
        method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 3078) | class Approx {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7885) | Approx Approx::custom() {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7889) | Approx Approx::operator-() const {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
      function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
      function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
      function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
      function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
      function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
      class StreamBufImpl (line 13645) | class StreamBufImpl : public std::streambuf {
        method StreamBufImpl (line 13650) | StreamBufImpl() {
        method overflow (line 13659) | int overflow( int c ) override {
        method sync (line 13671) | int sync() override {
      type OutputDebugWriter (line 13682) | struct OutputDebugWriter {
      class FileStream (line 13691) | class FileStream : public IStream {
        method FileStream (line 13694) | FileStream( StringRef filename ) {
      class CoutStream (line 13707) | class CoutStream : public IStream {
        method CoutStream (line 13712) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
      class DebugOutStream (line 13721) | class DebugOutStream : public IStream {
        method DebugOutStream (line 13725) | DebugOutStream()
      type Endianness (line 15025) | struct Endianness {
        type Arch (line 15026) | enum Arch { Big, Little }
        method Arch (line 15028) | static Arch which() {
      function rawMemoryToString (line 15038) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type StringMaker<NSString*> (line 1844) | struct StringMaker<NSString*> {
      method convert (line 1845) | static std::string convert(NSString * nsstring) {
    type StringMaker<NSObject*> (line 1852) | struct StringMaker<NSObject*> {
      method convert (line 1853) | static std::string convert(NSObject* nsObject) {
    type Detail (line 1858) | namespace Detail {
      type EnumInfo (line 1466) | struct EnumInfo {
      function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 1564) | class IsStreamInsertable {
      function convertUnstreamable (line 1580) | typename std::enable_if<
      function convertUnstreamable (line 1586) | typename std::enable_if<
      function convertUnstreamable (line 1593) | typename std::enable_if<
      function stringify (line 1644) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
      function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
        method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 3078) | class Approx {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7885) | Approx Approx::custom() {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7889) | Approx Approx::operator-() const {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
      function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
      function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
      function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
      function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
      function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
      class StreamBufImpl (line 13645) | class StreamBufImpl : public std::streambuf {
        method StreamBufImpl (line 13650) | StreamBufImpl() {
        method overflow (line 13659) | int overflow( int c ) override {
        method sync (line 13671) | int sync() override {
      type OutputDebugWriter (line 13682) | struct OutputDebugWriter {
      class FileStream (line 13691) | class FileStream : public IStream {
        method FileStream (line 13694) | FileStream( StringRef filename ) {
      class CoutStream (line 13707) | class CoutStream : public IStream {
        method CoutStream (line 13712) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
      class DebugOutStream (line 13721) | class DebugOutStream : public IStream {
        method DebugOutStream (line 13725) | DebugOutStream()
      type Endianness (line 15025) | struct Endianness {
        type Arch (line 15026) | enum Arch { Big, Little }
        method Arch (line 15028) | static Arch which() {
      function rawMemoryToString (line 15038) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type StringMaker<std::pair<T1, T2> > (line 1885) | struct StringMaker<std::pair<T1, T2> > {
      method convert (line 1886) | static std::string convert(const std::pair<T1, T2>& pair) {
    type StringMaker<std::optional<T> > (line 1903) | struct StringMaker<std::optional<T> > {
      method convert (line 1904) | static std::string convert(const std::optional<T>& optional) {
    type Detail (line 1921) | namespace Detail {
      type EnumInfo (line 1466) | struct EnumInfo {
      function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 1564) | class IsStreamInsertable {
      function convertUnstreamable (line 1580) | typename std::enable_if<
      function convertUnstreamable (line 1586) | typename std::enable_if<
      function convertUnstreamable (line 1593) | typename std::enable_if<
      function stringify (line 1644) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
      function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
        method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 3078) | class Approx {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7885) | Approx Approx::custom() {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7889) | Approx Approx::operator-() const {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
      function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
      function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
      function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
      function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
      function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
      class StreamBufImpl (line 13645) | class StreamBufImpl : public std::streambuf {
        method StreamBufImpl (line 13650) | StreamBufImpl() {
        method overflow (line 13659) | int overflow( int c ) override {
        method sync (line 13671) | int sync() override {
      type OutputDebugWriter (line 13682) | struct OutputDebugWriter {
      class FileStream (line 13691) | class FileStream : public IStream {
        method FileStream (line 13694) | FileStream( StringRef filename ) {
      class CoutStream (line 13707) | class CoutStream : public IStream {
        method CoutStream (line 13712) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
      class DebugOutStream (line 13721) | class DebugOutStream : public IStream {
        method DebugOutStream (line 13725) | DebugOutStream()
      type Endianness (line 15025) | struct Endianness {
        type Arch (line 15026) | enum Arch { Big, Little }
        method Arch (line 15028) | static Arch which() {
      function rawMemoryToString (line 15038) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type StringMaker<std::monostate> (line 1962) | struct StringMaker<std::monostate> {
      method convert (line 1963) | static std::string convert(const std::monostate&) {
    type detail (line 1991) | namespace detail {
      type void_type (line 1993) | struct void_type {
      type is_range_impl (line 1998) | struct is_range_impl : std::false_type {
      type is_range_impl<T, typename void_type<decltype(begin(std::declval<T>()))>::type> (line 2002) | struct is_range_impl<T, typename void_type<decltype(begin(std::declv...
    type is_range (line 2007) | struct is_range : detail::is_range_impl<T> {
    type is_range<T^> (line 2012) | struct is_range<T^> {
    function rangeToString (line 2018) | std::string rangeToString( Range const& range ) {
    function rangeToString (line 2024) | std::string rangeToString( std::vector<bool, Allocator> const& v ) {
    type StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> (line 2040) | struct StringMaker<R, typename std::enable_if<is_range<R>::value && !:...
      method convert (line 2041) | static std::string convert( R const& range ) {
    type StringMaker<T[SZ]> (line 2047) | struct StringMaker<T[SZ]> {
      method convert (line 2048) | static std::string convert(T const(&arr)[SZ]) {
    type ratio_string (line 2064) | struct ratio_string {
    type ratio_string<std::atto> (line 2076) | struct ratio_string<std::atto> {
    type ratio_string<std::femto> (line 2080) | struct ratio_string<std::femto> {
    type ratio_string<std::pico> (line 2084) | struct ratio_string<std::pico> {
    type ratio_string<std::nano> (line 2088) | struct ratio_string<std::nano> {
    type ratio_string<std::micro> (line 2092) | struct ratio_string<std::micro> {
    type ratio_string<std::milli> (line 2096) | struct ratio_string<std::milli> {
    type StringMaker<std::chrono::duration<Value, Ratio>> (line 2103) | struct StringMaker<std::chrono::duration<Value, Ratio>> {
      method convert (line 2104) | static std::string convert(std::chrono::duration<Value, Ratio> const...
    type StringMaker<std::chrono::duration<Value, std::ratio<1>>> (line 2111) | struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
      method convert (line 2112) | static std::string convert(std::chrono::duration<Value, std::ratio<1...
    type StringMaker<std::chrono::duration<Value, std::ratio<60>>> (line 2119) | struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
      method convert (line 2120) | static std::string convert(std::chrono::duration<Value, std::ratio<6...
    type StringMaker<std::chrono::duration<Value, std::ratio<3600>>> (line 2127) | struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
      method convert (line 2128) | static std::string convert(std::chrono::duration<Value, std::ratio<3...
    type StringMaker<std::chrono::time_point<Clock, Duration>> (line 2139) | struct StringMaker<std::chrono::time_point<Clock, Duration>> {
      method convert (line 2140) | static std::string convert(std::chrono::time_point<Clock, Duration> ...
    type StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> (line 2146) | struct StringMaker<std::chrono::time_point<std::chrono::system_clock, ...
      method convert (line 2147) | static std::string convert(std::chrono::time_point<std::chrono::syst...
    type ITransientExpression (line 2202) | struct ITransientExpression {
      method isBinaryExpression (line 2203) | auto isBinaryExpression() const -> bool { return m_isBinaryExpressio...
      method getResult (line 2204) | auto getResult() const -> bool { return m_result; }
      method ITransientExpression (line 2207) | ITransientExpression( bool isBinaryExpression, bool result )
    class BinaryExpr (line 2224) | class BinaryExpr  : public ITransientExpression {
      method streamReconstructedExpression (line 2229) | void streamReconstructedExpression( std::ostream &os ) const override {
      method BinaryExpr (line 2235) | BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
    class UnaryExpr (line 2300) | class UnaryExpr : public ITransientExpression {
      method streamReconstructedExpression (line 2303) | void streamReconstructedExpression( std::ostream &os ) const override {
      method UnaryExpr (line 2308) | explicit UnaryExpr( LhsT lhs )
    function compareEqual (line 2316) | auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return...
    function compareEqual (line 2318) | auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == re...
    function compareEqual (line 2320) | auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == r...
    function compareEqual (line 2322) | auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpr...
    function compareEqual (line 2324) | auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterp...
    function compareNotEqual (line 2327) | auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return s...
    function compareNotEqual (line 2329) | auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs !=...
    function compareNotEqual (line 2331) | auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs !...
    function compareNotEqual (line 2333) | auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinte...
    function compareNotEqual (line 2335) | auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reint...
    class ExprLhs (line 2338) | class ExprLhs {
      method ExprLhs (line 2341) | explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
      method makeUnaryExpr (line 2402) | auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
    function handleExpression (line 2410) | void handleExpression( ExprLhs<T> const& expr ) {
    type Decomposer (line 2414) | struct Decomposer {
    class AssertionResult (line 2439) | class AssertionResult
      method AssertionResult (line 5399) | AssertionResult() = delete;
    type AssertionInfo (line 2440) | struct AssertionInfo
    type SectionInfo (line 2441) | struct SectionInfo
      method SectionInfo (line 2866) | SectionInfo
    type SectionEndInfo (line 2442) | struct SectionEndInfo
    type MessageInfo (line 2443) | struct MessageInfo
    type MessageBuilder (line 2444) | struct MessageBuilder
      method MessageBuilder (line 2633) | MessageBuilder& operator << ( T const& value ) {
    type Counts (line 2445) | struct Counts
    type AssertionReaction (line 2446) | struct AssertionReaction
    type SourceLineInfo (line 2447) | struct SourceLineInfo
      method SourceLineInfo (line 504) | SourceLineInfo() = delete;
      method SourceLineInfo (line 505) | SourceLineInfo( char const* _file, std::size_t _line ) noexcept
      method SourceLineInfo (line 510) | SourceLineInfo( SourceLineInfo const& other )            = default;
      method SourceLineInfo (line 511) | SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
      method SourceLineInfo (line 512) | SourceLineInfo( SourceLineInfo&& )              noexcept = default;
      method SourceLineInfo (line 513) | SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
      method empty (line 515) | bool empty() const noexcept { return file[0] == '\0'; }
    type ITransientExpression (line 2449) | struct ITransientExpression
      method isBinaryExpression (line 2203) | auto isBinaryExpression() const -> bool { return m_isBinaryExpressio...
      method getResult (line 2204) | auto getResult() const -> bool { return m_result; }
      method ITransientExpression (line 2207) | ITransientExpression( bool isBinaryExpression, bool result )
    type IGeneratorTracker (line 2450) | struct IGeneratorTracker
    type BenchmarkInfo (line 2453) | struct BenchmarkInfo
    type BenchmarkStats (line 2455) | struct BenchmarkStats
    type IResultCapture (line 2458) | struct IResultCapture {
    type TestFailureException (line 2521) | struct TestFailureException{}
    type AssertionResultData (line 2522) | struct AssertionResultData
      method AssertionResultData (line 5385) | AssertionResultData() = delete;
    type IResultCapture (line 2523) | struct IResultCapture
    class RunContext (line 2524) | class RunContext
      method RunContext (line 8064) | RunContext( RunContext const& ) = delete;
      method RunContext (line 8065) | RunContext& operator =( RunContext const& ) = delete;
    class LazyExpression (line 2526) | class LazyExpression {
      method LazyExpression (line 2536) | LazyExpression& operator = ( LazyExpression const& ) = delete;
    type AssertionReaction (line 2543) | struct AssertionReaction {
    class AssertionHandler (line 2548) | class AssertionHandler {
      method handleExpr (line 2567) | void handleExpr( ExprLhs<T> const& expr ) {
    type MessageInfo (line 2599) | struct MessageInfo {
    type MessageStream (line 2616) | struct MessageStream {
      method MessageStream (line 2619) | MessageStream& operator << ( T const& value ) {
    type MessageBuilder (line 2627) | struct MessageBuilder : MessageStream {
      method MessageBuilder (line 2633) | MessageBuilder& operator << ( T const& value ) {
    class ScopedMessage (line 2641) | class ScopedMessage {
      method ScopedMessage (line 2644) | ScopedMessage( ScopedMessage& duplicate ) = delete;
    class Capturer (line 2652) | class Capturer {
      method captureValues (line 2663) | void captureValues( size_t index, T const& value ) {
      method captureValues (line 2668) | void captureValues( size_t index, T const& value, Ts const&... value...
    type Counts (line 2829) | struct Counts {
    type Totals (line 2842) | struct Totals {
    type SectionInfo (line 2860) | struct SectionInfo {
      method SectionInfo (line 2866) | SectionInfo
    type SectionEndInfo (line 2876) | struct SectionEndInfo {
    class Timer (line 2894) | class Timer {
    class Section (line 2911) | class Section : NonCopyable {
    class TestCase (line 2952) | class TestCase
    type ITestCaseRegistry (line 2953) | struct ITestCaseRegistry
    type IExceptionTranslatorRegistry (line 2954) | struct IExceptionTranslatorRegistry
    type IExceptionTranslator (line 2955) | struct IExceptionTranslator
    type IReporterRegistry (line 2956) | struct IReporterRegistry
    type IReporterFactory (line 2957) | struct IReporterFactory
    type ITagAliasRegistry (line 2958) | struct ITagAliasRegistry
    type IMutableEnumValuesRegistry (line 2959) | struct IMutableEnumValuesRegistry
    class StartupExceptionRegistry (line 2961) | class StartupExceptionRegistry
    type IRegistryHub (line 2965) | struct IRegistryHub {
    type IMutableRegistryHub (line 2976) | struct IMutableRegistryHub {
    type IExceptionTranslator (line 3007) | struct IExceptionTranslator
    type IExceptionTranslator (line 3010) | struct IExceptionTranslator {
    type IExceptionTranslatorRegistry (line 3015) | struct IExceptionTranslatorRegistry {
    class ExceptionTranslatorRegistrar (line 3021) | class ExceptionTranslatorRegistrar {
      class ExceptionTranslator (line 3023) | class ExceptionTranslator : public IExceptionTranslator {
        method ExceptionTranslator (line 3026) | ExceptionTranslator( std::string(*translateFunction)( T& ) )
        method translate (line 3030) | std::string translate( ExceptionTranslators::const_iterator it, Ex...
      method ExceptionTranslatorRegistrar (line 3052) | ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
    type Detail (line 3076) | namespace Detail {
      type EnumInfo (line 1466) | struct EnumInfo {
      function rawMemoryToString (line 1559) | std::string rawMemoryToString( const T& object ) {
      class IsStreamInsertable (line 1564) | class IsStreamInsertable {
      function convertUnstreamable (line 1580) | typename std::enable_if<
      function convertUnstreamable (line 1586) | typename std::enable_if<
      function convertUnstreamable (line 1593) | typename std::enable_if<
      function stringify (line 1644) | std::string stringify(const T& e) {
      function convertUnknownEnumToString (line 1649) | std::string convertUnknownEnumToString( E e ) {
      function rangeToString (line 1829) | std::string rangeToString(InputIterator first, Sentinel last) {
      function stringify (line 1859) | inline std::string stringify( NSString* nsstring ) {
      type TupleElementPrinter (line 1927) | struct TupleElementPrinter {
        method print (line 1928) | static void print(const Tuple& tuple, std::ostream& os) {
      type TupleElementPrinter<Tuple, N, false> (line 1939) | struct TupleElementPrinter<Tuple, N, false> {
        method print (line 1940) | static void print(const Tuple&, std::ostream&) {}
      class Approx (line 3078) | class Approx {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7885) | Approx Approx::custom() {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      function Approx (line 7889) | Approx Approx::operator-() const {
        method Approx (line 3096) | Approx operator()( T const& value ) const {
        method Approx (line 3105) | explicit Approx( T const& value ): Approx(static_cast<double>(value))
        method Approx (line 3150) | Approx& epsilon( T const& newEpsilon ) {
        method Approx (line 3157) | Approx& margin( T const& newMargin ) {
        method Approx (line 3164) | Approx& scale( T const& newScale ) {
      class EnumValuesRegistry (line 10567) | class EnumValuesRegistry : public IMutableEnumValuesRegistry {
      function StringRef (line 10594) | StringRef extractInstanceName(StringRef enumInstance) {
      function parseEnums (line 10604) | std::vector<StringRef> parseEnums( StringRef enums ) {
      function StringRef (line 10616) | StringRef EnumInfo::lookup( int value ) const {
      function makeEnumInfo (line 10624) | std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRe...
      function EnumInfo (line 10638) | EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName...
      class StreamBufImpl (line 13645) | class StreamBufImpl : public std::streambuf {
        method StreamBufImpl (line 13650) | StreamBufImpl() {
        method overflow (line 13659) | int overflow( int c ) override {
        method sync (line 13671) | int sync() override {
      type OutputDebugWriter (line 13682) | struct OutputDebugWriter {
      class FileStream (line 13691) | class FileStream : public IStream {
        method FileStream (line 13694) | FileStream( StringRef filename ) {
      class CoutStream (line 13707) | class CoutStream : public IStream {
        method CoutStream (line 13712) | CoutStream() : m_os( Catch::cout().rdbuf() ) {}
      class DebugOutStream (line 13721) | class DebugOutStream : public IStream {
        method DebugOutStream (line 13725) | DebugOutStream()
      type Endianness (line 15025) | struct Endianness {
        type Arch (line 15026) | enum Arch { Big, Little }
        method Arch (line 15028) | static Arch which() {
      function rawMemoryToString (line 15038) | std::string rawMemoryToString( const void *object, std::size_t size ) {
    type literals (line 3179) | namespace literals {
    type StringMaker<Catch::Detail::Approx> (line 3185) | struct StringMaker<Catch::Detail::Approx> {
    type pluralise (line 3216) | struct pluralise {
    type Matchers (line 3236) | namespace Matchers {
      type Impl (line 3237) | namespace Impl {
        type MatchAllOf (line 3239) | struct MatchAllOf
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3240) | struct MatchAnyOf
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3241) | struct MatchNotOf
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
        class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 3262) | struct MatcherMethod {
        type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
        type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
      type Exception (line 3397) | namespace Exception {
        class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
          method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
      type Floating (line 3425) | namespace Floating {
        type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
        type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
        type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
      type Generic (line 3488) | namespace Generic {
        type Detail (line 3490) | namespace Detail {
        class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
          method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
          method match (line 3505) | bool match( T const& item ) const override {
          method describe (line 3509) | std::string describe() const override {
      function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
      type StdString (line 3536) | namespace StdString {
        type CasedString (line 3538) | struct CasedString
        type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
      type Vector (line 3605) | namespace Vector {
        type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
          method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
          method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
          method describe (line 3620) | std::string describe() const override {
        type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
          method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3650) | std::string describe() const override {
        type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
          method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3674) | std::string describe() const override {
        type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
          method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3693) | std::string describe() const override {
          method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
          method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
          method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
        type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
          method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
          method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
          method describe (line 3726) | std::string describe() const override {
      function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
      function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
      function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
      function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
      function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
      type Impl (line 11406) | namespace Impl {
        type MatchAllOf (line 3239) | struct MatchAllOf
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3240) | struct MatchAnyOf
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3241) | struct MatchNotOf
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
        class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 3262) | struct MatcherMethod {
        type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
        type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
      type Exception (line 11428) | namespace Exception {
        class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
          method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
      function Message (line 11439) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
      type Floating (line 11563) | namespace Floating {
        type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
        type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
        type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
      function WithinULP (line 11663) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
      function WithinULP (line 11667) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
      function WithinAbs (line 11671) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
      function WithinRel (line 11675) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
      function WithinRel (line 11679) | Floating::WithinRelMatcher WithinRel(double target) {
      function WithinRel (line 11683) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
      function WithinRel (line 11687) | Floating::WithinRelMatcher WithinRel(float target) {
      type StdString (line 11711) | namespace StdString {
        type CasedString (line 3538) | struct CasedString
        type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
      function Equals (line 11786) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
      function Contains (line 11789) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
      function EndsWith (line 11792) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
      function StartsWith (line 11795) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
      function Matches (line 11799) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
    type Matchers (line 3396) | namespace Matchers {
      type Impl (line 3237) | namespace Impl {
        type MatchAllOf (line 3239) | struct MatchAllOf
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3240) | struct MatchAnyOf
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3241) | struct MatchNotOf
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
        class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 3262) | struct MatcherMethod {
        type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
        type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
      type Exception (line 3397) | namespace Exception {
        class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
          method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
      type Floating (line 3425) | namespace Floating {
        type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
        type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
        type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
      type Generic (line 3488) | namespace Generic {
        type Detail (line 3490) | namespace Detail {
        class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
          method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
          method match (line 3505) | bool match( T const& item ) const override {
          method describe (line 3509) | std::string describe() const override {
      function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
      type StdString (line 3536) | namespace StdString {
        type CasedString (line 3538) | struct CasedString
        type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
      type Vector (line 3605) | namespace Vector {
        type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
          method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
          method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
          method describe (line 3620) | std::string describe() const override {
        type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
          method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3650) | std::string describe() const override {
        type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
          method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3674) | std::string describe() const override {
        type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
          method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3693) | std::string describe() const override {
          method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
          method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
          method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
        type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
          method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
          method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
          method describe (line 3726) | std::string describe() const override {
      function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
      function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
      function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
      function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
      function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
      type Impl (line 11406) | namespace Impl {
        type MatchAllOf (line 3239) | struct MatchAllOf
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3240) | struct MatchAnyOf
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3241) | struct MatchNotOf
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
        class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 3262) | struct MatcherMethod {
        type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
        type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
      type Exception (line 11428) | namespace Exception {
        class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
          method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
      function Message (line 11439) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
      type Floating (line 11563) | namespace Floating {
        type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
        type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
        type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
      function WithinULP (line 11663) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
      function WithinULP (line 11667) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
      function WithinAbs (line 11671) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
      function WithinRel (line 11675) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
      function WithinRel (line 11679) | Floating::WithinRelMatcher WithinRel(double target) {
      function WithinRel (line 11683) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
      function WithinRel (line 11687) | Floating::WithinRelMatcher WithinRel(float target) {
      type StdString (line 11711) | namespace StdString {
        type CasedString (line 3538) | struct CasedString
        type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
      function Equals (line 11786) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
      function Contains (line 11789) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
      function EndsWith (line 11792) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
      function StartsWith (line 11795) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
      function Matches (line 11799) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
    type Matchers (line 3423) | namespace Matchers {
      type Impl (line 3237) | namespace Impl {
        type MatchAllOf (line 3239) | struct MatchAllOf
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3240) | struct MatchAnyOf
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3241) | struct MatchNotOf
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
        class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 3262) | struct MatcherMethod {
        type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
        type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
      type Exception (line 3397) | namespace Exception {
        class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
          method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
      type Floating (line 3425) | namespace Floating {
        type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
        type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
        type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
      type Generic (line 3488) | namespace Generic {
        type Detail (line 3490) | namespace Detail {
        class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
          method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
          method match (line 3505) | bool match( T const& item ) const override {
          method describe (line 3509) | std::string describe() const override {
      function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
      type StdString (line 3536) | namespace StdString {
        type CasedString (line 3538) | struct CasedString
        type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
      type Vector (line 3605) | namespace Vector {
        type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
          method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
          method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
          method describe (line 3620) | std::string describe() const override {
        type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
          method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3650) | std::string describe() const override {
        type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
          method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3674) | std::string describe() const override {
        type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
          method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3693) | std::string describe() const override {
          method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
          method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
          method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
        type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
          method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
          method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
          method describe (line 3726) | std::string describe() const override {
      function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
      function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
      function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
      function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
      function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
      type Impl (line 11406) | namespace Impl {
        type MatchAllOf (line 3239) | struct MatchAllOf
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3240) | struct MatchAnyOf
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3241) | struct MatchNotOf
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
        class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 3262) | struct MatcherMethod {
        type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
        type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
      type Exception (line 11428) | namespace Exception {
        class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
          method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
      function Message (line 11439) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
      type Floating (line 11563) | namespace Floating {
        type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
        type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
        type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
      function WithinULP (line 11663) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
      function WithinULP (line 11667) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
      function WithinAbs (line 11671) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
      function WithinRel (line 11675) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
      function WithinRel (line 11679) | Floating::WithinRelMatcher WithinRel(double target) {
      function WithinRel (line 11683) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
      function WithinRel (line 11687) | Floating::WithinRelMatcher WithinRel(float target) {
      type StdString (line 11711) | namespace StdString {
        type CasedString (line 3538) | struct CasedString
        type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
      function Equals (line 11786) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
      function Contains (line 11789) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
      function EndsWith (line 11792) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
      function StartsWith (line 11795) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
      function Matches (line 11799) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
    type Matchers (line 3487) | namespace Matchers {
      type Impl (line 3237) | namespace Impl {
        type MatchAllOf (line 3239) | struct MatchAllOf
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3240) | struct MatchAnyOf
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3241) | struct MatchNotOf
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
        class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 3262) | struct MatcherMethod {
        type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
        type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
      type Exception (line 3397) | namespace Exception {
        class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
          method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
      type Floating (line 3425) | namespace Floating {
        type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
        type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
        type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
      type Generic (line 3488) | namespace Generic {
        type Detail (line 3490) | namespace Detail {
        class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
          method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
          method match (line 3505) | bool match( T const& item ) const override {
          method describe (line 3509) | std::string describe() const override {
      function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
      type StdString (line 3536) | namespace StdString {
        type CasedString (line 3538) | struct CasedString
        type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
      type Vector (line 3605) | namespace Vector {
        type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
          method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
          method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
          method describe (line 3620) | std::string describe() const override {
        type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
          method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3650) | std::string describe() const override {
        type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
          method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3674) | std::string describe() const override {
        type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
          method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3693) | std::string describe() const override {
          method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
          method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
          method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
        type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
          method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
          method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
          method describe (line 3726) | std::string describe() const override {
      function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
      function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
      function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
      function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
      function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
      type Impl (line 11406) | namespace Impl {
        type MatchAllOf (line 3239) | struct MatchAllOf
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3240) | struct MatchAnyOf
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3241) | struct MatchNotOf
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
        class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 3262) | struct MatcherMethod {
        type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
        type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
      type Exception (line 11428) | namespace Exception {
        class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
          method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
      function Message (line 11439) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
      type Floating (line 11563) | namespace Floating {
        type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
        type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
        type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
      function WithinULP (line 11663) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
      function WithinULP (line 11667) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
      function WithinAbs (line 11671) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
      function WithinRel (line 11675) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
      function WithinRel (line 11679) | Floating::WithinRelMatcher WithinRel(double target) {
      function WithinRel (line 11683) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
      function WithinRel (line 11687) | Floating::WithinRelMatcher WithinRel(float target) {
      type StdString (line 11711) | namespace StdString {
        type CasedString (line 3538) | struct CasedString
        type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
      function Equals (line 11786) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
      function Contains (line 11789) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
      function EndsWith (line 11792) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
      function StartsWith (line 11795) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
      function Matches (line 11799) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
    type Matchers (line 3534) | namespace Matchers {
      type Impl (line 3237) | namespace Impl {
        type MatchAllOf (line 3239) | struct MatchAllOf
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3240) | struct MatchAnyOf
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3241) | struct MatchNotOf
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
        class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 3262) | struct MatcherMethod {
        type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
        type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
      type Exception (line 3397) | namespace Exception {
        class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
          method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
      type Floating (line 3425) | namespace Floating {
        type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
        type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
        type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
      type Generic (line 3488) | namespace Generic {
        type Detail (line 3490) | namespace Detail {
        class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
          method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
          method match (line 3505) | bool match( T const& item ) const override {
          method describe (line 3509) | std::string describe() const override {
      function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
      type StdString (line 3536) | namespace StdString {
        type CasedString (line 3538) | struct CasedString
        type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
      type Vector (line 3605) | namespace Vector {
        type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
          method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
          method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
          method describe (line 3620) | std::string describe() const override {
        type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
          method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3650) | std::string describe() const override {
        type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
          method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3674) | std::string describe() const override {
        type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
          method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3693) | std::string describe() const override {
          method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
          method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
          method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
        type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
          method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
          method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
          method describe (line 3726) | std::string describe() const override {
      function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
      function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
      function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
      function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
      function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
      type Impl (line 11406) | namespace Impl {
        type MatchAllOf (line 3239) | struct MatchAllOf
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3240) | struct MatchAnyOf
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3241) | struct MatchNotOf
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
        class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 3262) | struct MatcherMethod {
        type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
        type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
      type Exception (line 11428) | namespace Exception {
        class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
          method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
      function Message (line 11439) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
      type Floating (line 11563) | namespace Floating {
        type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
        type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
        type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
      function WithinULP (line 11663) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
      function WithinULP (line 11667) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
      function WithinAbs (line 11671) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
      function WithinRel (line 11675) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
      function WithinRel (line 11679) | Floating::WithinRelMatcher WithinRel(double target) {
      function WithinRel (line 11683) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
      function WithinRel (line 11687) | Floating::WithinRelMatcher WithinRel(float target) {
      type StdString (line 11711) | namespace StdString {
        type CasedString (line 3538) | struct CasedString
        type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
      function Equals (line 11786) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
      function Contains (line 11789) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
      function EndsWith (line 11792) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
      function StartsWith (line 11795) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
      function Matches (line 11799) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
    type Matchers (line 3603) | namespace Matchers {
      type Impl (line 3237) | namespace Impl {
        type MatchAllOf (line 3239) | struct MatchAllOf
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3240) | struct MatchAnyOf
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3241) | struct MatchNotOf
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
        class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 3262) | struct MatcherMethod {
        type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
        type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
      type Exception (line 3397) | namespace Exception {
        class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
          method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
      type Floating (line 3425) | namespace Floating {
        type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
        type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
        type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
      type Generic (line 3488) | namespace Generic {
        type Detail (line 3490) | namespace Detail {
        class PredicateMatcher (line 3495) | class PredicateMatcher : public MatcherBase<T> {
          method PredicateMatcher (line 3500) | PredicateMatcher(std::function<bool(T const&)> const& elem, std:...
          method match (line 3505) | bool match( T const& item ) const override {
          method describe (line 3509) | std::string describe() const override {
      function Predicate (line 3521) | Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)>...
      type StdString (line 3536) | namespace StdString {
        type CasedString (line 3538) | struct CasedString
        type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
      type Vector (line 3605) | namespace Vector {
        type ContainsElementMatcher (line 3607) | struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
          method ContainsElementMatcher (line 3609) | ContainsElementMatcher(T const &comparator) : m_comparator( comp...
          method match (line 3611) | bool match(std::vector<T, Alloc> const &v) const override {
          method describe (line 3620) | std::string describe() const override {
        type ContainsMatcher (line 3628) | struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method ContainsMatcher (line 3630) | ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m...
          method match (line 3632) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3650) | std::string describe() const override {
        type EqualsMatcher (line 3658) | struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method EqualsMatcher (line 3660) | EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_c...
          method match (line 3662) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3674) | std::string describe() const override {
        type ApproxMatcher (line 3681) | struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
          method ApproxMatcher (line 3683) | ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_c...
          method match (line 3685) | bool match(std::vector<T, AllocMatch> const &v) const override {
          method describe (line 3693) | std::string describe() const override {
          method ApproxMatcher (line 3697) | ApproxMatcher& epsilon( T const& newEpsilon ) {
          method ApproxMatcher (line 3702) | ApproxMatcher& margin( T const& newMargin ) {
          method ApproxMatcher (line 3707) | ApproxMatcher& scale( T const& newScale ) {
        type UnorderedEqualsMatcher (line 3717) | struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMa...
          method UnorderedEqualsMatcher (line 3718) | UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) ...
          method match (line 3719) | bool match(std::vector<T, AllocMatch> const& vec) const override {
          method describe (line 3726) | std::string describe() const override {
      function Contains (line 3739) | Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vec...
      function VectorContains (line 3744) | Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& co...
      function Equals (line 3749) | Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<...
      function Approx (line 3754) | Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<...
      function UnorderedEquals (line 3759) | Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEq...
      type Impl (line 11406) | namespace Impl {
        type MatchAllOf (line 3239) | struct MatchAllOf
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3240) | struct MatchAnyOf
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3241) | struct MatchNotOf
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
        class MatcherUntypedBase (line 3243) | class MatcherUntypedBase {
          method MatcherUntypedBase (line 3245) | MatcherUntypedBase() = default;
          method MatcherUntypedBase (line 3246) | MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
          method MatcherUntypedBase (line 3247) | MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = d...
        type MatcherMethod (line 3262) | struct MatcherMethod {
        type MatcherMethod<NSString*> (line 3270) | struct MatcherMethod<NSString*> {
        type MatcherBase (line 3280) | struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
        type MatchAllOf (line 3288) | struct MatchAllOf : MatcherBase<ArgT> {
          method match (line 3289) | bool match( ArgT const& arg ) const override {
          method describe (line 3296) | std::string describe() const override {
        type MatchAnyOf (line 3321) | struct MatchAnyOf : MatcherBase<ArgT> {
          method match (line 3323) | bool match( ArgT const& arg ) const override {
          method describe (line 3330) | std::string describe() const override {
        type MatchNotOf (line 3356) | struct MatchNotOf : MatcherBase<ArgT> {
          method MatchNotOf (line 3358) | MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_und...
          method match (line 3360) | bool match( ArgT const& arg ) const override {
          method describe (line 3364) | std::string describe() const override {
      type Exception (line 11428) | namespace Exception {
        class ExceptionMessageMatcher (line 3399) | class ExceptionMessageMatcher : public MatcherBase<std::exception> {
          method ExceptionMessageMatcher (line 3403) | ExceptionMessageMatcher(std::string const& message):
      function Message (line 11439) | Exception::ExceptionMessageMatcher Message(std::string const& messag...
      type Floating (line 11563) | namespace Floating {
        type FloatingPointKind (line 3427) | enum class FloatingPointKind : uint8_t
        type WithinAbsMatcher (line 3429) | struct WithinAbsMatcher : MatcherBase<double> {
        type WithinUlpsMatcher (line 3438) | struct WithinUlpsMatcher : MatcherBase<double> {
        type WithinRelMatcher (line 3454) | struct WithinRelMatcher : MatcherBase<double> {
        type FloatingPointKind (line 11565) | enum class FloatingPointKind : uint8_t {
      function WithinULP (line 11663) | Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlp...
      function WithinULP (line 11667) | Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpD...
      function WithinAbs (line 11671) | Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
      function WithinRel (line 11675) | Floating::WithinRelMatcher WithinRel(double target, double eps) {
      function WithinRel (line 11679) | Floating::WithinRelMatcher WithinRel(double target) {
      function WithinRel (line 11683) | Floating::WithinRelMatcher WithinRel(float target, float eps) {
      function WithinRel (line 11687) | Floating::WithinRelMatcher WithinRel(float target) {
      type StdString (line 11711) | namespace StdString {
        type CasedString (line 3538) | struct CasedString
        type StringMatcherBase (line 3548) | struct StringMatcherBase : MatcherBase<std::string> {
        type EqualsMatcher (line 3556) | struct EqualsMatcher : StringMatcherBase {
        type ContainsMatcher (line 3560) | struct ContainsMatcher : StringMatcherBase {
        type StartsWithMatcher (line 3564) | struct StartsWithMatcher : StringMatcherBase {
        type EndsWithMatcher (line 3568) | struct EndsWithMatcher : StringMatcherBase {
        type RegexMatcher (line 3573) | struct RegexMatcher : MatcherBase<std::string> {
      function Equals (line 11786) | StdString::EqualsMatcher Equals( std::string const& str, CaseSensiti...
      function Contains (line 11789) | StdString::ContainsMatcher Contains( std::string const& str, CaseSen...
      function EndsWith (line 11792) | StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSen...
      function StartsWith (line 11795) | StdString::StartsWithMatcher StartsWith( std::string const& str, Cas...
      function Matches (line 11799) | StdString::RegexMatcher Matches(std::string const& regex, CaseSensit...
    class MatchExpr (line 3770) | class MatchExpr : public ITransientExpression {
      method MatchExpr (line 3775) | MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const...
      method streamReconstructedExpression (line 3782) | void streamReconstructedExpression( std::ostream &os ) const override {
    function makeMatchExpr (line 3797) | auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRe...
    type Generators (line 3844) | namespace Generators {
      class GeneratorUntypedBase (line 3845) | class GeneratorUntypedBase {
        method GeneratorUntypedBase (line 3847) | GeneratorUntypedBase() = default;
      type pf (line 3933) | namespace pf{
        function make_unique (line 3935) | std::unique_ptr<T> make_unique( Args&&... args ) {
      type IGenerator (line 3941) | struct IGenerator : GeneratorUntypedBase {
      class SingleValueGenerator (line 3953) | class SingleValueGenerator final : public IGenerator<T> {
        method SingleValueGenerator (line 3956) | SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
        method T (line 3958) | T const& get() const override {
        method next (line 3961) | bool next() override {
      class FixedValuesGenerator (line 3967) | class FixedValuesGenerator final : public IGenerator<T> {
        method FixedValuesGenerator (line 3974) | FixedValuesGenerator( std::initializer_list<T> values ) : m_values...
        method T (line 3976) | T const& get() const override {
        method next (line 3979) | bool next() override {
      class GeneratorWrapper (line 3986) | class GeneratorWrapper final {
        method GeneratorWrapper (line 3989) | GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
        method T (line 3992) | T const& get() const {
        method next (line 3995) | bool next() {
      function value (line 4001) | GeneratorWrapper<T> value(T&& value) {
      function values (line 4005) | GeneratorWrapper<T> values(std::initializer_list<T> values) {
      class Generators (line 4010) | class Generators : public IGenerator<T> {
        method populate (line 4014) | void populate(GeneratorWrapper<T>&& generator) {
        method populate (line 4017) | void populate(T&& val) {
        method populate (line 4021) | void populate(U&& val) {
        method populate (line 4025) | void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
        method Generators (line 4032) | Generators(Gs &&... moreGenerators) {
        method T (line 4037) | T const& get() const override {
        method next (line 4041) | bool next() override {
      function table (line 4054) | GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std...
      type as (line 4060) | struct as {}
      function makeGenerators (line 4063) | auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreG...
      function makeGenerators (line 4067) | auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators...
      function makeGenerators (line 4071) | auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generator...
      function makeGenerators (line 4075) | auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Ge...
      function generate (line 4085) | auto generate( StringRef generatorName, SourceLineInfo const& lineIn...
      class TakeGenerator (line 4120) | class TakeGenerator : public IGenerator<T> {
        method TakeGenerator (line 4125) | TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
        method T (line 4131) | T const& get() const override {
        method next (line 4134) | bool next() override {
      function take (line 4151) | GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& genera...
      class FilterGenerator (line 4156) | class FilterGenerator : public IGenerator<T> {
        method FilterGenerator (line 4161) | FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
        method T (line 4175) | T const& get() const override {
        method next (line 4179) | bool next() override {
        method nextImpl (line 4184) | bool nextImpl() {
      function filter (line 4195) | GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& g...
      class RepeatGenerator (line 4200) | class RepeatGenerator : public IGenerator<T> {
        method RepeatGenerator (line 4210) | RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
        method T (line 4217) | T const& get() const override {
        method next (line 4225) | bool next() override {
      function repeat (line 4251) | GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& gen...
      class MapGenerator (line 4256) | class MapGenerator : public IGenerator<T> {
        method MapGenerator (line 4264) | MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
        method T (line 4270) | T const& get() const override {
        method next (line 4273) | bool next() override {
      function map (line 4283) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
      function map (line 4290) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
      class ChunkGenerator (line 4297) | class ChunkGenerator final : public IGenerator<std::vector<T>> {
        method ChunkGenerator (line 4303) | ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
        method next (line 4320) | bool next() override {
      function chunk (line 4333) | GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper...
      class RandomFloatingGenerator (line 4603) | class RandomFloatingGenerator final : public IGenerator<Float> {
        method RandomFloatingGenerator (line 4609) | RandomFloatingGenerator(Float a, Float b):
        method Float (line 4615) | Float const& get() const override {
        method next (line 4618) | bool next() override {
      class RandomIntegerGenerator (line 4625) | class RandomIntegerGenerator final : public IGenerator<Integer> {
        method RandomIntegerGenerator (line 4631) | RandomIntegerGenerator(Integer a, Integer b):
        method Integer (line 4637) | Integer const& get() const override {
        method next (line 4640) | bool next() override {
      function random (line 4649) | typename std::enable_if<std::is_integral<T>::value && !std::is_same<...
      function random (line 4658) | typename std::enable_if<std::is_floating_point<T>::value,
      class RangeGenerator (line 4667) | class RangeGenerator final : public IGenerator<T> {
        method RangeGenerator (line 4674) | RangeGenerator(T const& start, T const& end, T const& step):
        method RangeGenerator (line 4685) | RangeGenerator(T const& start, T const& end):
        method T (line 4689) | T const& get() const override {
        method next (line 4693) | bool next() override {
      function range (line 4700) | GeneratorWrapper<T> range(T const& start, T const& end, T const& ste...
      function range (line 4706) | GeneratorWrapper<T> range(T const& start, T const& end) {
      class IteratorGenerator (line 4712) | class IteratorGenerator final : public IGenerator<T> {
        method IteratorGenerator (line 4721) | IteratorGenerator(InputIterator first, InputSentinel last):m_elems...
        method T (line 4727) | T const& get() const override {
        method next (line 4731) | bool next() override {
      function from_range (line 4740) | GeneratorWrapper<ResultType> from_range(InputIterator from, InputSen...
      function from_range (line 4746) | GeneratorWrapper<ResultType> from_range(Container const& cnt) {
      function acquireGeneratorTracker (line 10982) | auto acquireGeneratorTracker( StringRef generatorName, SourceLineInf...
      type GeneratorTracker (line 12588) | struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorT...
        method GeneratorTracker (line 12591) | GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAnd...
        method GeneratorTracker (line 12596) | static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTra...
        method isGeneratorTracker (line 12633) | bool isGeneratorTracker() const override { return true; }
        method hasGenerator (line 12634) | auto hasGenerator() const -> bool override {
        method close (line 12637) | void close() override {
        method getGenerator (line 12707) | auto getGenerator() const -> GeneratorBasePtr const& override {
        method setGenerator (line 12710) | void setGenerator( GeneratorBasePtr&& generator ) override {
    type IGeneratorTracker (line 3859) | struct IGeneratorTracker {
    function throw_exception (line 3876) | [[noreturn]]
    class GeneratorException (line 3919) | class GeneratorException : public std::exception {
      method GeneratorException (line 3923) | GeneratorException(const char* msg):
    type Generators (line 3930) | namespace Generators {
      class GeneratorUntypedBase (line 3845) | class GeneratorUntypedBase {
        method GeneratorUntypedBase (line 3847) | GeneratorUntypedBase() = default;
      type pf (line 3933) | namespace pf{
        function make_unique (line 3935) | std::unique_ptr<T> make_unique( Args&&... args ) {
      type IGenerator (line 3941) | struct IGenerator : GeneratorUntypedBase {
      class SingleValueGenerator (line 3953) | class SingleValueGenerator final : public IGenerator<T> {
        method SingleValueGenerator (line 3956) | SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
        method T (line 3958) | T const& get() const override {
        method next (line 3961) | bool next() override {
      class FixedValuesGenerator (line 3967) | class FixedValuesGenerator final : public IGenerator<T> {
        method FixedValuesGenerator (line 3974) | FixedValuesGenerator( std::initializer_list<T> values ) : m_values...
        method T (line 3976) | T const& get() const override {
        method next (line 3979) | bool next() override {
      class GeneratorWrapper (line 3986) | class GeneratorWrapper final {
        method GeneratorWrapper (line 3989) | GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
        method T (line 3992) | T const& get() const {
        method next (line 3995) | bool next() {
      function value (line 4001) | GeneratorWrapper<T> value(T&& value) {
      function values (line 4005) | GeneratorWrapper<T> values(std::initializer_list<T> values) {
      class Generators (line 4010) | class Generators : public IGenerator<T> {
        method populate (line 4014) | void populate(GeneratorWrapper<T>&& generator) {
        method populate (line 4017) | void populate(T&& val) {
        method populate (line 4021) | void populate(U&& val) {
        method populate (line 4025) | void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
        method Generators (line 4032) | Generators(Gs &&... moreGenerators) {
        method T (line 4037) | T const& get() const override {
        method next (line 4041) | bool next() override {
      function table (line 4054) | GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std...
      type as (line 4060) | struct as {}
      function makeGenerators (line 4063) | auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreG...
      function makeGenerators (line 4067) | auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators...
      function makeGenerators (line 4071) | auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generator...
      function makeGenerators (line 4075) | auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Ge...
      function generate (line 4085) | auto generate( StringRef generatorName, SourceLineInfo const& lineIn...
      class TakeGenerator (line 4120) | class TakeGenerator : public IGenerator<T> {
        method TakeGenerator (line 4125) | TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
        method T (line 4131) | T const& get() const override {
        method next (line 4134) | bool next() override {
      function take (line 4151) | GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& genera...
      class FilterGenerator (line 4156) | class FilterGenerator : public IGenerator<T> {
        method FilterGenerator (line 4161) | FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
        method T (line 4175) | T const& get() const override {
        method next (line 4179) | bool next() override {
        method nextImpl (line 4184) | bool nextImpl() {
      function filter (line 4195) | GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& g...
      class RepeatGenerator (line 4200) | class RepeatGenerator : public IGenerator<T> {
        method RepeatGenerator (line 4210) | RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
        method T (line 4217) | T const& get() const override {
        method next (line 4225) | bool next() override {
      function repeat (line 4251) | GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& gen...
      class MapGenerator (line 4256) | class MapGenerator : public IGenerator<T> {
        method MapGenerator (line 4264) | MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
        method T (line 4270) | T const& get() const override {
        method next (line 4273) | bool next() override {
      function map (line 4283) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
      function map (line 4290) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
      class ChunkGenerator (line 4297) | class ChunkGenerator final : public IGenerator<std::vector<T>> {
        method ChunkGenerator (line 4303) | ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
        method next (line 4320) | bool next() override {
      function chunk (line 4333) | GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper...
      class RandomFloatingGenerator (line 4603) | class RandomFloatingGenerator final : public IGenerator<Float> {
        method RandomFloatingGenerator (line 4609) | RandomFloatingGenerator(Float a, Float b):
        method Float (line 4615) | Float const& get() const override {
        method next (line 4618) | bool next() override {
      class RandomIntegerGenerator (line 4625) | class RandomIntegerGenerator final : public IGenerator<Integer> {
        method RandomIntegerGenerator (line 4631) | RandomIntegerGenerator(Integer a, Integer b):
        method Integer (line 4637) | Integer const& get() const override {
        method next (line 4640) | bool next() override {
      function random (line 4649) | typename std::enable_if<std::is_integral<T>::value && !std::is_same<...
      function random (line 4658) | typename std::enable_if<std::is_floating_point<T>::value,
      class RangeGenerator (line 4667) | class RangeGenerator final : public IGenerator<T> {
        method RangeGenerator (line 4674) | RangeGenerator(T const& start, T const& end, T const& step):
        method RangeGenerator (line 4685) | RangeGenerator(T const& start, T const& end):
        method T (line 4689) | T const& get() const override {
        method next (line 4693) | bool next() override {
      function range (line 4700) | GeneratorWrapper<T> range(T const& start, T const& end, T const& ste...
      function range (line 4706) | GeneratorWrapper<T> range(T const& start, T const& end) {
      class IteratorGenerator (line 4712) | class IteratorGenerator final : public IGenerator<T> {
        method IteratorGenerator (line 4721) | IteratorGenerator(InputIterator first, InputSentinel last):m_elems...
        method T (line 4727) | T const& get() const override {
        method next (line 4731) | bool next() override {
      function from_range (line 4740) | GeneratorWrapper<ResultType> from_range(InputIterator from, InputSen...
      function from_range (line 4746) | GeneratorWrapper<ResultType> from_range(Container const& cnt) {
      function acquireGeneratorTracker (line 10982) | auto acquireGeneratorTracker( StringRef generatorName, SourceLineInf...
      type GeneratorTracker (line 12588) | struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorT...
        method GeneratorTracker (line 12591) | GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAnd...
        method GeneratorTracker (line 12596) | static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTra...
        method isGeneratorTracker (line 12633) | bool isGeneratorTracker() const override { return true; }
        method hasGenerator (line 12634) | auto hasGenerator() const -> bool override {
        method close (line 12637) | void close() override {
        method getGenerator (line 12707) | auto getGenerator() const -> GeneratorBasePtr const& override {
        method setGenerator (line 12710) | void setGenerator( GeneratorBasePtr&& generator ) override {
    type Generators (line 4117) | namespace Generators {
      class GeneratorUntypedBase (line 3845) | class GeneratorUntypedBase {
        method GeneratorUntypedBase (line 3847) | GeneratorUntypedBase() = default;
      type pf (line 3933) | namespace pf{
        function make_unique (line 3935) | std::unique_ptr<T> make_unique( Args&&... args ) {
      type IGenerator (line 3941) | struct IGenerator : GeneratorUntypedBase {
      class SingleValueGenerator (line 3953) | class SingleValueGenerator final : public IGenerator<T> {
        method SingleValueGenerator (line 3956) | SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
        method T (line 3958) | T const& get() const override {
        method next (line 3961) | bool next() override {
      class FixedValuesGenerator (line 3967) | class FixedValuesGenerator final : public IGenerator<T> {
        method FixedValuesGenerator (line 3974) | FixedValuesGenerator( std::initializer_list<T> values ) : m_values...
        method T (line 3976) | T const& get() const override {
        method next (line 3979) | bool next() override {
      class GeneratorWrapper (line 3986) | class GeneratorWrapper final {
        method GeneratorWrapper (line 3989) | GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
        method T (line 3992) | T const& get() const {
        method next (line 3995) | bool next() {
      function value (line 4001) | GeneratorWrapper<T> value(T&& value) {
      function values (line 4005) | GeneratorWrapper<T> values(std::initializer_list<T> values) {
      class Generators (line 4010) | class Generators : public IGenerator<T> {
        method populate (line 4014) | void populate(GeneratorWrapper<T>&& generator) {
        method populate (line 4017) | void populate(T&& val) {
        method populate (line 4021) | void populate(U&& val) {
        method populate (line 4025) | void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
        method Generators (line 4032) | Generators(Gs &&... moreGenerators) {
        method T (line 4037) | T const& get() const override {
        method next (line 4041) | bool next() override {
      function table (line 4054) | GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std...
      type as (line 4060) | struct as {}
      function makeGenerators (line 4063) | auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreG...
      function makeGenerators (line 4067) | auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators...
      function makeGenerators (line 4071) | auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generator...
      function makeGenerators (line 4075) | auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Ge...
      function generate (line 4085) | auto generate( StringRef generatorName, SourceLineInfo const& lineIn...
      class TakeGenerator (line 4120) | class TakeGenerator : public IGenerator<T> {
        method TakeGenerator (line 4125) | TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
        method T (line 4131) | T const& get() const override {
        method next (line 4134) | bool next() override {
      function take (line 4151) | GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& genera...
      class FilterGenerator (line 4156) | class FilterGenerator : public IGenerator<T> {
        method FilterGenerator (line 4161) | FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
        method T (line 4175) | T const& get() const override {
        method next (line 4179) | bool next() override {
        method nextImpl (line 4184) | bool nextImpl() {
      function filter (line 4195) | GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& g...
      class RepeatGenerator (line 4200) | class RepeatGenerator : public IGenerator<T> {
        method RepeatGenerator (line 4210) | RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
        method T (line 4217) | T const& get() const override {
        method next (line 4225) | bool next() override {
      function repeat (line 4251) | GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& gen...
      class MapGenerator (line 4256) | class MapGenerator : public IGenerator<T> {
        method MapGenerator (line 4264) | MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
        method T (line 4270) | T const& get() const override {
        method next (line 4273) | bool next() override {
      function map (line 4283) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
      function map (line 4290) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
      class ChunkGenerator (line 4297) | class ChunkGenerator final : public IGenerator<std::vector<T>> {
        method ChunkGenerator (line 4303) | ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
        method next (line 4320) | bool next() override {
      function chunk (line 4333) | GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper...
      class RandomFloatingGenerator (line 4603) | class RandomFloatingGenerator final : public IGenerator<Float> {
        method RandomFloatingGenerator (line 4609) | RandomFloatingGenerator(Float a, Float b):
        method Float (line 4615) | Float const& get() const override {
        method next (line 4618) | bool next() override {
      class RandomIntegerGenerator (line 4625) | class RandomIntegerGenerator final : public IGenerator<Integer> {
        method RandomIntegerGenerator (line 4631) | RandomIntegerGenerator(Integer a, Integer b):
        method Integer (line 4637) | Integer const& get() const override {
        method next (line 4640) | bool next() override {
      function random (line 4649) | typename std::enable_if<std::is_integral<T>::value && !std::is_same<...
      function random (line 4658) | typename std::enable_if<std::is_floating_point<T>::value,
      class RangeGenerator (line 4667) | class RangeGenerator final : public IGenerator<T> {
        method RangeGenerator (line 4674) | RangeGenerator(T const& start, T const& end, T const& step):
        method RangeGenerator (line 4685) | RangeGenerator(T const& start, T const& end):
        method T (line 4689) | T const& get() const override {
        method next (line 4693) | bool next() override {
      function range (line 4700) | GeneratorWrapper<T> range(T const& start, T const& end, T const& ste...
      function range (line 4706) | GeneratorWrapper<T> range(T const& start, T const& end) {
      class IteratorGenerator (line 4712) | class IteratorGenerator final : public IGenerator<T> {
        method IteratorGenerator (line 4721) | IteratorGenerator(InputIterator first, InputSentinel last):m_elems...
        method T (line 4727) | T const& get() const override {
        method next (line 4731) | bool next() override {
      function from_range (line 4740) | GeneratorWrapper<ResultType> from_range(InputIterator from, InputSen...
      function from_range (line 4746) | GeneratorWrapper<ResultType> from_range(Container const& cnt) {
      function acquireGeneratorTracker (line 10982) | auto acquireGeneratorTracker( StringRef generatorName, SourceLineInf...
      type GeneratorTracker (line 12588) | struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorT...
        method GeneratorTracker (line 12591) | GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAnd...
        method GeneratorTracker (line 12596) | static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTra...
        method isGeneratorTracker (line 12633) | bool isGeneratorTracker() const override { return true; }
        method hasGenerator (line 12634) | auto hasGenerator() const -> bool override {
        method close (line 12637) | void close() override {
        method getGenerator (line 12707) | auto getGenerator() const -> GeneratorBasePtr const& override {
        method setGenerator (line 12710) | void setGenerator( GeneratorBasePtr&& generator ) override {
    type IResultCapture (line 4351) | struct IResultCapture
    type IRunner (line 4352) | struct IRunner
    type IConfig (line 4353) | struct IConfig
    type IMutableContext (line 4354) | struct IMutableContext
    type IContext (line 4358) | struct IContext
    type IMutableContext (line 4367) | struct IMutableContext : IContext
    function IMutableContext (line 4381) | inline IMutableContext& getCurrentMutableContext()
    function IContext (line 4389) | inline IContext& getCurrentContext()
    class SimplePcg32 (line 4396) | class SimplePcg32
      method SimplePcg32 (line 4570) | SimplePcg32():SimplePcg32(0xed743cc4U) {}
    class Option (line 4409) | class Option {
      method Option (line 4411) | Option() : nullableValue( nullptr ) {}
      method Option (line 4412) | Option( T const& _value )
      method Option (line 4415) | Option( Option const& _other )
      method Option (line 4423) | Option& operator= ( Option const& _other ) {
      method Option (line 4431) | Option& operator = ( T const& _value ) {
      method reset (line 4437) | void reset() {
      method T (line 4443) | T& operator*() { return *nullableValue; }
      method T (line 4444) | T const& operator*() const { return *nullableValue; }
      method T (line 4445) | T* operator->() { return nullableValue; }
      method T (line 4446) | const T* operator->() const { return nullableValue; }
      method T (line 4448) | T valueOr( T const& defaultValue ) const {
      method some (line 4452) | bool some() const { return nullableValue != nullptr; }
      method none (line 4453) | bool none() const { return nullableValue == nullptr; }
    type Verbosity (line 4476) | enum class Verbosity {
    type WarnAbout (line 4482) | struct WarnAbout { enum What {
      type What (line 4482) | enum What {
    type ShowDurations (line 4488) | struct ShowDurations { enum OrNot {
      type OrNot (line 4488) | enum OrNot {
    type RunTests (line 4493) | struct RunTests { enum InWhatOrder {
      type InWhatOrder (line 4493) | enum InWhatOrder {
    type UseColour (line 4498) | struct UseColour { enum YesOrNo {
      type YesOrNo (line 4498) | enum YesOrNo {
    type WaitForKeypress (line 4503) | struct WaitForKeypress { enum When {
      type When (line 4503) | enum When {
    class TestSpec (line 4510) | class TestSpec
      class Pattern (line 5112) | class Pattern {
      class NamePattern (line 5123) | class NamePattern : public Pattern {
      class TagPattern (line 5131) | class TagPattern : public Pattern {
      class ExcludedPattern (line 5139) | class ExcludedPattern : public Pattern {
      type Filter (line 5147) | struct Filter {
      type FilterMatch (line 5155) | struct FilterMatch {
    type IConfig (line 4512) | struct IConfig : NonCopyable {
    class SimplePcg32 (line 4558) | class SimplePcg32 {
      method SimplePcg32 (line 4570) | SimplePcg32():SimplePcg32(0xed743cc4U) {}
    type Generators (line 4600) | namespace Generators {
      class GeneratorUntypedBase (line 3845) | class GeneratorUntypedBase {
        method GeneratorUntypedBase (line 3847) | GeneratorUntypedBase() = default;
      type pf (line 3933) | namespace pf{
        function make_unique (line 3935) | std::unique_ptr<T> make_unique( Args&&... args ) {
      type IGenerator (line 3941) | struct IGenerator : GeneratorUntypedBase {
      class SingleValueGenerator (line 3953) | class SingleValueGenerator final : public IGenerator<T> {
        method SingleValueGenerator (line 3956) | SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
        method T (line 3958) | T const& get() const override {
        method next (line 3961) | bool next() override {
      class FixedValuesGenerator (line 3967) | class FixedValuesGenerator final : public IGenerator<T> {
        method FixedValuesGenerator (line 3974) | FixedValuesGenerator( std::initializer_list<T> values ) : m_values...
        method T (line 3976) | T const& get() const override {
        method next (line 3979) | bool next() override {
      class GeneratorWrapper (line 3986) | class GeneratorWrapper final {
        method GeneratorWrapper (line 3989) | GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
        method T (line 3992) | T const& get() const {
        method next (line 3995) | bool next() {
      function value (line 4001) | GeneratorWrapper<T> value(T&& value) {
      function values (line 4005) | GeneratorWrapper<T> values(std::initializer_list<T> values) {
      class Generators (line 4010) | class Generators : public IGenerator<T> {
        method populate (line 4014) | void populate(GeneratorWrapper<T>&& generator) {
        method populate (line 4017) | void populate(T&& val) {
        method populate (line 4021) | void populate(U&& val) {
        method populate (line 4025) | void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
        method Generators (line 4032) | Generators(Gs &&... moreGenerators) {
        method T (line 4037) | T const& get() const override {
        method next (line 4041) | bool next() override {
      function table (line 4054) | GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std...
      type as (line 4060) | struct as {}
      function makeGenerators (line 4063) | auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreG...
      function makeGenerators (line 4067) | auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators...
      function makeGenerators (line 4071) | auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generator...
      function makeGenerators (line 4075) | auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Ge...
      function generate (line 4085) | auto generate( StringRef generatorName, SourceLineInfo const& lineIn...
      class TakeGenerator (line 4120) | class TakeGenerator : public IGenerator<T> {
        method TakeGenerator (line 4125) | TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
        method T (line 4131) | T const& get() const override {
        method next (line 4134) | bool next() override {
      function take (line 4151) | GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& genera...
      class FilterGenerator (line 4156) | class FilterGenerator : public IGenerator<T> {
        method FilterGenerator (line 4161) | FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
        method T (line 4175) | T const& get() const override {
        method next (line 4179) | bool next() override {
        method nextImpl (line 4184) | bool nextImpl() {
      function filter (line 4195) | GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& g...
      class RepeatGenerator (line 4200) | class RepeatGenerator : public IGenerator<T> {
        method RepeatGenerator (line 4210) | RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
        method T (line 4217) | T const& get() const override {
        method next (line 4225) | bool next() override {
      function repeat (line 4251) | GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& gen...
      class MapGenerator (line 4256) | class MapGenerator : public IGenerator<T> {
        method MapGenerator (line 4264) | MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
        method T (line 4270) | T const& get() const override {
        method next (line 4273) | bool next() override {
      function map (line 4283) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
      function map (line 4290) | GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& gener...
      class ChunkGenerator (line 4297) | class ChunkGenerator final : public IGenerator<std::vector<T>> {
        method ChunkGenerator (line 4303) | ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
        method next (line 4320) | bool next() override {
      function chunk (line 4333) | GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper...
      class RandomFloatingGenerator (line 4603) | class RandomFloatingGenerator final : public IGenerator<Float> {
        method RandomFloatingGenerator (line 4609) | RandomFloatingGenerator(Float a, Float b):
        method Float (line 4615) | Float const& get() const override {
        method next (line 4618) | bool next() override {
      class RandomIntegerGenerator (line 4625) | class RandomIntegerGenerator final : public IGenerator<Integer> {
        method RandomIntegerGenerator (line 4631) | RandomIntegerGenerator(Integer a, Integer b):
        method Integer (line 4637) | Integer const& get() const override {
        method next (line 4640) | bool next() override {
      function random (line 4649) | typename std::enable_if<std::is_integral<T>::value && !std::is_same<...
      function random (line 4658) | typename std::enable_if<std::is_floating_point<T>::value,
      class RangeGenerator (line 4667) | class RangeGenerator final : public IGenerator<T> {
        method RangeGenerator (line 4674) | RangeGenerator(T const& start, T const& end, T const& step):
        method RangeGenerator (line 4685) | RangeGenerator(T const& start, T const& end):
        method T (line 4689) | T const& get() const override {
        method next (line 4693) | bool next() override {
      function range (line 4700) | GeneratorWrapper<T> range(T const& start, T const& end, T const& ste...
      function range (line 4706) | GeneratorWrapper<T> range(T const& start, T const& end) {
      class IteratorGenerator (line 4712) | class IteratorGenerator final : public IGenerator<T> {
        method IteratorGenerator (line 4721) | IteratorGenerator(InputIterator first, InputSentinel last):m_elems...
        method T (line 4727) | T const& get() const override {
        method next (line 4731) | bool next() override {
      function from_range (line 4740) | GeneratorWrapper<ResultType> from_range(InputIterator from, InputSen...
      function from_range (line 4746) | GeneratorWrapper<ResultType> from_range(Container const& cnt) {
      function acquireGeneratorTracker (line 10982) | auto acquireGeneratorTracker( StringRef generatorName, SourceLineInf...
      type GeneratorTracker (line 12588) | struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorT...
        method GeneratorTracker (line 12591) | GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAnd...
        method GeneratorTracker (line 12596) | static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTra...
        method isGeneratorTracker (line 12633) | bool isGeneratorTracker() const override { return true; }
        method hasGenerator (line 12634) | auto hasGenerator() const -> bool override {
        method close (line 12637) | void close() override {
        method getGenerator (line 12707) | auto getGenerator() const -> GeneratorBasePtr const& override {
        method setGenerator (line 12710) | void setGenerator( GeneratorBasePtr&& generator ) override {
    type ITestInvoker (line 4770) | struct ITestInvoker
    type TestCaseInfo (line 4772) | struct TestCaseInfo {
      type SpecialProperties (line 4773) | enum SpecialProperties{
    class TestCase (line 4807) | class TestCase : public TestCaseInfo {
    type IRunner (line 4840) | struct IRunner {
    class WildcardPattern (line 5080) | class WildcardPattern {
      type WildcardPosition (line 5081) | enum WildcardPosition {
    type IConfig (line 5109) | struct IConfig
    class TestSpec (line 5111) | class TestSpec {
      class Pattern (line 5112) | class Pattern {
      class NamePattern (line 5123) | class NamePattern : public Pattern {
      class TagPattern (line 5131) | class TagPattern : public Pattern {
      class ExcludedPattern (line 5139) | class ExcludedPattern : public Pattern {
      type Filter (line 5147) | struct Filter {
      type FilterMatch (line 5155) | struct FilterMatch {
    type TagAlias (line 5185) | struct TagAlias
    type ITagAliasRegistry (line 5187) | struct ITagAliasRegistry {
    class TestSpecParser (line 5201) | class TestSpecParser {
      type Mode (line 5202) | enum Mode{ None, Name, QuotedName, Tag, EscapedName }
      method addCharToPattern (line 5243) | inline void addCharToPattern(char c) {
    type IStream (line 5271) | struct IStream
    type ConfigData (line 5273) | struct ConfigData {
    class Config (line 5317) | class Config : public IConfig {
      method Config (line 5320) | Config() = default;
    type AssertionResultData (line 5383) | struct AssertionResultData
      method AssertionResultData (line 5385) | AssertionResultData() = delete;
    class AssertionResult (line 5397) | class AssertionResult {
      method AssertionResult (line 5399) | AssertionResult() = delete;
    type Benchmark (line 5430) | namespace Benchmark {
      type Estimate (line 5432) | struct Estimate {
      type OutlierClassification (line 5453) | struct OutlierClassification {
        method total (line 5460) | int total() const {
      type now (line 6469) | struct now {
      function keep_memory (line 6493) | inline void keep_memory(T* p) {
      function keep_memory (line 6496) | inline void keep_memory() {
      type Detail (line 6500) | namespace Detail {
        function optimizer_barrier (line 6501) | inline void optimizer_barrier() { keep_memory(); }
        function optimizer_barrier (line 6515) | inline void optimizer_barrier() {
        type CompleteType (line 6552) | struct CompleteType { using type = T; }
        type CompleteType<void> (line 6554) | struct CompleteType<void> { struct type {}; }
          type type (line 6554) | struct type {}
        type CompleteInvoker (line 6560) | struct CompleteInvoker {
          method Result (line 6562) | static Result invoke(Fun&& fun, Args&&... args) {
        type CompleteInvoker<void> (line 6567) | struct CompleteInvoker<void> {
          method invoke (line 6569) | static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
        function complete_invoke (line 6577) | CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(F...
        type ChronometerConcept (line 6600) | struct ChronometerConcept {
        type ChronometerModel (line 6606) | struct ChronometerModel final : public ChronometerConcept {
          method start (line 6607) | void start() override { started = Clock::now(); }
          method finish (line 6608) | void finish() override { finished = Clock::now(); }
          method elapsed (line 6610) | ClockDuration<Clock> elapsed() const { return finished - started; }
        type is_related (line 6698) | struct is_related
        type BenchmarkFunction (line 6708) | struct BenchmarkFunction {
          type callable (line 6710) | struct callable {
          type model (line 6716) | struct model : public callable {
            method model (line 6717) | model(Fun&& fun) : fun(std::move(fun)) {}
            method model (line 6718) | model(Fun const& fun) : fun(fun) {}
            method call (line 6722) | void call(Chronometer meter) const override {
            method call (line 6725) | void call(Chronometer meter, std::true_type) const {
            method call (line 6728) | void call(Chronometer meter, std::false_type) const {
          type do_nothing (line 6735) | struct do_nothing { void operator()() const {} }
          method BenchmarkFunction (line 6738) | BenchmarkFunction(model<T>* c) : f(c) {}
          method BenchmarkFunction (line 6741) | BenchmarkFunction()
          method BenchmarkFunction (line 6746) | BenchmarkFunction(Fun&& fun)
          method BenchmarkFunction (line 6749) | BenchmarkFunction(BenchmarkFunction&& that)
          method BenchmarkFunction (line 6752) | BenchmarkFunction(BenchmarkFunction const& that)
          method BenchmarkFunction (line 6755) | BenchmarkFunction& operator=(BenchmarkFunction&& that) {
          method BenchmarkFunction (line 6760) | BenchmarkFunction& operator=(BenchmarkFunction const& that) {
        type repeater (line 6787) | struct repeater {
        function repeat (line 6796) | repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
        function measure (line 6842) | TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
        function measure_one (line 6861) | TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::f...
        function measure_one (line 6865) | TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters...
        type optimized_away_error (line 6875) | struct optimized_away_error : std::exception {
        function run_for_at_least (line 6882) | TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>> run_...
        function OutlierClassification (line 6967) | OutlierClassification classify_outliers(Iterator first, Iterator l...
        function mean (line 6991) | double mean(Iterator first, Iterator last) {
        function sample (line 6998) | sample resample(URng& rng, int resamples, Iterator first, Iterator...
        function sample (line 7015) | sample jackknife(Estimator&& estimator, Iterator first, Iterator l...
        function normal_cdf (line 7029) | inline double normal_cdf(double x) {
        function bootstrap (line 7038) | Estimate<double> bootstrap(double confidence_level, Iterator first...
        type bootstrap_analysis (line 7079) | struct bootstrap_analysis {
        function resolution (line 7101) | std::vector<double> resolution(int k) {
        function warmup (line 7126) | int warmup() {
        function estimate_clock_resolution (line 7131) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolutio...
        function estimate_clock_cost (line 7140) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(Floa...
        function measure_environment (line 7168) | Environment<FloatDuration<Clock>> measure_environment() {
        function analyse (line 7237) | SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<D...
        type ObjectStorage (line 7396) | struct ObjectStorage
          method ObjectStorage (line 7400) | ObjectStorage() : data() {}
          method ObjectStorage (line 7402) | ObjectStorage(const ObjectStorage& other)
          method ObjectStorage (line 7407) | ObjectStorage(ObjectStorage&& other)
          method construct (line 7415) | void construct(Args&&... args)
          method destruct (line 7421) | typename std::enable_if<AllowManualDestruction>::type destruct()
          method destruct_on_exit (line 7429) | void destruct_on_exit(typename std::enable_if<Destruct, U>::type...
          method destruct_on_exit (line 7432) | void destruct_on_exit(typename std::enable_if<!Destruct, U>::typ...
          method T (line 7434) | T& stored_object() {
          method T (line 7438) | T const& stored_object() const {
        function weighted_average_quantile (line 7753) | double weighted_average_quantile(int k, int q, std::vector<double>...
        function erfc_inv (line 7766) | double erfc_inv(double x) {
        function normal_quantile (line 7770) | double normal_quantile(double p) {
        function outlier_variance (line 7786) | double outlier_variance(Estimate<double> mean, Estimate<double> st...
        function bootstrap_analysis (line 7812) | bootstrap_analysis analyse_samples(double confidence_level, int n_...
      function keep_memory (line 6507) | inline void keep_memory(T* p) {
      type Detail (line 6514) | namespace Detail {
        function optimizer_barrier (line 6501) | inline void optimizer_barrier() { keep_memory(); }
        function optimizer_barrier (line 6515) | inline void optimizer_barrier() {
        type CompleteType (line 6552) | struct CompleteType { using type = T; }
        type CompleteType<void> (line 6554) | struct CompleteType<void> { struct type {}; }
          type type (line 6554) | struct type {}
        type CompleteInvoker (line 6560) | struct CompleteInvoker {
          method Result (line 6562) | static Result invoke(Fun&& fun, Args&&... args) {
        type CompleteInvoker<void> (line 6567) | struct CompleteInvoker<void> {
          method invoke (line 6569) | static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
        function complete_invoke (line 6577) | CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(F...
        type ChronometerConcept (line 6600) | struct ChronometerConcept {
        type ChronometerModel (line 6606) | struct ChronometerModel final : public ChronometerConcept {
          method start (line 6607) | void start() override { started = Clock::now(); }
          method finish (line 6608) | void finish() override { finished = Clock::now(); }
          method elapsed (line 6610) | ClockDuration<Clock> elapsed() const { return finished - started; }
        type is_related (line 6698) | struct is_related
        type BenchmarkFunction (line 6708) | struct BenchmarkFunction {
          type callable (line 6710) | struct callable {
          type model (line 6716) | struct model : public callable {
            method model (line 6717) | model(Fun&& fun) : fun(std::move(fun)) {}
            method model (line 6718) | model(Fun const& fun) : fun(fun) {}
            method call (line 6722) | void call(Chronometer meter) const override {
            method call (line 6725) | void call(Chronometer meter, std::true_type) const {
            method call (line 6728) | void call(Chronometer meter, std::false_type) const {
          type do_nothing (line 6735) | struct do_nothing { void operator()() const {} }
          method BenchmarkFunction (line 6738) | BenchmarkFunction(model<T>* c) : f(c) {}
          method BenchmarkFunction (line 6741) | BenchmarkFunction()
          method BenchmarkFunction (line 6746) | BenchmarkFunction(Fun&& fun)
          method BenchmarkFunction (line 6749) | BenchmarkFunction(BenchmarkFunction&& that)
          method BenchmarkFunction (line 6752) | BenchmarkFunction(BenchmarkFunction const& that)
          method BenchmarkFunction (line 6755) | BenchmarkFunction& operator=(BenchmarkFunction&& that) {
          method BenchmarkFunction (line 6760) | BenchmarkFunction& operator=(BenchmarkFunction const& that) {
        type repeater (line 6787) | struct repeater {
        function repeat (line 6796) | repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
        function measure (line 6842) | TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
        function measure_one (line 6861) | TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::f...
        function measure_one (line 6865) | TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters...
        type optimized_away_error (line 6875) | struct optimized_away_error : std::exception {
        function run_for_at_least (line 6882) | TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>> run_...
        function OutlierClassification (line 6967) | OutlierClassification classify_outliers(Iterator first, Iterator l...
        function mean (line 6991) | double mean(Iterator first, Iterator last) {
        function sample (line 6998) | sample resample(URng& rng, int resamples, Iterator first, Iterator...
        function sample (line 7015) | sample jackknife(Estimator&& estimator, Iterator first, Iterator l...
        function normal_cdf (line 7029) | inline double normal_cdf(double x) {
        function bootstrap (line 7038) | Estimate<double> bootstrap(double confidence_level, Iterator first...
        type bootstrap_analysis (line 7079) | struct bootstrap_analysis {
        function resolution (line 7101) | std::vector<double> resolution(int k) {
        function warmup (line 7126) | int warmup() {
        function estimate_clock_resolution (line 7131) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolutio...
        function estimate_clock_cost (line 7140) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(Floa...
        function measure_environment (line 7168) | Environment<FloatDuration<Clock>> measure_environment() {
        function analyse (line 7237) | SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<D...
        type ObjectStorage (line 7396) | struct ObjectStorage
          method ObjectStorage (line 7400) | ObjectStorage() : data() {}
          method ObjectStorage (line 7402) | ObjectStorage(const ObjectStorage& other)
          method ObjectStorage (line 7407) | ObjectStorage(ObjectStorage&& other)
          method construct (line 7415) | void construct(Args&&... args)
          method destruct (line 7421) | typename std::enable_if<AllowManualDestruction>::type destruct()
          method destruct_on_exit (line 7429) | void destruct_on_exit(typename std::enable_if<Destruct, U>::type...
          method destruct_on_exit (line 7432) | void destruct_on_exit(typename std::enable_if<!Destruct, U>::typ...
          method T (line 7434) | T& stored_object() {
          method T (line 7438) | T const& stored_object() const {
        function weighted_average_quantile (line 7753) | double weighted_average_quantile(int k, int q, std::vector<double>...
        function erfc_inv (line 7766) | double erfc_inv(double x) {
        function normal_quantile (line 7770) | double normal_quantile(double p) {
        function outlier_variance (line 7786) | double outlier_variance(Estimate<double> mean, Estimate<double> st...
        function bootstrap_analysis (line 7812) | bootstrap_analysis analyse_samples(double confidence_level, int n_...
      function deoptimize_value (line 6523) | inline void deoptimize_value(T&& x) {
      function invoke_deoptimized (line 6528) | inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename ...
      function invoke_deoptimized (line 6533) | inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename ...
      type Detail (line 6550) | namespace Detail {
        function optimizer_barrier (line 6501) | inline void optimizer_barrier() { keep_memory(); }
        function optimizer_barrier (line 6515) | inline void optimizer_barrier() {
        type CompleteType (line 6552) | struct CompleteType { using type = T; }
        type CompleteType<void> (line 6554) | struct CompleteType<void> { struct type {}; }
          type type (line 6554) | struct type {}
        type CompleteInvoker (line 6560) | struct CompleteInvoker {
          method Result (line 6562) | static Result invoke(Fun&& fun, Args&&... args) {
        type CompleteInvoker<void> (line 6567) | struct CompleteInvoker<void> {
          method invoke (line 6569) | static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
        function complete_invoke (line 6577) | CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(F...
        type ChronometerConcept (line 6600) | struct ChronometerConcept {
        type ChronometerModel (line 6606) | struct ChronometerModel final : public ChronometerConcept {
          method start (line 6607) | void start() override { started = Clock::now(); }
          method finish (line 6608) | void finish() override { finished = Clock::now(); }
          method elapsed (line 6610) | ClockDuration<Clock> elapsed() const { return finished - started; }
        type is_related (line 6698) | struct is_related
        type BenchmarkFunction (line 6708) | struct BenchmarkFunction {
          type callable (line 6710) | struct callable {
          type model (line 6716) | struct model : public callable {
            method model (line 6717) | model(Fun&& fun) : fun(std::move(fun)) {}
            method model (line 6718) | model(Fun const& fun) : fun(fun) {}
            method call (line 6722) | void call(Chronometer meter) const override {
            method call (line 6725) | void call(Chronometer meter, std::true_type) const {
            method call (line 6728) | void call(Chronometer meter, std::false_type) const {
          type do_nothing (line 6735) | struct do_nothing { void operator()() const {} }
          method BenchmarkFunction (line 6738) | BenchmarkFunction(model<T>* c) : f(c) {}
          method BenchmarkFunction (line 6741) | BenchmarkFunction()
          method BenchmarkFunction (line 6746) | BenchmarkFunction(Fun&& fun)
          method BenchmarkFunction (line 6749) | BenchmarkFunction(BenchmarkFunction&& that)
          method BenchmarkFunction (line 6752) | BenchmarkFunction(BenchmarkFunction const& that)
          method BenchmarkFunction (line 6755) | BenchmarkFunction& operator=(BenchmarkFunction&& that) {
          method BenchmarkFunction (line 6760) | BenchmarkFunction& operator=(BenchmarkFunction const& that) {
        type repeater (line 6787) | struct repeater {
        function repeat (line 6796) | repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
        function measure (line 6842) | TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
        function measure_one (line 6861) | TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::f...
        function measure_one (line 6865) | TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters...
        type optimized_away_error (line 6875) | struct optimized_away_error : std::exception {
        function run_for_at_least (line 6882) | TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>> run_...
        function OutlierClassification (line 6967) | OutlierClassification classify_outliers(Iterator first, Iterator l...
        function mean (line 6991) | double mean(Iterator first, Iterator last) {
        function sample (line 6998) | sample resample(URng& rng, int resamples, Iterator first, Iterator...
        function sample (line 7015) | sample jackknife(Estimator&& estimator, Iterator first, Iterator l...
        function normal_cdf (line 7029) | inline double normal_cdf(double x) {
        function bootstrap (line 7038) | Estimate<double> bootstrap(double confidence_level, Iterator first...
        type bootstrap_analysis (line 7079) | struct bootstrap_analysis {
        function resolution (line 7101) | std::vector<double> resolution(int k) {
        function warmup (line 7126) | int warmup() {
        function estimate_clock_resolution (line 7131) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolutio...
        function estimate_clock_cost (line 7140) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(Floa...
        function measure_environment (line 7168) | Environment<FloatDuration<Clock>> measure_environment() {
        function analyse (line 7237) | SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<D...
        type ObjectStorage (line 7396) | struct ObjectStorage
          method ObjectStorage (line 7400) | ObjectStorage() : data() {}
          method ObjectStorage (line 7402) | ObjectStorage(const ObjectStorage& other)
          method ObjectStorage (line 7407) | ObjectStorage(ObjectStorage&& other)
          method construct (line 7415) | void construct(Args&&... args)
          method destruct (line 7421) | typename std::enable_if<AllowManualDestruction>::type destruct()
          method destruct_on_exit (line 7429) | void destruct_on_exit(typename std::enable_if<Destruct, U>::type...
          method destruct_on_exit (line 7432) | void destruct_on_exit(typename std::enable_if<!Destruct, U>::typ...
          method T (line 7434) | T& stored_object() {
          method T (line 7438) | T const& stored_object() const {
        function weighted_average_quantile (line 7753) | double weighted_average_quantile(int k, int q, std::vector<double>...
        function erfc_inv (line 7766) | double erfc_inv(double x) {
        function normal_quantile (line 7770) | double normal_quantile(double p) {
        function outlier_variance (line 7786) | double outlier_variance(Estimate<double> mean, Estimate<double> st...
        function bootstrap_analysis (line 7812) | bootstrap_analysis analyse_samples(double confidence_level, int n_...
      function user_code (line 6585) | Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
      type Detail (line 6599) | namespace Detail {
        function optimizer_barrier (line 6501) | inline void optimizer_barrier() { keep_memory(); }
        function optimizer_barrier (line 6515) | inline void optimizer_barrier() {
        type CompleteType (line 6552) | struct CompleteType { using type = T; }
        type CompleteType<void> (line 6554) | struct CompleteType<void> { struct type {}; }
          type type (line 6554) | struct type {}
        type CompleteInvoker (line 6560) | struct CompleteInvoker {
          method Result (line 6562) | static Result invoke(Fun&& fun, Args&&... args) {
        type CompleteInvoker<void> (line 6567) | struct CompleteInvoker<void> {
          method invoke (line 6569) | static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
        function complete_invoke (line 6577) | CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(F...
        type ChronometerConcept (line 6600) | struct ChronometerConcept {
        type ChronometerModel (line 6606) | struct ChronometerModel final : public ChronometerConcept {
          method start (line 6607) | void start() override { started = Clock::now(); }
          method finish (line 6608) | void finish() override { finished = Clock::now(); }
          method elapsed (line 6610) | ClockDuration<Clock> elapsed() const { return finished - started; }
        type is_related (line 6698) | struct is_related
        type BenchmarkFunction (line 6708) | struct BenchmarkFunction {
          type callable (line 6710) | struct callable {
          type model (line 6716) | struct model : public callable {
            method model (line 6717) | model(Fun&& fun) : fun(std::move(fun)) {}
            method model (line 6718) | model(Fun const& fun) : fun(fun) {}
            method call (line 6722) | void call(Chronometer meter) const override {
            method call (line 6725) | void call(Chronometer meter, std::true_type) const {
            method call (line 6728) | void call(Chronometer meter, std::false_type) const {
          type do_nothing (line 6735) | struct do_nothing { void operator()() const {} }
          method BenchmarkFunction (line 6738) | BenchmarkFunction(model<T>* c) : f(c) {}
          method BenchmarkFunction (line 6741) | BenchmarkFunction()
          method BenchmarkFunction (line 6746) | BenchmarkFunction(Fun&& fun)
          method BenchmarkFunction (line 6749) | BenchmarkFunction(BenchmarkFunction&& that)
          method BenchmarkFunction (line 6752) | BenchmarkFunction(BenchmarkFunction const& that)
          method BenchmarkFunction (line 6755) | BenchmarkFunction& operator=(BenchmarkFunction&& that) {
          method BenchmarkFunction (line 6760) | BenchmarkFunction& operator=(BenchmarkFunction const& that) {
        type repeater (line 6787) | struct repeater {
        function repeat (line 6796) | repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
        function measure (line 6842) | TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
        function measure_one (line 6861) | TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::f...
        function measure_one (line 6865) | TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters...
        type optimized_away_error (line 6875) | struct optimized_away_error : std::exception {
        function run_for_at_least (line 6882) | TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>> run_...
        function OutlierClassification (line 6967) | OutlierClassification classify_outliers(Iterator first, Iterator l...
        function mean (line 6991) | double mean(Iterator first, Iterator last) {
        function sample (line 6998) | sample resample(URng& rng, int resamples, Iterator first, Iterator...
        function sample (line 7015) | sample jackknife(Estimator&& estimator, Iterator first, Iterator l...
        function normal_cdf (line 7029) | inline double normal_cdf(double x) {
        function bootstrap (line 7038) | Estimate<double> bootstrap(double confidence_level, Iterator first...
        type bootstrap_analysis (line 7079) | struct bootstrap_analysis {
        function resolution (line 7101) | std::vector<double> resolution(int k) {
        function warmup (line 7126) | int warmup() {
        function estimate_clock_resolution (line 7131) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolutio...
        function estimate_clock_cost (line 7140) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(Floa...
        function measure_environment (line 7168) | Environment<FloatDuration<Clock>> measure_environment() {
        function analyse (line 7237) | SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<D...
        type ObjectStorage (line 7396) | struct ObjectStorage
          method ObjectStorage (line 7400) | ObjectStorage() : data() {}
          method ObjectStorage (line 7402) | ObjectStorage(const ObjectStorage& other)
          method ObjectStorage (line 7407) | ObjectStorage(ObjectStorage&& other)
          method construct (line 7415) | void construct(Args&&... args)
          method destruct (line 7421) | typename std::enable_if<AllowManualDestruction>::type destruct()
          method destruct_on_exit (line 7429) | void destruct_on_exit(typename std::enable_if<Destruct, U>::type...
          method destruct_on_exit (line 7432) | void destruct_on_exit(typename std::enable_if<!Destruct, U>::typ...
          method T (line 7434) | T& stored_object() {
          method T (line 7438) | T const& stored_object() const {
        function weighted_average_quantile (line 7753) | double weighted_average_quantile(int k, int q, std::vector<double>...
        function erfc_inv (line 7766) | double erfc_inv(double x) {
        function normal_quantile (line 7770) | double normal_quantile(double p) {
        function outlier_variance (line 7786) | double outlier_variance(Estimate<double> mean, Estimate<double> st...
        function bootstrap_analysis (line 7812) | bootstrap_analysis analyse_samples(double confidence_level, int n_...
      type Chronometer (line 6617) | struct Chronometer {
        method measure (line 6620) | void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_calla...
        method runs (line 6622) | int runs() const { return k; }
        method Chronometer (line 6624) | Chronometer(Detail::ChronometerConcept& meter, int k)
        method measure (line 6630) | void measure(Fun&& fun, std::false_type) {
        method measure (line 6635) | void measure(Fun&& fun, std::true_type) {
      type EnvironmentEstimate (line 6658) | struct EnvironmentEstimate {
      type Environment (line 6668) | struct Environment {
      type Detail (line 6694) | namespace Detail {
        function optimizer_barrier (line 6501) | inline void optimizer_barrier() { keep_memory(); }
        function optimizer_barrier (line 6515) | inline void optimizer_barrier() {
        type CompleteType (line 6552) | struct CompleteType { using type = T; }
        type CompleteType<void> (line 6554) | struct CompleteType<void> { struct type {}; }
          type type (line 6554) | struct type {}
        type CompleteInvoker (line 6560) | struct CompleteInvoker {
          method Result (line 6562) | static Result invoke(Fun&& fun, Args&&... args) {
        type CompleteInvoker<void> (line 6567) | struct CompleteInvoker<void> {
          method invoke (line 6569) | static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
        function complete_invoke (line 6577) | CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(F...
        type ChronometerConcept (line 6600) | struct ChronometerConcept {
        type ChronometerModel (line 6606) | struct ChronometerModel final : public ChronometerConcept {
          method start (line 6607) | void start() override { started = Clock::now(); }
          method finish (line 6608) | void finish() override { finished = Clock::now(); }
          method elapsed (line 6610) | ClockDuration<Clock> elapsed() const { return finished - started; }
        type is_related (line 6698) | struct is_related
        type BenchmarkFunction (line 6708) | struct BenchmarkFunction {
          type callable (line 6710) | struct callable {
          type model (line 6716) | struct model : public callable {
            method model (line 6717) | model(Fun&& fun) : fun(std::move(fun)) {}
            method model (line 6718) | model(Fun const& fun) : fun(fun) {}
            method call (line 6722) | void call(Chronometer meter) const override {
            method call (line 6725) | void call(Chronometer meter, std::true_type) const {
            method call (line 6728) | void call(Chronometer meter, std::false_type) const {
          type do_nothing (line 6735) | struct do_nothing { void operator()() const {} }
          method BenchmarkFunction (line 6738) | BenchmarkFunction(model<T>* c) : f(c) {}
          method BenchmarkFunction (line 6741) | BenchmarkFunction()
          method BenchmarkFunction (line 6746) | BenchmarkFunction(Fun&& fun)
          method BenchmarkFunction (line 6749) | BenchmarkFunction(BenchmarkFunction&& that)
          method BenchmarkFunction (line 6752) | BenchmarkFunction(BenchmarkFunction const& that)
          method BenchmarkFunction (line 6755) | BenchmarkFunction& operator=(BenchmarkFunction&& that) {
          method BenchmarkFunction (line 6760) | BenchmarkFunction& operator=(BenchmarkFunction const& that) {
        type repeater (line 6787) | struct repeater {
        function repeat (line 6796) | repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
        function measure (line 6842) | TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
        function measure_one (line 6861) | TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::f...
        function measure_one (line 6865) | TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters...
        type optimized_away_error (line 6875) | struct optimized_away_error : std::exception {
        function run_for_at_least (line 6882) | TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>> run_...
        function OutlierClassification (line 6967) | OutlierClassification classify_outliers(Iterator first, Iterator l...
        function mean (line 6991) | double mean(Iterator first, Iterator last) {
        function sample (line 6998) | sample resample(URng& rng, int resamples, Iterator first, Iterator...
        function sample (line 7015) | sample jackknife(Estimator&& estimator, Iterator first, Iterator l...
        function normal_cdf (line 7029) | inline double normal_cdf(double x) {
        function bootstrap (line 7038) | Estimate<double> bootstrap(double confidence_level, Iterator first...
        type bootstrap_analysis (line 7079) | struct bootstrap_analysis {
        function resolution (line 7101) | std::vector<double> resolution(int k) {
        function warmup (line 7126) | int warmup() {
        function estimate_clock_resolution (line 7131) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolutio...
        function estimate_clock_cost (line 7140) | EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(Floa...
        function measure_environment (line 7168) | Environment<FloatDuration<Clock>> measure_environment() {
        function analyse (line 7237) | SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<D...
        type ObjectStorage (line 7396) | struct ObjectStorage
          method ObjectStorage (line 7400) | ObjectStorage() : data() {}
          method ObjectStorage (line 7402) | ObjectStorage(const ObjectStorage& other)
          method ObjectStorage (line 7407) | ObjectStorage(ObjectStorage&& other)
          method construct (line 7415) | void construct(Args&&... args)
          method destruct (line 7421) | typename std::enable_if<AllowManualDestruction>::type destruct()
          method destruct_on_exit (line 7429) | void destruct_on_exit(typename std::enable_if<Destruct, U>::type...
          method destruct_on_exit (line 7432) | void destruct_on_exit(typename std::enable_if<!Destruct, U>::typ...
          method T (line 7434) | T& stored_object() {
          method T (line 7438) | T const& stored_object() const {
        function weighted_average_quantile (line 7753) | double weighted_average_quantile(int k, int q, std::vector<double>...
        function erfc_inv (line 7766) | double erfc_inv(double x) {
        function normal_quantile (line 7770) | double normal_quantile(double p) {
        function outlier_variance (line 7786) | double outlier_variance(Estimate<double> mean, Estimate<double> st...
        function bootstrap_analysis (line 7812) | bootstrap_analysis analyse_samples(double confidence_level, int n_...
      type Detail (line 6785) | namespace Detail {
        function optimizer_barrier (line 6501) | inline void optimizer_barrier() { keep_memory(); }
        function optimizer_barrier (line 6515) | inline void optimizer_barrier() {
        type CompleteType (line 6552) | struct CompleteType { using type = T; }
        type CompleteType<void> (line 6554) | struct CompleteType<void> { struct type {}; }
          type type (line 6554) | struct type {}
        type CompleteInvoker (line 6560) | struct CompleteInvoker {
          method Result (line 6562) | static Result invoke(Fun&& fun, Args&&... args) {
        type CompleteInvoker<void> (line 6567) | struct CompleteInvoker<void> {
          method invoke (line 6569) | static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
        function complete_invoke (line 6577) | CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(F...
        type ChronometerConcept (line 6600) | struct ChronometerConcept {
        type ChronometerModel (line 6606) | struct ChronometerModel final : public ChronometerConcept {
          method start (line 6607) | void start() override { started = Clock::now(); }
          method finish (line 6608) | void finish() override { finished = Clock::now(); }
          method elapsed (line 6610) | ClockDuration<Clock> elapsed() const { return finished - started; }
        type is_related (line 6698) | struct is_related
        type BenchmarkFunction (line 6708) | struct BenchmarkFunction {
          type callable (line 6710) | struct callable {
          type model (line 6716) | struct model : public callable {
            method model (line 6717) | model(Fun&& fun) : fun(std::move(fun)) {}
            method model (line 6718) | model(Fun const& fun) : fun(fun) {}
            method call (line 6722) | void call(Chronometer meter) const override {
            method call (line 6725) | void call(Chronometer meter, std::true_type) const {
            method call (line 6728) | void call(Chronometer meter, std::false_type) const {
          type do_nothing (line 6735) | struct do_nothing { void operator()() const {} }
          method BenchmarkFunction (line 6738) | BenchmarkFunction(model<T>* c) : f(c) {}
          method BenchmarkFunction (line 6741) | BenchmarkFunction()
          method BenchmarkFunction (line 6746) | BenchmarkFunction(Fun&& fun)
          method BenchmarkFunction (line 6749) | BenchmarkFunction(BenchmarkFunction&& that)
          method BenchmarkFunction (line 6752) | BenchmarkFunction(BenchmarkFunction const& that)
          method BenchmarkFunction (line 6755) | BenchmarkFunction& operator=(BenchmarkFunction&& that) {
          method BenchmarkFunction (line 6760) | BenchmarkFunction& operator=(BenchmarkFunction const& that) {
        type repeater (line 6787) | struct repeater {
        function repeat (line 6796) | repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
        function measure (line 6842) | TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
        function measure_one (line 6861) | TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::f...
        function measure_one (line 6865) | TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters...
        type optimized_away_error (line 6875) | struct optimized_away_error : std::exception {
        function run_for_at_least (line 6882) | TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>> run_...
        function OutlierClassification (line 6967) | OutlierClassification classify_outliers(Iterator first, Iterator l...
        function mean (line 6991) | double mean(Iterator first, Iterator last) {
        function sample (line 6998) | sample resample(URng& rng, int resamples, Iterator first, Iterator...
        function sample (line 7015) | sample jackknife(Estimator&& estimator, Iterator first, Iterator l...
        function normal_cdf (line 7029) | inline double normal_cdf(double x) {
        function bootstrap (line 7038) | Estimate<double> bootstrap(double confidenc

Download .json

Condensed preview — 8 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (705K chars).

[
  {
    "path": ".clang-format",
    "chars": 1973,
    "preview": "---\nLanguage:        Cpp\n# BasedOnStyle:  Mozilla\nAccessModifierOffset: -4\nAlignAfterOpenBracket: false\nAlignEscapedNewl"
  },
  {
    "path": ".github/workflows/main.yml",
    "chars": 316,
    "preview": "name: cpptime CI\n\non: push\n\njobs:\n  unit_test:\n    name: Run Tests\n    runs-on: ubuntu-latest\n\n    steps:\n      - name: "
  },
  {
    "path": ".gitignore",
    "chars": 23,
    "preview": "# The test binary\ntest\n"
  },
  {
    "path": "LICENSE",
    "chars": 1080,
    "preview": "The MIT License (MIT)\n\nCopyright (c) 2015 Michael Egli\n\nPermission is hereby granted, free of charge, to any person obta"
  },
  {
    "path": "README.md",
    "chars": 3444,
    "preview": "# C++ Timeouts\n\nA portable, header-only C++11 timer component.\n\nIt manages a set of timeouts that, when expired, invoke "
  },
  {
    "path": "cpptime.h",
    "chars": 9210,
    "preview": "#ifndef CPPTIME_H_\n#define CPPTIME_H_\n\n/**\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 Michael Egli\n *\n * Permissi"
  },
  {
    "path": "tests/catch.hpp",
    "chars": 657174,
    "preview": "/*\n *  Catch v2.13.8\n *  Generated: 2022-01-03 21:20:09.589503\n *  -----------------------------------------------------"
  },
  {
    "path": "tests/timer_test.cpp",
    "chars": 8236,
    "preview": "/**\n * The MIT License (MIT)\n *\n * Copyright (c) 2015 Michael Egli\n *\n * Permission is hereby granted, free of charge, t"
  }
]

About this extraction

This page contains the full source code of the eglimi/cpptime GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 8 files (665.5 KB), approximately 154.6k tokens, and a symbol index with 1462 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.

Extract another repo