mirror of
				https://github.com/catchorg/Catch2.git
				synced 2025-11-04 05:59:32 +01:00 
			
		
		
		
	Merge from origin
This commit is contained in:
		@@ -30,76 +30,29 @@ namespace Catch {
 | 
			
		||||
            std::cout << "All available test cases:\n";
 | 
			
		||||
        else
 | 
			
		||||
            std::cout << "Matching test cases:\n";
 | 
			
		||||
        std::vector<TestCase> const& allTests = getRegistryHub().getTestCaseRegistry().getAllTests();
 | 
			
		||||
        std::vector<TestCase>::const_iterator it = allTests.begin(), itEnd = allTests.end();
 | 
			
		||||
 | 
			
		||||
        // First pass - get max tags
 | 
			
		||||
        std::size_t maxTagLen = 0;
 | 
			
		||||
        std::size_t maxNameLen = 0;
 | 
			
		||||
        for(; it != itEnd; ++it ) {
 | 
			
		||||
            if( matchesFilters( config.filters(), *it ) ) {
 | 
			
		||||
                maxTagLen = (std::max)( it->getTestCaseInfo().tagsAsString.size(), maxTagLen );
 | 
			
		||||
                maxNameLen = (std::max)( it->getTestCaseInfo().name.size(), maxNameLen );
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        // Try to fit everything in. If not shrink tag column first, down to 30
 | 
			
		||||
        // then shrink name column until it all fits (strings will be wrapped within column)
 | 
			
		||||
        while( maxTagLen + maxNameLen > CATCH_CONFIG_CONSOLE_WIDTH-5 ) {
 | 
			
		||||
            if( maxTagLen > 30 )
 | 
			
		||||
                --maxTagLen;
 | 
			
		||||
            else
 | 
			
		||||
                --maxNameLen;
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        std::size_t matchedTests = 0;
 | 
			
		||||
        for( it = allTests.begin(); it != itEnd; ++it ) {
 | 
			
		||||
        TextAttributes nameAttr, tagsAttr;
 | 
			
		||||
        nameAttr.setInitialIndent( 2 ).setIndent( 4 );
 | 
			
		||||
        tagsAttr.setIndent( 6 );
 | 
			
		||||
 | 
			
		||||
        std::vector<TestCase> const& allTests = getRegistryHub().getTestCaseRegistry().getAllTests();
 | 
			
		||||
        for( std::vector<TestCase>::const_iterator it = allTests.begin(), itEnd = allTests.end();
 | 
			
		||||
                it != itEnd;
 | 
			
		||||
                ++it )
 | 
			
		||||
            if( matchesFilters( config.filters(), *it ) ) {
 | 
			
		||||
                matchedTests++;
 | 
			
		||||
                Text nameWrapper(   it->getTestCaseInfo().name,
 | 
			
		||||
                                    TextAttributes()
 | 
			
		||||
                                        .setWidth( maxNameLen+2 )
 | 
			
		||||
                                        .setInitialIndent(2)
 | 
			
		||||
                                        .setIndent(4) );
 | 
			
		||||
                TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
 | 
			
		||||
                Colour::Code colour = testCaseInfo.isHidden
 | 
			
		||||
                    ? Colour::SecondaryText
 | 
			
		||||
                    : Colour::None;
 | 
			
		||||
                Colour colourGuard( colour );
 | 
			
		||||
 | 
			
		||||
                Text tagsWrapper(   it->getTestCaseInfo().tagsAsString,
 | 
			
		||||
                                    TextAttributes()
 | 
			
		||||
                                        .setWidth( maxTagLen )
 | 
			
		||||
                                        .setInitialIndent(0)
 | 
			
		||||
                                        .setIndent( 2 ) );
 | 
			
		||||
 | 
			
		||||
                for( std::size_t i = 0; i < (std::max)( nameWrapper.size(), tagsWrapper.size() ); ++i ) {
 | 
			
		||||
                    Colour::Code colour = Colour::None;
 | 
			
		||||
                    if( it->getTestCaseInfo().isHidden )
 | 
			
		||||
                        colour = Colour::SecondaryText;
 | 
			
		||||
                    std::string nameCol;
 | 
			
		||||
                    if( i < nameWrapper.size() ) {
 | 
			
		||||
                        nameCol = nameWrapper[i];
 | 
			
		||||
                    }
 | 
			
		||||
                    else {
 | 
			
		||||
                        nameCol = "    ...";
 | 
			
		||||
                        colour = Colour::SecondaryText;
 | 
			
		||||
                    }
 | 
			
		||||
 | 
			
		||||
                    {
 | 
			
		||||
                        Colour colourGuard( colour );
 | 
			
		||||
                        std::cout << nameCol;
 | 
			
		||||
                    }
 | 
			
		||||
                    if( i < tagsWrapper.size() && !tagsWrapper[i].empty() ) {
 | 
			
		||||
                        size_t padLen( maxNameLen > nameCol.size() ? maxNameLen - nameCol.size() : 0 );
 | 
			
		||||
                        if( i == 0 ) {
 | 
			
		||||
                            Colour colourGuard( Colour::SecondaryText );
 | 
			
		||||
                            std::cout << "  " << std::string( padLen, '.' ) << "  ";
 | 
			
		||||
                        }
 | 
			
		||||
                        else {
 | 
			
		||||
                            std::cout << std::string( padLen, ' ' ) << "    ";
 | 
			
		||||
                        }
 | 
			
		||||
                        std::cout << tagsWrapper[i];
 | 
			
		||||
                    }
 | 
			
		||||
                    std::cout << "\n";
 | 
			
		||||
                }
 | 
			
		||||
                std::cout << Text( testCaseInfo.name, nameAttr ) << std::endl;
 | 
			
		||||
                if( !testCaseInfo.tags.empty() )
 | 
			
		||||
                    std::cout << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        if( config.filters().empty() )
 | 
			
		||||
            std::cout << pluralise( matchedTests, "test case" ) << "\n" << std::endl;
 | 
			
		||||
        else
 | 
			
		||||
@@ -112,21 +65,20 @@ namespace Catch {
 | 
			
		||||
            std::cout << "All available tags:\n";
 | 
			
		||||
        else
 | 
			
		||||
            std::cout << "Matching tags:\n";
 | 
			
		||||
        std::vector<TestCase> const& allTests = getRegistryHub().getTestCaseRegistry().getAllTests();
 | 
			
		||||
        std::vector<TestCase>::const_iterator it = allTests.begin(), itEnd = allTests.end();
 | 
			
		||||
 | 
			
		||||
        std::map<std::string, int> tagCounts;
 | 
			
		||||
 | 
			
		||||
        std::size_t maxTagLen = 0;
 | 
			
		||||
 | 
			
		||||
        for(; it != itEnd; ++it ) {
 | 
			
		||||
        std::vector<TestCase> const& allTests = getRegistryHub().getTestCaseRegistry().getAllTests();
 | 
			
		||||
        for( std::vector<TestCase>::const_iterator  it = allTests.begin(),
 | 
			
		||||
                                                    itEnd = allTests.end();
 | 
			
		||||
                it != itEnd;
 | 
			
		||||
                ++it ) {
 | 
			
		||||
            if( matchesFilters( config.filters(), *it ) ) {
 | 
			
		||||
                for( std::set<std::string>::const_iterator  tagIt = it->getTestCaseInfo().tags.begin(),
 | 
			
		||||
                                                            tagItEnd = it->getTestCaseInfo().tags.end();
 | 
			
		||||
                        tagIt != tagItEnd;
 | 
			
		||||
                        ++tagIt ) {
 | 
			
		||||
                    std::string tagName = *tagIt;
 | 
			
		||||
                    maxTagLen = (std::max)( maxTagLen, tagName.size() );
 | 
			
		||||
                    std::map<std::string, int>::iterator countIt = tagCounts.find( tagName );
 | 
			
		||||
                    if( countIt == tagCounts.end() )
 | 
			
		||||
                        tagCounts.insert( std::make_pair( tagName, 1 ) );
 | 
			
		||||
@@ -135,26 +87,18 @@ namespace Catch {
 | 
			
		||||
                }
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
        maxTagLen +=4;
 | 
			
		||||
        if( maxTagLen > CATCH_CONFIG_CONSOLE_WIDTH-10 )
 | 
			
		||||
            maxTagLen = CATCH_CONFIG_CONSOLE_WIDTH-10;
 | 
			
		||||
 | 
			
		||||
        for( std::map<std::string, int>::const_iterator countIt = tagCounts.begin(), countItEnd = tagCounts.end();
 | 
			
		||||
        for( std::map<std::string, int>::const_iterator countIt = tagCounts.begin(),
 | 
			
		||||
                                                        countItEnd = tagCounts.end();
 | 
			
		||||
                countIt != countItEnd;
 | 
			
		||||
                ++countIt ) {
 | 
			
		||||
            std::ostringstream oss;
 | 
			
		||||
            oss << "  " << countIt->second << "  ";
 | 
			
		||||
            Text wrapper( "[" + countIt->first + "]", TextAttributes()
 | 
			
		||||
                                                        .setIndent(2)
 | 
			
		||||
                                                        .setWidth( maxTagLen ) );
 | 
			
		||||
            std::cout << wrapper;
 | 
			
		||||
            std::size_t dots = 2;
 | 
			
		||||
            if( maxTagLen > wrapper.last().size() )
 | 
			
		||||
                dots += maxTagLen - wrapper.last().size();
 | 
			
		||||
            {
 | 
			
		||||
                Colour colourGuard( Colour::SecondaryText );
 | 
			
		||||
                std::cout << std::string( dots, '.' );
 | 
			
		||||
            }
 | 
			
		||||
            std::cout   << countIt->second
 | 
			
		||||
                        << "\n";
 | 
			
		||||
                                                        .setInitialIndent( 0 )
 | 
			
		||||
                                                        .setIndent( oss.str().size() )
 | 
			
		||||
                                                        .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) );
 | 
			
		||||
            std::cout << oss.str() << wrapper << "\n";
 | 
			
		||||
        }
 | 
			
		||||
        std::cout << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl;
 | 
			
		||||
        return tagCounts.size();
 | 
			
		||||
 
 | 
			
		||||
@@ -14,8 +14,7 @@ namespace Catch {
 | 
			
		||||
 | 
			
		||||
    // These numbers are maintained by a script
 | 
			
		||||
    template <typename T>
 | 
			
		||||
    const T LibraryVersionInfo<T>::value( 1, 0, 11, "master" );
 | 
			
		||||
 | 
			
		||||
    const T LibraryVersionInfo<T>::value( 1, 0, 13, "master" );
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
#endif // TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED
 | 
			
		||||
 
 | 
			
		||||
@@ -41,13 +41,18 @@ namespace Catch {
 | 
			
		||||
        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
 | 
			
		||||
            AssertionResult const& result = _assertionStats.assertionResult;
 | 
			
		||||
 | 
			
		||||
            bool printInfoMessages = true;
 | 
			
		||||
 | 
			
		||||
            // Drop out if result was successful and we're not printing those
 | 
			
		||||
            if( !m_config->includeSuccessfulResults() && result.isOk() )
 | 
			
		||||
                return false;
 | 
			
		||||
            if( !m_config->includeSuccessfulResults() && result.isOk() ) {
 | 
			
		||||
                if( result.getResultType() != ResultWas::Warning )
 | 
			
		||||
                    return false;
 | 
			
		||||
                printInfoMessages = false;
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
            lazyPrint();
 | 
			
		||||
 | 
			
		||||
            AssertionPrinter printer( stream, _assertionStats );
 | 
			
		||||
            AssertionPrinter printer( stream, _assertionStats, printInfoMessages );
 | 
			
		||||
            printer.print();
 | 
			
		||||
            stream << std::endl;
 | 
			
		||||
            return true;
 | 
			
		||||
@@ -105,13 +110,14 @@ namespace Catch {
 | 
			
		||||
        class AssertionPrinter {
 | 
			
		||||
            void operator= ( AssertionPrinter const& );
 | 
			
		||||
        public:
 | 
			
		||||
            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats )
 | 
			
		||||
            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
 | 
			
		||||
            :   stream( _stream ),
 | 
			
		||||
                stats( _stats ),
 | 
			
		||||
                result( _stats.assertionResult ),
 | 
			
		||||
                colour( Colour::None ),
 | 
			
		||||
                message( result.getMessage() ),
 | 
			
		||||
                messages( _stats.infoMessages )
 | 
			
		||||
                messages( _stats.infoMessages ),
 | 
			
		||||
                printInfoMessages( _printInfoMessages )
 | 
			
		||||
            {
 | 
			
		||||
                switch( result.getResultType() ) {
 | 
			
		||||
                    case ResultWas::Ok:
 | 
			
		||||
@@ -214,7 +220,9 @@ namespace Catch {
 | 
			
		||||
                for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
 | 
			
		||||
                        it != itEnd;
 | 
			
		||||
                        ++it ) {
 | 
			
		||||
                    stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n";
 | 
			
		||||
                    // If this assertion is a warning ignore any INFO messages
 | 
			
		||||
                    if( printInfoMessages || it->type != ResultWas::Info )
 | 
			
		||||
                        stream << Text( it->message, TextAttributes().setIndent(2) ) << "\n";
 | 
			
		||||
                }
 | 
			
		||||
            }
 | 
			
		||||
            void printSourceInfo() const {
 | 
			
		||||
@@ -230,6 +238,7 @@ namespace Catch {
 | 
			
		||||
            std::string messageLabel;
 | 
			
		||||
            std::string message;
 | 
			
		||||
            std::vector<MessageInfo> messages;
 | 
			
		||||
            bool printInfoMessages;
 | 
			
		||||
        };
 | 
			
		||||
 | 
			
		||||
        void lazyPrint() {
 | 
			
		||||
@@ -315,9 +324,14 @@ namespace Catch {
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        void printTotals( const Totals& totals ) {
 | 
			
		||||
            if( totals.assertions.total() == 0 ) {
 | 
			
		||||
            if( totals.testCases.total() == 0 ) {
 | 
			
		||||
                stream << "No tests ran";
 | 
			
		||||
            }
 | 
			
		||||
            else if( totals.assertions.total() == 0 ) {
 | 
			
		||||
                Colour colour( Colour::Yellow );
 | 
			
		||||
                printCounts( "test case", totals.testCases );
 | 
			
		||||
                stream << " (no assertions)";
 | 
			
		||||
            }
 | 
			
		||||
            else if( totals.assertions.failed ) {
 | 
			
		||||
                Colour colour( Colour::ResultError );
 | 
			
		||||
                printCounts( "test case", totals.testCases );
 | 
			
		||||
 
 | 
			
		||||
		Reference in New Issue
	
	Block a user