#include "catch_amalgamated.hpp"

#include <cassert>

#include <cstddef>

#include <iterator>

#include <random>

#if defined(CATCH_CONFIG_USE_ASYNC)

#include <future>

#endif

namespace {

using Catch::Benchmark::Detail::sample;

template <typename URng, typename Estimator>

sample resample(URng& rng, unsigned int resamples, std::vector<double>::iterator first, std::vector<double>::iterator last, Estimator& estimator) {

}

double erf_inv(double x) {

}

double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {

}

}

namespace Catch {

namespace Benchmark {

namespace Detail {

#if defined( __GNUC__ ) || defined( __clang__ )

# pragma GCC diagnostic push

# pragma GCC diagnostic ignored "-Wfloat-equal"

#endif

bool directCompare( double lhs, double rhs ) { return lhs == rhs; }

#if defined( __GNUC__ ) || defined( __clang__ )

# pragma GCC diagnostic pop

#endif

double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {

}

double erfc_inv(double x) {

return erf_inv(1.0 - x);

}

double normal_quantile(double p) {

}

double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {

}

bootstrap_analysis analyse_samples(double confidence_level, unsigned int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {

}

} // namespace Detail

} // namespace Benchmark

} // namespace Catch

namespace Catch {

namespace Benchmark {

namespace Detail {

ChronometerConcept::~ChronometerConcept() = default;

} // namespace Detail

} // namespace Benchmark

} // namespace Catch

namespace Catch {

namespace Benchmark {

namespace Detail {

BenchmarkFunction::callable::~callable() = default;

} // namespace Detail

} // namespace Benchmark

} // namespace Catch

#include <exception>

namespace Catch {

namespace Benchmark {

namespace Detail {

struct optimized_away_error : std::exception {

const char* what() const noexcept override;

};

const char* optimized_away_error::what() const noexcept {

return "could not measure benchmark, maybe it was optimized away";

}

void throw_optimized_away_error() {

Catch::throw_exception(optimized_away_error{});

}

} // namespace Detail

} // namespace Benchmark

} // namespace Catch

#include <cmath>

#include <limits>

namespace {

bool marginComparison(double lhs, double rhs, double margin) {

return (lhs + margin >= rhs) && (rhs + margin >= lhs);

}

}

namespace Catch {

Approx::Approx ( double value )

{}

Approx Approx::custom() {

return Approx( 0 );

}

Approx Approx::operator-() const {

auto temp(*this);

temp.m_value = -temp.m_value;

return temp;

}

std::string Approx::toString() const {

}

bool Approx::equalityComparisonImpl(const double other) const {

}

void Approx::setMargin(double newMargin) {

}

void Approx::setEpsilon(double newEpsilon) {

}

namespace literals {

Approx operator "" _a(long double val) {

return Approx(val);

}

Approx operator "" _a(unsigned long long val) {

return Approx(val);

}

} // end namespace literals

std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) {

return value.toString();

}

} // end namespace Catch

namespace Catch {

AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):

lazyExpression(_lazyExpression),

resultType(_resultType) {}

std::string AssertionResultData::reconstructExpression() const {

}

AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )

: m_info( info ),

m_resultData( data )

{}

// Result was a success

bool AssertionResult::succeeded() const {

return Catch::isOk( m_resultData.resultType );

}

// Result was a success, or failure is suppressed

bool AssertionResult::isOk() const {

return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );

}

ResultWas::OfType AssertionResult::getResultType() const {

return m_resultData.resultType;

}

bool AssertionResult::hasExpression() const {

return !m_info.capturedExpression.empty();

}

bool AssertionResult::hasMessage() const {

return !m_resultData.message.empty();

}

std::string AssertionResult::getExpression() const {

}

std::string AssertionResult::getExpressionInMacro() const {

}

bool AssertionResult::hasExpandedExpression() const {

return hasExpression() && getExpandedExpression() != getExpression();

}

std::string AssertionResult::getExpandedExpression() const {

}

StringRef AssertionResult::getMessage() const {

return m_resultData.message;

}

SourceLineInfo AssertionResult::getSourceInfo() const {

return m_info.lineInfo;

}

