Beispiel #1
0
    inline std::size_t listTests( Config const& config ) {
        if( config.filters().empty() )
            std::cout << "All available test cases:\n";
        else
            std::cout << "Matching test cases:\n";

        std::size_t matchedTests = 0;
        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++;
                TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
                Colour::Code colour = testCaseInfo.isHidden
                    ? Colour::SecondaryText
                    : Colour::None;
                Colour colourGuard( colour );

                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
            std::cout << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl;
        return matchedTests;
    }
Beispiel #2
0
int run( C const & specification, std::ostream & os = std::cout )
{
    int failures = 0;
    const int  N = end( specification ) - begin( specification );

    for ( typename iter<C>::type testing = begin( specification ); testing != end( specification ); ++testing )
    {
        try
        {
            testing->behaviour();
        }
        catch( message const & e )
        {
            ++failures;
            report( os, e, testing->name );
        }
    }

    if ( failures > 0 )
    {
        os << failures << " out of " << N << " " << pluralise(N, "test") << " failed." << std::endl;
    }

    return failures;
}
Beispiel #3
0
 void ReportCounts( const Totals& totals, const std::string& allPrefix = "All " ) {
     if( totals.assertions.total() == 0 ) {
         m_config.stream() << "No tests ran";
     }
     else if( totals.assertions.failed ) {
         TextColour colour( TextColour::ResultError );
         ReportCounts( "test case", totals.testCases, allPrefix );
         if( totals.testCases.failed > 0 ) {
             m_config.stream() << " (";
             ReportCounts( "assertion", totals.assertions, allPrefix );
             m_config.stream() << ")";
         }
     }
     else {
         TextColour colour( TextColour::ResultSuccess );
         m_config.stream()   << allPrefix << "tests passed ("
                             << pluralise( totals.assertions.passed, "assertion" ) << " in " 
                             << pluralise( totals.testCases.passed, "test case" ) << ")";
     }
 }
Beispiel #4
0
    inline std::size_t listTags( Config const& config ) {
        if( config.filters().empty() )
            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 ) {
            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 ) );
                    else
                        countIt->second++;
                }
            }
        }
        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();
                countIt != countItEnd;
                ++countIt ) {
            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";
        }
        std::cout << pluralise( tagCounts.size(), "tag" ) << "\n" << std::endl;
        return tagCounts.size();
    }
    inline std::size_t listTests(Config const &config) {

        TestSpec testSpec = config.testSpec();
        if (config.testSpec().hasFilters())
            Catch::cout() << "Matching test cases:\n";
        else {
            Catch::cout() << "All available test cases:\n";
            testSpec = TestSpecParser(ITagAliasRegistry::get()).parse("*").testSpec();
        }

        std::size_t matchedTests = 0;
        TextAttributes nameAttr, tagsAttr;
        nameAttr.setInitialIndent(2).setIndent(4);
        tagsAttr.setIndent(6);

        std::vector<TestCase> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
        for (std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
             it != itEnd;
             ++it) {
            matchedTests++;
            TestCaseInfo const &testCaseInfo = it->getTestCaseInfo();
            Colour::Code colour = testCaseInfo.isHidden()
                                  ? Colour::SecondaryText
                                  : Colour::None;
            Colour colourGuard(colour);

            Catch::cout() << Text(testCaseInfo.name, nameAttr) << std::endl;
            if (!testCaseInfo.tags.empty())
                Catch::cout() << Text(testCaseInfo.tagsAsString, tagsAttr) << std::endl;
        }

        if (!config.testSpec().hasFilters())
            Catch::cout() << pluralise(matchedTests, "test case") << "\n" << std::endl;
        else
            Catch::cout() << pluralise(matchedTests, "matching test case") << "\n" << std::endl;
        return matchedTests;
    }
Beispiel #6
0
 virtual void EndSection( const std::string& sectionName, const Counts& assertions ) {
     SpanInfo& sectionSpan = m_sectionSpans.back();
     if( sectionSpan.emitted && !sectionSpan.name.empty() ) {
         m_config.stream() << "[End of section: '" << sectionName << "' ";
         
         if( assertions.failed ) {
             TextColour colour( TextColour::ResultError );
             ReportCounts( "assertion", assertions);
         }
         else {
             TextColour colour( TextColour::ResultSuccess );
             m_config.stream()   << ( assertions.passed > 1 ? "All " : "" ) 
                                 << pluralise( assertions.passed, "assertion" ) << "passed" ;
         }
         m_config.stream() << "]\n" << std::endl;
     }
     m_sectionSpans.pop_back();
 }
