catch2/include/internal/catch_test_case_info.cpp

178 lines
5.7 KiB
C++
Raw Normal View History

/*
2012-08-14 20:30:30 +02:00
* Created by Phil on 14/08/2012.
* Copyright 2012 Two Blue Cubes Ltd. All rights reserved.
*
* 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-14 20:30:30 +02:00
#include "catch_test_case_info.h"
#include "catch_enforce.h"
#include "catch_test_spec.hpp"
#include "catch_interfaces_testcase.h"
#include "catch_string_manip.h"
#include <cctype>
#include <exception>
#include <algorithm>
2012-05-16 00:58:23 +02:00
namespace Catch {
2017-07-12 16:16:55 +02:00
TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
if( startsWith( tag, '.' ) ||
tag == "!hide" )
return TestCaseInfo::IsHidden;
else if( tag == "!throws" )
return TestCaseInfo::Throws;
else if( tag == "!shouldfail" )
return TestCaseInfo::ShouldFail;
else if( tag == "!mayfail" )
return TestCaseInfo::MayFail;
2017-01-23 18:44:55 +01:00
else if( tag == "!nonportable" )
return TestCaseInfo::NonPortable;
else if( tag == "!benchmark" )
return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
else
return TestCaseInfo::None;
}
2017-07-12 16:16:55 +02:00
bool isReservedTag( std::string const& tag ) {
return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( tag[0] );
}
2017-07-12 16:16:55 +02:00
void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
CATCH_ENFORCE( !isReservedTag(tag),
"Tag name: [" << tag << "] is not allowed.\n"
<< "Tag names starting with non alpha-numeric characters are reserved\n"
<< _lineInfo );
}
TestCase makeTestCase( ITestInvoker* _testCase,
std::string const& _className,
std::string const& _name,
std::string const& _descOrTags,
SourceLineInfo const& _lineInfo )
2012-09-15 18:53:27 +02:00
{
bool isHidden = false;
// Parse out tags
std::vector<std::string> tags;
std::string desc, tag;
bool inTag = false;
2017-08-29 14:02:14 +02:00
for (char c : _descOrTags) {
if( !inTag ) {
if( c == '[' )
inTag = true;
else
desc += c;
}
else {
if( c == ']' ) {
2014-12-15 08:25:34 +01:00
TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
if( ( prop & TestCaseInfo::IsHidden ) != 0 )
2014-05-19 18:50:58 +02:00
isHidden = true;
2014-12-15 08:25:34 +01:00
else if( prop == TestCaseInfo::None )
enforceNotReservedTag( tag, _lineInfo );
tags.push_back( tag );
tag.clear();
2014-12-15 08:25:34 +01:00
inTag = false;
}
else
tag += c;
}
2013-12-04 08:58:39 +01:00
}
if( isHidden ) {
tags.push_back( "." );
}
TestCaseInfo info( _name, _className, desc, tags, _lineInfo );
return TestCase( _testCase, info );
2012-09-15 18:53:27 +02:00
}
void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
std::sort(begin(tags), end(tags));
tags.erase(std::unique(begin(tags), end(tags)), end(tags));
2015-07-02 09:20:18 +02:00
testCaseInfo.lcaseTags.clear();
for( auto const& tag : tags ) {
std::string lcaseTag = toLower( tag );
2015-07-02 09:20:18 +02:00
testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
testCaseInfo.lcaseTags.push_back( lcaseTag );
2015-07-02 09:20:18 +02:00
}
testCaseInfo.tags = std::move(tags);
2015-07-02 09:20:18 +02:00
}
TestCaseInfo::TestCaseInfo( std::string const& _name,
std::string const& _className,
std::string const& _description,
std::vector<std::string> const& _tags,
SourceLineInfo const& _lineInfo )
: name( _name ),
className( _className ),
description( _description ),
lineInfo( _lineInfo ),
properties( None )
{
2015-07-02 09:20:18 +02:00
setTags( *this, _tags );
}
2012-08-14 09:38:22 +02:00
bool TestCaseInfo::isHidden() const {
return ( properties & IsHidden ) != 0;
}
bool TestCaseInfo::throws() const {
return ( properties & Throws ) != 0;
}
bool TestCaseInfo::okToFail() const {
return ( properties & (ShouldFail | MayFail ) ) != 0;
}
bool TestCaseInfo::expectedToFail() const {
return ( properties & (ShouldFail ) ) != 0;
}
std::string TestCaseInfo::tagsAsString() const {
std::string ret;
// '[' and ']' per tag
size_t full_size = 2 * tags.size();
for (const auto& tag : tags) {
full_size += tag.size();
}
ret.reserve(full_size);
for (const auto& tag : tags) {
ret.push_back('[');
ret.append(tag);
ret.push_back(']');
}
return ret;
}
TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {}
TestCase TestCase::withName( std::string const& _newName ) const {
TestCase other( *this );
other.name = _newName;
return other;
2012-08-14 20:30:30 +02:00
}
void TestCase::invoke() const {
test->invoke();
2012-08-14 20:30:30 +02:00
}
bool TestCase::operator == ( TestCase const& other ) const {
return test.get() == other.test.get() &&
name == other.name &&
className == other.className;
2012-08-14 20:30:30 +02:00
}
bool TestCase::operator < ( TestCase const& other ) const {
return name < other.name;
2012-08-14 20:30:30 +02:00
}
TestCaseInfo const& TestCase::getTestCaseInfo() const
{
return *this;
}
} // end namespace Catch