StringRef AssertionResult::getTestMacroName() const {

return m_info.macroName;

}

} // end namespace Catch

namespace Catch {

bool operator==( ProcessedReporterSpec const& lhs,

ProcessedReporterSpec const& rhs ) {

return lhs.name == rhs.name &&

lhs.outputFilename == rhs.outputFilename &&

lhs.colourMode == rhs.colourMode &&

lhs.customOptions == rhs.customOptions;

}

Config::Config( ConfigData const& data ):

m_data( data ) {

// We need to trim filter specs to avoid trouble with superfluous

// whitespace (esp. important for bdd macros, as those are manually

// aligned with whitespace).

for (auto& elem : m_data.testsOrTags) {

elem = trim(elem);

}

for (auto& elem : m_data.sectionsToRun) {

elem = trim(elem);

}

TestSpecParser parser(ITagAliasRegistry::get());

if (!m_data.testsOrTags.empty()) {

m_hasTestFilters = true;

for (auto const& testOrTags : m_data.testsOrTags) {

parser.parse(testOrTags);

}

}

m_testSpec = parser.testSpec();

// Insert the default reporter if user hasn't asked for a specfic one

if ( m_data.reporterSpecifications.empty() ) {

m_data.reporterSpecifications.push_back( {

#if defined( CATCH_CONFIG_DEFAULT_REPORTER )

CATCH_CONFIG_DEFAULT_REPORTER,

#else

"console",

#endif

{}, {}, {}

} );

}

#if defined( CATCH_CONFIG_BAZEL_SUPPORT )

// Register a JUnit reporter for Bazel. Bazel sets an environment

// variable with the path to XML output. If this file is written to

// during test, Bazel will not generate a default XML output.

// This allows the XML output file to contain higher level of detail

// than what is possible otherwise.

# if defined( _MSC_VER )

// On Windows getenv throws a warning as there is no input validation,

// since the key is hardcoded, this should not be an issue.

# pragma warning( push )

# pragma warning( disable : 4996 )

# endif

const auto bazelOutputFilePtr = std::getenv( "XML_OUTPUT_FILE" );

# if defined( _MSC_VER )

# pragma warning( pop )

# endif

if ( bazelOutputFilePtr != nullptr ) {

m_data.reporterSpecifications.push_back(

{ "junit", std::string( bazelOutputFilePtr ), {}, {} } );

}

#endif

// We now fixup the reporter specs to handle default output spec,

// default colour spec, etc

bool defaultOutputUsed = false;

for ( auto const& reporterSpec : m_data.reporterSpecifications ) {

// We do the default-output check separately, while always

// using the default output below to make the code simpler

// and avoid superfluous copies.

if ( reporterSpec.outputFile().none() ) {

CATCH_ENFORCE( !defaultOutputUsed,

"Internal error: cannot use default output for "

"multiple reporters" );

defaultOutputUsed = true;

}

m_processedReporterSpecs.push_back( ProcessedReporterSpec{

reporterSpec.name(),

reporterSpec.outputFile() ? *reporterSpec.outputFile()

: data.defaultOutputFilename,

reporterSpec.colourMode().valueOr( data.defaultColourMode ),

reporterSpec.customOptions() } );

}

}

Config::~Config() = default;

bool Config::listTests() const { return m_data.listTests; }

bool Config::listTags() const { return m_data.listTags; }

bool Config::listReporters() const { return m_data.listReporters; }

bool Config::listListeners() const { return m_data.listListeners; }

std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }

std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }

std::vector<ReporterSpec> const& Config::getReporterSpecs() const {

return m_data.reporterSpecifications;

}

std::vector<ProcessedReporterSpec> const&

Config::getProcessedReporterSpecs() const {

return m_processedReporterSpecs;

}

TestSpec const& Config::testSpec() const { return m_testSpec; }

bool Config::hasTestFilters() const { return m_hasTestFilters; }

bool Config::showHelp() const { return m_data.showHelp; }

// IConfig interface

bool Config::allowThrows() const { return !m_data.noThrow; }

StringRef Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; }