Beispiel #7
0
    inline std::size_t listTags( Config const& config ) {
        if( config.filters().empty() )
            std::cout << "All available tags:\n";
        else
            std::cout << "Matching tags:\n";

        std::map<std::string, int> tagCounts;

        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;
                    std::map<std::string, int>::iterator countIt = tagCounts.find( tagName );
                    if( countIt == tagCounts.end() )
                        tagCounts.insert( std::make_pair( tagName, 1 ) );
                    else
                        countIt->second++;
                }
            }
        }

        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()
                                                        .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();
    }
    inline std::size_t listTags(Config const &config) {
        TestSpec testSpec = config.testSpec();
        if (config.testSpec().hasFilters())
            Catch::cout() << "Tags for matching test cases:\n";
        else {
            Catch::cout() << "All available tags:\n";
            testSpec = TestSpecParser(ITagAliasRegistry::get()).parse("*").testSpec();
        }

        std::map<std::string, TagInfo> tagCounts;

        std::vector<TestCase> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
        for (std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
             it != itEnd;
             ++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;
                std::string lcaseTagName = toLower(tagName);
                std::map<std::string, TagInfo>::iterator countIt = tagCounts.find(lcaseTagName);
                if (countIt == tagCounts.end())
                    countIt = tagCounts.insert(std::make_pair(lcaseTagName, TagInfo())).first;
                countIt->second.add(tagName);
            }
        }

        for (std::map<std::string, TagInfo>::const_iterator countIt = tagCounts.begin(),
                     countItEnd = tagCounts.end();
             countIt != countItEnd;
             ++countIt) {
            std::ostringstream oss;
            oss << "  " << std::setw(2) << countIt->second.count << "  ";
            Text wrapper(countIt->second.all(), TextAttributes()
                    .setInitialIndent(0)
                    .setIndent(oss.str().size())
                    .setWidth(CATCH_CONFIG_CONSOLE_WIDTH - 10));
            Catch::cout() << oss.str() << wrapper << "\n";
        }
        Catch::cout() << pluralise(tagCounts.size(), "tag") << "\n" << std::endl;
        return tagCounts.size();
    }
Beispiel #9
0
int run( test const (&specification)[N], std::ostream & os = std::cout )
{
    int failures = 0;

    for ( auto & testing : specification )
    {
        try
        {
            testing.behaviour();
        }
        catch( message const & e )
        {
            ++failures;
            report( os, e, testing.name );
        }
    }

    if ( failures > 0 )
    {
        os << failures << " out of " << N << " " << pluralise(N, "test") << " failed." << std::endl;
    }

    return failures;
}
Beispiel #10
0
 void ReportCounts( const std::string& label, const Counts& counts, const std::string& allPrefix = "All " ) {
     if( counts.passed )
         m_config.stream() << counts.failed << " of " << counts.total() << " " << label << "s failed";
     else
         m_config.stream() << ( counts.failed > 1 ? allPrefix : "" ) << pluralise( counts.failed, label ) << " failed";
 }
Beispiel #11
0
    inline std::size_t listTests( Config const& config ) {
        if( config.filters().empty() )
            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 ) {
            if( matchesFilters( config.filters(), *it ) ) {
                matchedTests++;
                Text nameWrapper(   it->getTestCaseInfo().name,
                                    TextAttributes()
                                        .setWidth( maxNameLen )
                                        .setInitialIndent(2)
                                        .setIndent(4) );

                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() ) {
                        if( i == 0 ) {
                            Colour colourGuard( Colour::SecondaryText );
                            std::cout << "  " << std::string( maxNameLen - nameCol.size(), '.' ) << "  ";
                        }
                        else {
                            std::cout << std::string( maxNameLen - nameCol.size(), ' ' ) << "    ";
                        }
                        std::cout << tagsWrapper[i];
                    }
                    std::cout << "\n";
                }
            }
        }
        if( config.filters().empty() )
            std::cout << pluralise( matchedTests, "test case" ) << "\n" << std::endl;
        else
            std::cout << pluralise( matchedTests, "matching test case" ) << "\n" << std::endl;
        return matchedTests;
    }