Catch::RunContext Class Reference

#include <catch_run_context.h>

Inheritance diagram for Catch::RunContext:

Collaboration diagram for Catch::RunContext:

Public Member Functions
	RunContext (RunContext const &)=delete
RunContext &	operator= (RunContext const &)=delete
	RunContext (IConfigPtr const &_config, IStreamingReporterPtr &&reporter)
	~RunContext () override
void	testGroupStarting (std::string const &testSpec, std::size_t groupIndex, std::size_t groupsCount)
void	testGroupEnded (std::string const &testSpec, Totals const &totals, std::size_t groupIndex, std::size_t groupsCount)
Totals	runTest (TestCase const &testCase)
IConfigPtr	config () const
IStreamingReporter &	reporter () const
void	handleExpr (AssertionInfo const &info, ITransientExpression const &expr, AssertionReaction &reaction) override
void	handleMessage (AssertionInfo const &info, ResultWas::OfType resultType, StringRef const &message, AssertionReaction &reaction) override
void	handleUnexpectedExceptionNotThrown (AssertionInfo const &info, AssertionReaction &reaction) override
void	handleUnexpectedInflightException (AssertionInfo const &info, std::string const &message, AssertionReaction &reaction) override
void	handleIncomplete (AssertionInfo const &info) override
void	handleNonExpr (AssertionInfo const &info, ResultWas::OfType resultType, AssertionReaction &reaction) override
bool	sectionStarted (SectionInfo const &sectionInfo, Counts &assertions) override
void	sectionEnded (SectionEndInfo const &endInfo) override
void	sectionEndedEarly (SectionEndInfo const &endInfo) override
auto	acquireGeneratorTracker (SourceLineInfo const &lineInfo) -> IGeneratorTracker &override
void	benchmarkStarting (BenchmarkInfo const &info) override
void	benchmarkEnded (BenchmarkStats const &stats) override
void	pushScopedMessage (MessageInfo const &message) override
void	popScopedMessage (MessageInfo const &message) override
void	emplaceUnscopedMessage (MessageBuilder const &builder) override
std::string	getCurrentTestName () const override
const AssertionResult *	getLastResult () const override
void	exceptionEarlyReported () override
void	handleFatalErrorCondition (StringRef message) override
bool	lastAssertionPassed () override
void	assertionPassed () override
bool	aborting () const final
Public Member Functions inherited from Catch::IResultCapture
virtual	~IResultCapture ()
virtual	~IResultCapture ()
Public Member Functions inherited from Catch::IRunner
virtual	~IRunner ()
virtual	~IRunner ()

Detailed Description

Definition at line 34 of file catch_run_context.h.

Constructor & Destructor Documentation

RunContext() [1/2]

Catch::RunContext::RunContext ( RunContext const & )

delete

RunContext() [2/2]

Catch::RunContext::RunContext ( IConfigPtr const & _config, IStreamingReporterPtr && reporter )

explicit

Definition at line 70 of file catch_run_context.cpp.

    :   m_runInfo(_config->name()),
        m_context(getCurrentMutableContext()),
        m_config(_config),
        m_reporter(std::move(reporter)),
        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
    {
        m_context.setRunner(this);
        m_context.setConfig(m_config);
        m_context.setResultCapture(this);
        m_reporter->testRunStarting(m_runInfo);
    }

Here is the call graph for this function:

~RunContext()

Catch::RunContext::~RunContext ( )

override

Definition at line 84 of file catch_run_context.cpp.

                            {
        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
    }

Here is the call graph for this function:

Member Function Documentation

aborting()

bool Catch::RunContext::aborting ( ) const

finalvirtual

Implements Catch::IRunner.

Definition at line 315 of file catch_run_context.cpp.

                                    {
        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
    }

Here is the caller graph for this function:

acquireGeneratorTracker()

auto Catch::RunContext::acquireGeneratorTracker ( SourceLineInfo const & lineInfo ) -> IGeneratorTracker&

overridevirtual

Implements Catch::IResultCapture.

Definition at line 190 of file catch_run_context.cpp.

                                                                                                   {
        using namespace Generators;
        GeneratorTracker& tracker = GeneratorTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( "generator", lineInfo ) );
        assert( tracker.isOpen() );
        m_lastAssertionInfo.lineInfo = lineInfo;
        return tracker;
    }

assertionPassed()

void Catch::RunContext::assertionPassed ( )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 308 of file catch_run_context.cpp.

                                     {
        m_lastAssertionPassed = true;
        ++m_totals.assertions.passed;
        resetAssertionInfo();
        m_messageScopes.clear();
    }

Here is the caller graph for this function:

benchmarkEnded()

void Catch::RunContext::benchmarkEnded ( BenchmarkStats const & stats )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 236 of file catch_run_context.cpp.

                                                                 {
        m_reporter->benchmarkEnded( stats );
    }

