catch_reporter_listening.cpp

//              Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
//   (See accompanying file LICENSE_1_0.txt or copy at
//        https://www.boost.org/LICENSE_1_0.txt)

// SPDX-License-Identifier: BSL-1.0
#include <catch2/reporters/catch_reporter_listening.hpp>

#include <catch2/catch_config.hpp>
#include <catch2/internal/catch_move_and_forward.hpp>
#include <catch2/internal/catch_stream.hpp>

#include <cassert>

namespace Catch {

    void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
        m_listeners.insert(m_listeners.begin() + m_insertedListeners, CATCH_MOVE(listener) );
        ++m_insertedListeners;
    }

    void ListeningReporter::addReporter( IStreamingReporterPtr&& reporter ) {
        m_preferences.shouldRedirectStdOut |= reporter->getPreferences().shouldRedirectStdOut;
        // We will need to output the captured stdout if there are reporters
        // that do not want it captured.
        m_haveNoncapturingListeners |= !reporter->getPreferences().shouldRedirectStdOut;

        m_preferences.shouldReportAllAssertions |=
            reporter->getPreferences().shouldReportAllAssertions;

        // Reporters can always be placed to the back without breaking the
        // reporting order
        m_listeners.push_back( CATCH_MOVE( reporter ) );
    }

    void ListeningReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
        for ( auto& listener : m_listeners ) {
            listener->noMatchingTestCases( unmatchedSpec );
        }
    }

    void ListeningReporter::fatalErrorEncountered( StringRef error ) {
        for ( auto& listener : m_listeners ) {
            listener->fatalErrorEncountered( error );
        }
    }

    void ListeningReporter::reportInvalidTestSpec( StringRef arg ) {
        for ( auto& listener : m_listeners ) {
            listener->reportInvalidTestSpec( arg );
        }
    }

    void ListeningReporter::benchmarkPreparing( StringRef name ) {
        for (auto& listener : m_listeners) {
            listener->benchmarkPreparing(name);
        }
    }
    void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
        for ( auto& listener : m_listeners ) {
            listener->benchmarkStarting( benchmarkInfo );
        }
    }
    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
        for ( auto& listener : m_listeners ) {
            listener->benchmarkEnded( benchmarkStats );
        }
    }

    void ListeningReporter::benchmarkFailed( StringRef error ) {
        for (auto& listener : m_listeners) {
            listener->benchmarkFailed(error);
        }
    }

    void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
        for ( auto& listener : m_listeners ) {
            listener->testRunStarting( testRunInfo );
        }
    }

    void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
        for ( auto& listener : m_listeners ) {
            listener->testCaseStarting( testInfo );
        }
    }

    void
    ListeningReporter::testCasePartialStarting( TestCaseInfo const& testInfo,
                                                uint64_t partNumber ) {
        for ( auto& listener : m_listeners ) {
            listener->testCasePartialStarting( testInfo, partNumber );
        }
    }

    void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
        for ( auto& listener : m_listeners ) {
            listener->sectionStarting( sectionInfo );
        }
    }

    void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
        for ( auto& listener : m_listeners ) {
            listener->assertionStarting( assertionInfo );
        }
    }

    // The return value indicates if the messages buffer should be cleared:
    void ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
        const bool alwaysReport =
            assertionStats.assertionResult.getResultType() != ResultWas::Ok ||
            m_config->includeSuccessfulResults();

        for ( auto & listener : m_listeners ) {
            if ( alwaysReport ||
                 listener->getPreferences().shouldReportAllAssertions ) {
                    listener->assertionEnded( assertionStats );
            }
        }
    }

    void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
        for ( auto& listener : m_listeners ) {
            listener->sectionEnded( sectionStats );
        }
    }

    void ListeningReporter::testCasePartialEnded( TestCaseStats const& testStats,
                                                  uint64_t partNumber ) {
        // TODO: Fix handling of stderr/stdout?
        for ( auto& listener : m_listeners ) {
            listener->testCasePartialEnded( testStats, partNumber );
        }
    }

    void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
        if ( m_preferences.shouldRedirectStdOut && m_haveNoncapturingListeners ) {
            if ( !testCaseStats.stdOut.empty() ) {
                Catch::cout() << testCaseStats.stdOut << std::flush;
            }
            if ( !testCaseStats.stdErr.empty() ) {
                Catch::cerr() << testCaseStats.stdErr << std::flush;
            }
        }
        for ( auto& listener : m_listeners ) {
            listener->testCaseEnded( testCaseStats );
        }
    }

    void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
        for ( auto& listener : m_listeners ) {
            listener->testRunEnded( testRunStats );
        }
    }


    void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
        for ( auto& listener : m_listeners ) {
            listener->skipTest( testInfo );
        }
    }

    void ListeningReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
        for (auto& listener : m_listeners) {
            listener->listReporters(descriptions);
        }
    }

    void ListeningReporter::listTests(std::vector<TestCaseHandle> const& tests) {
        for (auto& listener : m_listeners) {
            listener->listTests(tests);
        }
    }

    void ListeningReporter::listTags(std::vector<TagInfo> const& tags) {
        for (auto& listener : m_listeners) {
            listener->listTags(tags);
        }
    }

} // end namespace Catch