catch2/projects/SelfTest/TestMain.cpp

214 lines
7.7 KiB
C++
Raw Normal View History

2010-11-10 00:24:00 +01:00
/*
* Created by Phil on 22/10/2010.
* Copyright 2010 Two Blue Cubes Ltd
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#include "catch_self_test.hpp"
2011-04-01 09:15:58 +02:00
2012-05-16 16:02:51 +02:00
TEST_CASE( "selftest/main", "Runs all Catch self tests and checks their results" ) {
using namespace Catch;
///////////////////////////////////////////////////////////////////////////
SECTION( "selftest/expected result",
2012-05-16 16:02:51 +02:00
"Tests do what they claim" ) {
SECTION( "selftest/expected result/failing tests",
2012-05-16 16:02:51 +02:00
"Tests in the 'failing' branch fail" ) {
MetaTestRunner::runMatching( "./failing/*", MetaTestRunner::Expected::ToFail );
}
SECTION( "selftest/expected result/succeeding tests",
2012-05-16 16:02:51 +02:00
"Tests in the 'succeeding' branch succeed" ) {
MetaTestRunner::runMatching( "./succeeding/*", MetaTestRunner::Expected::ToSucceed );
}
}
///////////////////////////////////////////////////////////////////////////
SECTION( "selftest/test counts",
2012-05-16 16:02:51 +02:00
"Number of test cases that run is fixed" ) {
EmbeddedRunner runner;
SECTION( "selftest/test counts/succeeding tests",
2012-05-16 16:02:51 +02:00
"Number of 'succeeding' tests is fixed" ) {
runner.runMatching( "./succeeding/*" );
2012-07-05 19:37:58 +02:00
CHECK( runner.getTotals().assertions.passed == 284 );
CHECK( runner.getTotals().assertions.failed == 0 );
}
SECTION( "selftest/test counts/failing tests",
2012-05-16 16:02:51 +02:00
"Number of 'failing' tests is fixed" ) {
runner.runMatching( "./failing/*" );
CHECK( runner.getTotals().assertions.passed == 0 );
CHECK( runner.getTotals().assertions.failed == 72 );
}
}
2010-11-10 00:24:00 +01:00
}
2012-05-16 16:02:51 +02:00
TEST_CASE( "meta/Misc/Sections", "looped tests" ) {
Catch::EmbeddedRunner runner;
2011-02-21 19:50:35 +01:00
runner.runMatching( "./mixed/Misc/Sections/nested2" );
CHECK( runner.getTotals().assertions.passed == 2 );
CHECK( runner.getTotals().assertions.failed == 1 );
}
2012-06-02 13:31:55 +02:00
#include "../../include/internal/catch_commandline.hpp"
#include "../../include/reporters/catch_reporter_basic.hpp"
#include "../../include/reporters/catch_reporter_xml.hpp"
#include "../../include/reporters/catch_reporter_junit.hpp"
template<size_t size>
2012-06-08 09:22:56 +02:00
void parseIntoConfig( const char * (&argv)[size], Catch::ConfigData& config ) {
Catch::parseIntoConfig( Catch::CommandParser( size, argv ), config );
}
2012-06-08 09:22:56 +02:00
template<size_t size>
std::string parseIntoConfigAndReturnError( const char * (&argv)[size], Catch::ConfigData& config ) {
try {
Catch::parseIntoConfig( Catch::CommandParser( size, argv ), config );
}
catch( std::exception& ex ) {
return ex.what();
}
return "";
}
TEST_CASE( "selftest/parser/2", "ConfigData" ) {
Catch::ConfigData config;
SECTION( "default", "" ) {
const char* argv[] = { "test" };
2012-06-08 09:22:56 +02:00
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
CHECK( config.testSpecs.empty() );
CHECK( config.shouldDebugBreak == false );
CHECK( config.cutoff == -1 );
CHECK( config.allowThrows == true );
CHECK( config.reporter.empty() );
}
SECTION( "test lists", "" ) {
SECTION( "-t/1", "Specify one test case using -t" ) {
const char* argv[] = { "test", "-t", "test1" };
2012-06-08 09:22:56 +02:00
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
REQUIRE( config.testSpecs.size() == 1 );
REQUIRE( config.testSpecs[0] == "test1" );
}
SECTION( "--test/1", "Specify one test case using --test" ) {
const char* argv[] = { "test", "--test", "test1" };
2012-06-08 09:22:56 +02:00
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
REQUIRE( config.testSpecs.size() == 1 );
REQUIRE( config.testSpecs[0] == "test1" );
}
SECTION( "-t/2", "Specify two test cases using -t" ) {
const char* argv[] = { "test", "-t", "test1", "test2" };
2012-06-08 09:22:56 +02:00
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
REQUIRE( config.testSpecs.size() == 2 );
REQUIRE( config.testSpecs[0] == "test1" );
REQUIRE( config.testSpecs[1] == "test2" );
}
SECTION( "-t/0", "When no test names are supplied it is an error" ) {
const char* argv[] = { "test", "-t" };
2012-06-08 09:22:56 +02:00
REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "at least one" ) );
}
}
SECTION( "reporter", "" ) {
SECTION( "-r/basic", "" ) {
2012-06-08 09:22:56 +02:00
const char* argv[] = { "test", "-r", "basic" };
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
REQUIRE( config.reporter == "basic" );
}
SECTION( "-r/xml", "" ) {
const char* argv[] = { "test", "-r", "xml" };
2012-06-08 09:22:56 +02:00
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
REQUIRE( config.reporter == "xml" );
}
2012-06-08 09:22:56 +02:00
SECTION( "--reporter/junit", "" ) {
const char* argv[] = { "test", "--reporter", "junit" };
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
REQUIRE( config.reporter == "junit" );
}
SECTION( "-r/error", "reporter config only accepts one argument" ) {
const char* argv[] = { "test", "-r", "one", "two" };
2012-06-08 09:22:56 +02:00
REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "one argument" ) );
}
}
SECTION( "debugger", "" ) {
SECTION( "-b", "" ) {
const char* argv[] = { "test", "-b" };
2012-06-08 09:22:56 +02:00
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
REQUIRE( config.shouldDebugBreak == true );
}
SECTION( "--break", "" ) {
const char* argv[] = { "test", "--break" };
2012-06-08 09:22:56 +02:00
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
REQUIRE( config.shouldDebugBreak );
}
SECTION( "-b", "break option has no arguments" ) {
const char* argv[] = { "test", "-b", "unexpected" };
2012-06-08 09:22:56 +02:00
REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "not accept" ) );
}
}
2012-06-08 09:22:56 +02:00
2012-06-03 00:26:32 +02:00
SECTION( "abort", "" ) {
SECTION( "-a", "" ) {
const char* argv[] = { "test", "-a" };
2012-06-08 09:22:56 +02:00
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
REQUIRE( config.cutoff == 1 );
}
2012-06-03 00:26:32 +02:00
SECTION( "-a/2", "" ) {
const char* argv[] = { "test", "-a", "2" };
2012-06-08 09:22:56 +02:00
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
REQUIRE( config.cutoff == 2 );
}
2012-06-03 00:26:32 +02:00
SECTION( "-a/error", "cutoff only takes one argument" ) {
const char* argv[] = { "test", "-a", "1", "2" };
2012-06-08 09:22:56 +02:00
REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "accepts" ) );
}
}
SECTION( "nothrow", "" ) {
SECTION( "-nt", "" ) {
const char* argv[] = { "test", "-nt" };
2012-06-08 09:22:56 +02:00
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
REQUIRE( config.allowThrows == false );
}
SECTION( "--nothrow", "" ) {
const char* argv[] = { "test", "--nothrow" };
2012-06-08 09:22:56 +02:00
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
REQUIRE( config.allowThrows == false );
}
}
SECTION( "combinations", "" ) {
2012-06-03 00:26:32 +02:00
SECTION( "-a -b", "" ) {
const char* argv[] = { "test", "-a", "-b", "-nt" };
2012-06-08 09:22:56 +02:00
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-06-08 09:22:56 +02:00
CHECK( config.cutoff == 1 );
CHECK( config.shouldDebugBreak );
CHECK( config.allowThrows == false );
}
2012-06-08 09:22:56 +02:00
}
}