benchmarkStarting()

void Catch::RunContext::benchmarkStarting ( BenchmarkInfo const & info )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 233 of file catch_run_context.cpp.

                                                                  {
        m_reporter->benchmarkStarting( info );
    }

config()

IConfigPtr Catch::RunContext::config

(

)

const

Definition at line 137 of file catch_run_context.cpp.

                                        {
        return m_config;
    }

emplaceUnscopedMessage()

void Catch::RunContext::emplaceUnscopedMessage ( MessageBuilder const & builder )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 248 of file catch_run_context.cpp.

                                                                           {
        m_messageScopes.emplace_back( builder );
    }

exceptionEarlyReported()

void Catch::RunContext::exceptionEarlyReported ( )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 262 of file catch_run_context.cpp.

                                            {
        m_shouldReportUnexpected = false;
    }

getCurrentTestName()

std::string Catch::RunContext::getCurrentTestName ( ) const

overridevirtual

Implements Catch::IResultCapture.

Definition at line 252 of file catch_run_context.cpp.

                                                   {
        return m_activeTestCase
            ? m_activeTestCase->getTestCaseInfo().name
            : std::string();
    }

Here is the call graph for this function:

getLastResult()

const AssertionResult * Catch::RunContext::getLastResult ( ) const

overridevirtual

Implements Catch::IResultCapture.

Definition at line 258 of file catch_run_context.cpp.

                                                            {
        return &(*m_lastResult);
    }

handleExpr()

void Catch::RunContext::handleExpr ( AssertionInfo const & info, ITransientExpression const & expr, AssertionReaction & reaction )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 387 of file catch_run_context.cpp.

      {
        m_reporter->assertionStarting( info );
 
        bool negated = isFalseTest( info.resultDisposition );
        bool result = expr.getResult() != negated;
 
        if( result ) {
            if (!m_includeSuccessfulResults) {
                assertionPassed();
            }
            else {
                reportExpr(info, ResultWas::Ok, &expr, negated);
            }
        }
        else {
            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
            populateReaction( reaction );
        }
    }

Here is the call graph for this function:

handleFatalErrorCondition()

void Catch::RunContext::handleFatalErrorCondition ( StringRef message )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 266 of file catch_run_context.cpp.

                                                                  {
        // First notify reporter that bad things happened
        m_reporter->fatalErrorEncountered(message);
 
        // Don't rebuild the result -- the stringification itself can cause more fatal errors
        // Instead, fake a result data.
        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
        tempResult.message = message;
        AssertionResult result(m_lastAssertionInfo, tempResult);
 
        assertionEnded(result);
 
        handleUnfinishedSections();
 
        // Recreate section for test case (as we will lose the one that was in scope)
        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
 
        Counts assertions;
        assertions.failed = 1;
        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
        m_reporter->sectionEnded(testCaseSectionStats);
 
        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
 
        Totals deltaTotals;
        deltaTotals.testCases.failed = 1;
        deltaTotals.assertions.failed = 1;
        m_reporter->testCaseEnded(TestCaseStats(testInfo,
                                  deltaTotals,
                                  std::string(),
                                  std::string(),
                                  false));
        m_totals.testCases.failed++;
        testGroupEnded(std::string(), m_totals, 1, 1);
        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
    }

Here is the call graph for this function:

handleIncomplete()

void Catch::RunContext::handleIncomplete ( AssertionInfo const & info )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 468 of file catch_run_context.cpp.

      {
        m_lastAssertionInfo = info;
 
        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
        AssertionResult assertionResult{ info, data };
        assertionEnded( assertionResult );
    }

handleMessage()

void Catch::RunContext::handleMessage ( AssertionInfo const & info, ResultWas::OfType resultType, StringRef const & message, AssertionReaction & reaction )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 425 of file catch_run_context.cpp.

      {
        m_reporter->assertionStarting( info );
 
        m_lastAssertionInfo = info;
 
        AssertionResultData data( resultType, LazyExpression( false ) );
        data.message = message;
        AssertionResult assertionResult{ m_lastAssertionInfo, data };
        assertionEnded( assertionResult );
        if( !assertionResult.isOk() )
            populateReaction( reaction );
    }

handleNonExpr()

void Catch::RunContext::handleNonExpr ( AssertionInfo const & info, ResultWas::OfType resultType, AssertionReaction & reaction )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 478 of file catch_run_context.cpp.

      {
        m_lastAssertionInfo = info;
 
        AssertionResultData data( resultType, LazyExpression( false ) );
        AssertionResult assertionResult{ info, data };
        assertionEnded( assertionResult );
 
        if( !assertionResult.isOk() )
            populateReaction( reaction );
    }

Here is the caller graph for this function:

handleUnexpectedExceptionNotThrown()

void Catch::RunContext::handleUnexpectedExceptionNotThrown ( AssertionInfo const & info, AssertionReaction & reaction )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 442 of file catch_run_context.cpp.

      {
        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
    }

