catch2/projects/SelfTest/TestMain.cpp

489 lines
20 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)
*/
2012-08-16 19:48:32 +02:00
#ifdef __clang__
#pragma clang diagnostic ignored "-Wpadded"
2012-08-16 19:48:32 +02:00
#endif
#include "catch_self_test.hpp"
#include "catch_line_wrap.h"
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, 0, 2 );
}
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, 1, 2 );
}
}
///////////////////////////////////////////////////////////////////////////
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" ) {
Totals totals = runner.runMatching( "./succeeding/*", 0, 2 );
2013-02-19 19:45:06 +01:00
CHECK( totals.assertions.passed == 296 );
CHECK( totals.assertions.failed == 0 );
}
SECTION( "selftest/test counts/failing tests",
2012-05-16 16:02:51 +02:00
"Number of 'failing' tests is fixed" ) {
Totals totals = runner.runMatching( "./failing/*", 1, 2 );
CHECK( totals.assertions.passed == 1 );
CHECK( totals.assertions.failed == 73 );
}
}
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;
Catch::Totals totals = runner.runMatching( "./mixed/Misc/Sections/nested2", 0, 1 );
CHECK( totals.assertions.passed == 2 );
CHECK( totals.assertions.failed == 1 );
}
2012-08-16 19:47:41 +02:00
#ifdef __clang__
#pragma clang diagnostic ignored "-Wweak-vtables"
2012-08-16 19:47:41 +02:00
#endif
2012-06-02 13:31:55 +02:00
#include "../../include/internal/catch_commandline.hpp"
2012-08-23 21:08:50 +02:00
#include "../../include/internal/catch_test_spec.h"
2012-06-02 13:31:55 +02:00
#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 ) {
static Catch::AllOptions options;
options.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 {
parseIntoConfig( argv, config );
FAIL( "expected exception" );
2012-06-08 09:22:56 +02:00
}
catch( std::exception& ex ) {
return ex.what();
}
return "";
}
inline Catch::TestCase fakeTestCase( const char* name ){ return Catch::makeTestCase( NULL, "", name, "", CATCH_INTERNAL_LINEINFO ); }
2012-08-23 21:08:50 +02:00
2012-06-08 09:22:56 +02:00
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.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-08-23 21:08:50 +02:00
REQUIRE( config.filters.size() == 1 );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) );
2012-08-23 21:08:50 +02:00
}
SECTION( "-t/exclude:1", "Specify one test case exclusion using -t exclude:" ) {
const char* argv[] = { "test", "-t", "exclude:test1" };
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
REQUIRE( config.filters.size() == 1 );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) == false );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "alwaysIncluded" ) ) );
}
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-08-23 21:08:50 +02:00
REQUIRE( config.filters.size() == 1 );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) );
2012-08-23 21:08:50 +02:00
}
SECTION( "--test/exclude:1", "Specify one test case exclusion using --test exclude:" ) {
const char* argv[] = { "test", "--test", "exclude:test1" };
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
REQUIRE( config.filters.size() == 1 );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) == false );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "alwaysIncluded" ) ) );
}
2012-08-24 20:01:35 +02:00
SECTION( "--test/exclude:2", "Specify one test case exclusion using --test ~" ) {
const char* argv[] = { "test", "--test", "~test1" };
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
REQUIRE( config.filters.size() == 1 );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) == false );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "alwaysIncluded" ) ) );
2012-08-24 20:01:35 +02:00
}
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-08-23 21:08:50 +02:00
REQUIRE( config.filters.size() == 1 );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "test2" ) ) );
}
SECTION( "-t/0", "When no test names are supplied it is an error" ) {
const char* argv[] = { "test", "-t" };
REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "at least 1" ) );
}
}
SECTION( "reporter", "" ) {
SECTION( "-r/console", "" ) {
2012-12-10 09:54:57 +01:00
const char* argv[] = { "test", "-r", "console" };
2012-06-08 09:22:56 +02:00
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
2012-12-10 09:54:57 +01:00
REQUIRE( config.reporter == "console" );
}
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" };
REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "1 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" };
REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "0 arguments" ) );
}
}
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 );
}
SECTION( "-a/error/0", "" ) {
const char* argv[] = { "test", "-a", "0" };
REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "greater than zero" ) );
}
SECTION( "-a/error/non numeric", "" ) {
const char* argv[] = { "test", "-a", "oops" };
REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "greater than zero" ) );
}
SECTION( "-a/error/two args", "cutoff only takes one argument" ) {
2012-06-03 00:26:32 +02:00
const char* argv[] = { "test", "-a", "1", "2" };
REQUIRE_THAT( parseIntoConfigAndReturnError( argv, config ), Contains( "0 and 1 argument" ) );
}
}
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( "streams", "" ) {
SECTION( "-o filename", "" ) {
const char* argv[] = { "test", "-o", "filename.ext" };
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
REQUIRE( config.outputFilename == "filename.ext" );
REQUIRE( config.stream.empty() );
}
SECTION( "-o %stdout", "" ) {
const char* argv[] = { "test", "-o", "%stdout" };
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
REQUIRE( config.stream == "stdout" );
REQUIRE( config.outputFilename.empty() );
}
SECTION( "--out", "" ) {
const char* argv[] = { "test", "--out", "filename.ext" };
CHECK_NOTHROW( parseIntoConfig( argv, config ) );
REQUIRE( config.outputFilename == "filename.ext" );
}
}
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
}
}
2012-08-16 19:48:32 +02:00
2012-08-24 09:23:50 +02:00
TEST_CASE( "selftest/test filter", "Individual filters" ) {
2012-08-16 19:48:32 +02:00
Catch::TestCaseFilter matchAny( "*" );
Catch::TestCaseFilter matchNone( "*", Catch::IfFilterMatches::ExcludeTests );
CHECK( matchAny.shouldInclude( fakeTestCase( "any" ) ));
CHECK( matchNone.shouldInclude( fakeTestCase( "any" ) ) == false );
2012-08-16 19:48:32 +02:00
Catch::TestCaseFilter matchHidden( "./*" );
Catch::TestCaseFilter matchNonHidden( "./*", Catch::IfFilterMatches::ExcludeTests );
CHECK( matchHidden.shouldInclude( fakeTestCase( "any" ) ) == false );
CHECK( matchNonHidden.shouldInclude( fakeTestCase( "any" ) ) );
2012-08-16 19:48:32 +02:00
CHECK( matchHidden.shouldInclude( fakeTestCase( "./any" ) ) );
CHECK( matchNonHidden.shouldInclude( fakeTestCase( "./any" ) ) == false );
2012-08-16 19:48:32 +02:00
}
2012-08-24 09:23:50 +02:00
TEST_CASE( "selftest/test filters", "Sets of filters" ) {
2012-08-16 19:48:32 +02:00
Catch::TestCaseFilter matchHidden( "./*" );
Catch::TestCaseFilter dontMatchA( "./a*", Catch::IfFilterMatches::ExcludeTests );
2012-08-23 21:08:50 +02:00
Catch::TestCaseFilters filters( "" );
2012-08-16 19:48:32 +02:00
filters.addFilter( matchHidden );
filters.addFilter( dontMatchA );
CHECK( matchHidden.shouldInclude( fakeTestCase( "./something" ) ) );
2012-08-16 19:48:32 +02:00
CHECK( filters.shouldInclude( fakeTestCase( "any" ) ) == false );
CHECK( filters.shouldInclude( fakeTestCase( "./something" ) ) );
CHECK( filters.shouldInclude( fakeTestCase( "./anything" ) ) == false );
2012-08-16 19:48:32 +02:00
}
2012-08-24 09:23:50 +02:00
TEST_CASE( "selftest/filter/prefix wildcard", "Individual filters with wildcards at the start" ) {
Catch::TestCaseFilter matchBadgers( "*badger" );
CHECK( matchBadgers.shouldInclude( fakeTestCase( "big badger" ) ));
CHECK( matchBadgers.shouldInclude( fakeTestCase( "little badgers" ) ) == false );
2012-08-24 09:23:50 +02:00
}
TEST_CASE( "selftest/filter/wildcard at both ends", "Individual filters with wildcards at both ends" ) {
Catch::TestCaseFilter matchBadgers( "*badger*" );
CHECK( matchBadgers.shouldInclude( fakeTestCase( "big badger" ) ));
CHECK( matchBadgers.shouldInclude( fakeTestCase( "little badgers" ) ) );
CHECK( matchBadgers.shouldInclude( fakeTestCase( "badgers are big" ) ) );
CHECK( matchBadgers.shouldInclude( fakeTestCase( "hedgehogs" ) ) == false );
2012-08-24 09:23:50 +02:00
}
template<size_t size>
int getArgc( const char * (&)[size] ) {
return size;
}
TEST_CASE( "selftest/option parsers", "" )
{
Catch::ConfigData config;
Catch::SharedImpl<Catch::Options::TestCaseOptionParser> tcOpt;
Catch::OptionParser& opt = tcOpt;
const char* argv[] = { "test", "-t", "test1" };
Catch::CommandParser parser( getArgc( argv ), argv );
CHECK_NOTHROW( opt.parseIntoConfig( parser, config ) );
REQUIRE( config.filters.size() == 1 );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "notIncluded" ) ) == false );
REQUIRE( config.filters[0].shouldInclude( fakeTestCase( "test1" ) ) );
2012-09-15 18:53:27 +02:00
}
TEST_CASE( "selftest/tags", "" ) {
std::string p1 = "[one]";
std::string p2 = "[one],[two]";
std::string p3 = "[one][two]";
std::string p4 = "[one][two],[three]";
std::string p5 = "[one][two]~[hide],[three]";
2012-09-15 18:53:27 +02:00
SECTION( "one tag", "" ) {
Catch::TestCase oneTag = makeTestCase( NULL, "", "test", "[one]", CATCH_INTERNAL_LINEINFO );
2012-09-15 18:53:27 +02:00
CHECK( oneTag.getTestCaseInfo().description == "" );
2012-09-15 18:53:27 +02:00
CHECK( oneTag.hasTag( "one" ) );
CHECK( oneTag.getTags().size() == 1 );
CHECK( oneTag.matchesTags( p1 ) == true );
CHECK( oneTag.matchesTags( p2 ) == true );
CHECK( oneTag.matchesTags( p3 ) == false );
CHECK( oneTag.matchesTags( p4 ) == false );
CHECK( oneTag.matchesTags( p5 ) == false );
2012-09-15 18:53:27 +02:00
}
SECTION( "two tags", "" ) {
Catch::TestCase twoTags= makeTestCase( NULL, "", "test", "[one][two]", CATCH_INTERNAL_LINEINFO );
2012-09-15 18:53:27 +02:00
CHECK( twoTags.getTestCaseInfo().description == "" );
2012-09-15 18:53:27 +02:00
CHECK( twoTags.hasTag( "one" ) );
CHECK( twoTags.hasTag( "two" ) );
2013-03-22 20:00:42 +01:00
CHECK( twoTags.hasTag( "Two" ) );
2012-09-15 18:53:27 +02:00
CHECK( twoTags.hasTag( "three" ) == false );
CHECK( twoTags.getTags().size() == 2 );
CHECK( twoTags.matchesTags( p1 ) == true );
CHECK( twoTags.matchesTags( p2 ) == true );
CHECK( twoTags.matchesTags( p3 ) == true );
CHECK( twoTags.matchesTags( p4 ) == true );
CHECK( twoTags.matchesTags( p5 ) == true );
2012-09-15 18:53:27 +02:00
}
2012-09-15 18:53:27 +02:00
SECTION( "one tag with characters either side", "" ) {
Catch::TestCase oneTagWithExtras = makeTestCase( NULL, "", "test", "12[one]34", CATCH_INTERNAL_LINEINFO );
CHECK( oneTagWithExtras.getTestCaseInfo().description == "1234" );
2012-09-15 18:53:27 +02:00
CHECK( oneTagWithExtras.hasTag( "one" ) );
CHECK( oneTagWithExtras.hasTag( "two" ) == false );
CHECK( oneTagWithExtras.getTags().size() == 1 );
2012-09-15 18:53:27 +02:00
}
SECTION( "start of a tag, but not closed", "" ) {
Catch::TestCase oneTagOpen = makeTestCase( NULL, "", "test", "[one", CATCH_INTERNAL_LINEINFO );
2012-09-15 18:53:27 +02:00
CHECK( oneTagOpen.getTestCaseInfo().description == "[one" );
2012-09-15 18:53:27 +02:00
CHECK( oneTagOpen.hasTag( "one" ) == false );
CHECK( oneTagOpen.getTags().size() == 0 );
2012-09-15 18:53:27 +02:00
}
SECTION( "hidden", "" ) {
Catch::TestCase oneTag = makeTestCase( NULL, "", "test", "[hide]", CATCH_INTERNAL_LINEINFO );
CHECK( oneTag.getTestCaseInfo().description == "" );
2012-09-15 18:53:27 +02:00
CHECK( oneTag.hasTag( "hide" ) );
CHECK( oneTag.isHidden() );
CHECK( oneTag.matchesTags( "~[hide]" ) == false );
2012-09-15 18:53:27 +02:00
}
}
TEST_CASE( "Long strings can be wrapped", "[wrap]" ) {
SECTION( "plain string", "" ) {
// guide: 123456789012345678
std::string testString = "one two three four";
SECTION( "No wrapping", "" ) {
CHECK( Catch::LineWrapper( 80 ).wrap( testString ).toString() == testString );
CHECK( Catch::LineWrapper( 18 ).wrap( testString ).toString() == testString );
}
SECTION( "Wrapped once", "" ) {
CHECK( Catch::LineWrapper( 17 ).wrap( testString ).toString() == "one two three\nfour" );
CHECK( Catch::LineWrapper( 16 ).wrap( testString ).toString() == "one two three\nfour" );
CHECK( Catch::LineWrapper( 15 ).wrap( testString ).toString() == "one two three\nfour" );
CHECK( Catch::LineWrapper( 14 ).wrap( testString ).toString() == "one two three\nfour" );
CHECK( Catch::LineWrapper( 13 ).wrap( testString ).toString() == "one two\nthree four" );
}
SECTION( "Wrapped twice", "" ) {
CHECK( Catch::LineWrapper( 9 ).wrap( testString ).toString() == "one two\nthree\nfour" );
CHECK( Catch::LineWrapper( 8 ).wrap( testString ).toString() == "one two\nthree\nfour" );
}
SECTION( "Wrapped three times", "" ) {
CHECK( Catch::LineWrapper( 7 ).wrap( testString ).toString() == "one\ntwo\nthree\nfour" );
CHECK( Catch::LineWrapper( 5 ).wrap( testString ).toString() == "one\ntwo\nthree\nfour" );
}
SECTION( "Short wrap", "" ) {
CHECK( Catch::LineWrapper( 4 ).wrap( "abcdef" ).toString() == "abc-\ndef" );
CHECK( Catch::LineWrapper( 4 ).wrap( "abcdefg" ).toString() == "abc-\ndefg" );
CHECK( Catch::LineWrapper( 4 ).wrap("abcdefgh" ).toString() == "abc-\ndef-\ngh" );
CHECK( Catch::LineWrapper( 4 ).wrap( testString ).toString() == "one\ntwo\nthr-\nee\nfour" );
CHECK( Catch::LineWrapper( 3 ).wrap( testString ).toString() == "one\ntwo\nth-\nree\nfo-\nur" );
}
}
SECTION( "With newlines", "" ) {
// guide: 1234567890123456789
std::string testString = "one two\nthree four";
SECTION( "No wrapping" , "" ) {
CHECK( Catch::LineWrapper( 80 ).wrap( testString ).toString() == testString );
CHECK( Catch::LineWrapper( 18 ).wrap( testString ).toString() == testString );
CHECK( Catch::LineWrapper( 10 ).wrap( testString ).toString() == testString );
}
SECTION( "Trailing newline" , "" ) {
CHECK( Catch::LineWrapper( 10 ).wrap( "abcdef\n" ).toString() == "abcdef\n" );
CHECK( Catch::LineWrapper( 6 ).wrap( "abcdef" ).toString() == "abcdef" );
CHECK( Catch::LineWrapper( 6 ).wrap( "abcdef\n" ).toString() == "abcdef\n" );
}
SECTION( "Wrapped once", "" ) {
CHECK( Catch::LineWrapper( 9 ).wrap( testString ).toString() == "one two\nthree\nfour" );
CHECK( Catch::LineWrapper( 8 ).wrap( testString ).toString() == "one two\nthree\nfour" );
CHECK( Catch::LineWrapper( 7 ).wrap( testString ).toString() == "one two\nthree\nfour" );
}
SECTION( "Wrapped twice", "" ) {
CHECK( Catch::LineWrapper( 6 ).wrap( testString ).toString() == "one\ntwo\nthree\nfour" );
}
}
}