bool Config::includeSuccessfulResults() const { return m_data.showSuccessfulTests; }

bool Config::warnAboutMissingAssertions() const {

return !!( m_data.warnings & WarnAbout::NoAssertions );

}

bool Config::warnAboutUnmatchedTestSpecs() const {

return !!( m_data.warnings & WarnAbout::UnmatchedTestSpec );

}

bool Config::zeroTestsCountAsSuccess() const { return m_data.allowZeroTests; }

ShowDurations Config::showDurations() const { return m_data.showDurations; }

double Config::minDuration() const { return m_data.minDuration; }

TestRunOrder Config::runOrder() const { return m_data.runOrder; }

uint32_t Config::rngSeed() const { return m_data.rngSeed; }

unsigned int Config::shardCount() const { return m_data.shardCount; }

unsigned int Config::shardIndex() const { return m_data.shardIndex; }

ColourMode Config::defaultColourMode() const { return m_data.defaultColourMode; }

bool Config::shouldDebugBreak() const { return m_data.shouldDebugBreak; }

int Config::abortAfter() const { return m_data.abortAfter; }

bool Config::showInvisibles() const { return m_data.showInvisibles; }

Verbosity Config::verbosity() const { return m_data.verbosity; }

bool Config::skipBenchmarks() const { return m_data.skipBenchmarks; }

bool Config::benchmarkNoAnalysis() const { return m_data.benchmarkNoAnalysis; }

unsigned int Config::benchmarkSamples() const { return m_data.benchmarkSamples; }

double Config::benchmarkConfidenceInterval() const { return m_data.benchmarkConfidenceInterval; }

unsigned int Config::benchmarkResamples() const { return m_data.benchmarkResamples; }

std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }

} // end namespace Catch

#include <cassert>

#include <stack>

namespace Catch {

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

ScopedMessage::ScopedMessage( MessageBuilder const& builder ):

}

ScopedMessage::ScopedMessage( ScopedMessage&& old ) noexcept:

m_info( CATCH_MOVE( old.m_info ) ) {

old.m_moved = true;

}

ScopedMessage::~ScopedMessage() {

if ( !uncaught_exceptions() && !m_moved ){

getResultCapture().popScopedMessage(m_info);

}

}

Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {

}

Capturer::~Capturer() {

if ( !uncaught_exceptions() ){

assert( m_captured == m_messages.size() );

for( size_t i = 0; i < m_captured; ++i )

m_resultCapture.popScopedMessage( m_messages[i] );

}

}

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

}

} // end namespace Catch

namespace Catch {

namespace {

class RegistryHub : public IRegistryHub,

};

}

using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;

IRegistryHub const& getRegistryHub() {

return RegistryHubSingleton::get();

}

IMutableRegistryHub& getMutableRegistryHub() {

return RegistryHubSingleton::getMutable();

}

void cleanUp() {

cleanupSingletons();

cleanUpContext();

}

std::string translateActiveException() {

return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();

}

} // end namespace Catch

#include <algorithm>

#include <cassert>

#include <iomanip>

#include <set>

namespace Catch {

namespace {

const int MaxExitCode = 255;

IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {

}

IEventListenerPtr prepareReporters(Config const* config) {

}

class TestGroup {

};

void applyFilenamesAsTags() {

}

} // anon namespace

Session::Session() {

CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }

}

// There cannot be exceptions at startup in no-exception mode.

#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)

const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();

if ( !exceptions.empty() ) {

config();

getCurrentMutableContext().setConfig(m_config.get());

m_startupExceptions = true;

auto errStream = makeStream( "%stderr" );

auto colourImpl = makeColourImpl(

ColourMode::PlatformDefault, errStream.get() );

auto guard = colourImpl->guardColour( Colour::Red );

errStream->stream() << "Errors occurred during startup!" << '\n';

// iterate over all exceptions and notify user

for ( const auto& ex_ptr : exceptions ) {

try {

std::rethrow_exception(ex_ptr);

} catch ( std::exception const& ex ) {

errStream->stream() << TextFlow::Column( ex.what() ).indent(2) << '\n';

}

}

}

#endif

alreadyInstantiated = true;