Here is the call graph for this function:

handleUnexpectedInflightException()

void Catch::RunContext::handleUnexpectedInflightException ( AssertionInfo const & info, std::string const & message, AssertionReaction & reaction )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 449 of file catch_run_context.cpp.

      {
        m_lastAssertionInfo = info;
 
        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
        data.message = message;
        AssertionResult assertionResult{ info, data };
        assertionEnded( assertionResult );
        populateReaction( reaction );
    }

lastAssertionPassed()

bool Catch::RunContext::lastAssertionPassed ( )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 304 of file catch_run_context.cpp.

                                         {
         return m_lastAssertionPassed;
    }

operator=()

RunContext & Catch::RunContext::operator= ( RunContext const & )

delete

popScopedMessage()

void Catch::RunContext::popScopedMessage ( MessageInfo const & message )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 244 of file catch_run_context.cpp.

                                                                 {
        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
    }

pushScopedMessage()

void Catch::RunContext::pushScopedMessage ( MessageInfo const & message )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 240 of file catch_run_context.cpp.

                                                                  {
        m_messages.push_back(message);
    }

reporter()

IStreamingReporter & Catch::RunContext::reporter

(

)

const

Definition at line 141 of file catch_run_context.cpp.

                                                   {
        return *m_reporter;
    }

runTest()

Totals Catch::RunContext::runTest

(

TestCase const &

testCase

)

Definition at line 96 of file catch_run_context.cpp.

                                                       {
        Totals prevTotals = m_totals;
 
        std::string redirectedCout;
        std::string redirectedCerr;
 
        auto const& testInfo = testCase.getTestCaseInfo();
 
        m_reporter->testCaseStarting(testInfo);
 
        m_activeTestCase = &testCase;
 
 
        ITracker& rootTracker = m_trackerContext.startRun();
        assert(rootTracker.isSectionTracker());
        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
        do {
            m_trackerContext.startCycle();
            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
            runCurrentTest(redirectedCout, redirectedCerr);
        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
 
        Totals deltaTotals = m_totals.delta(prevTotals);
        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
            deltaTotals.assertions.failed++;
            deltaTotals.testCases.passed--;
            deltaTotals.testCases.failed++;
        }
        m_totals.testCases += deltaTotals.testCases;
        m_reporter->testCaseEnded(TestCaseStats(testInfo,
                                  deltaTotals,
                                  redirectedCout,
                                  redirectedCerr,
                                  aborting()));
 
        m_activeTestCase = nullptr;
        m_testCaseTracker = nullptr;
 
        return deltaTotals;
    }

Here is the call graph for this function:

sectionEnded()

void Catch::RunContext::sectionEnded ( SectionEndInfo const & endInfo )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 210 of file catch_run_context.cpp.

                                                                {
        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
        bool missingAssertions = testForMissingAssertions(assertions);
 
        if (!m_activeSections.empty()) {
            m_activeSections.back()->close();
            m_activeSections.pop_back();
        }
 
        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
        m_messages.clear();
        m_messageScopes.clear();
    }

sectionEndedEarly()

void Catch::RunContext::sectionEndedEarly ( SectionEndInfo const & endInfo )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 224 of file catch_run_context.cpp.

                                                                     {
        if (m_unfinishedSections.empty())
            m_activeSections.back()->fail();
        else
            m_activeSections.back()->close();
        m_activeSections.pop_back();
 
        m_unfinishedSections.push_back(endInfo);
    }

sectionStarted()

bool Catch::RunContext::sectionStarted ( SectionInfo const & sectionInfo, Counts & assertions )

overridevirtual

Implements Catch::IResultCapture.

Definition at line 176 of file catch_run_context.cpp.

                                                                                        {
        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
        if (!sectionTracker.isOpen())
            return false;
        m_activeSections.push_back(&sectionTracker);
 
        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
 
        m_reporter->sectionStarting(sectionInfo);
 
        assertions = m_totals.assertions;
 
        return true;
    }

Here is the call graph for this function:

testGroupEnded()

void Catch::RunContext::testGroupEnded	(	std::string const &	testSpec,
		Totals const &	totals,
		std::size_t	groupIndex,
		std::size_t	groupsCount )

Definition at line 92 of file catch_run_context.cpp.

                                                                                                                                {
        m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

testGroupStarting()

void Catch::RunContext::testGroupStarting	(	std::string const &	testSpec,
		std::size_t	groupIndex,
		std::size_t	groupsCount )

Definition at line 88 of file catch_run_context.cpp.

                                                                                                             {
        m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
    }

---

The documentation for this class was generated from the following files:

• libraries/sys-vm/external/Catch2/include/internal/catch_run_context.h
• libraries/sys-vm/external/Catch2/include/internal/catch_run_context.cpp