2011-01-07 11:22:24 +01:00
|
|
|
/*
|
|
|
|
* Created by Phil on 7/1/2011
|
|
|
|
* Copyright 2010 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-09-17 07:42:29 +02:00
|
|
|
#ifndef TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
|
|
|
|
#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
|
|
|
|
|
2011-01-07 11:22:24 +01:00
|
|
|
#include "catch_test_registry.hpp"
|
2012-08-14 20:30:30 +02:00
|
|
|
#include "catch_test_case_info.h"
|
2014-05-16 19:28:58 +02:00
|
|
|
#include "catch_test_spec.hpp"
|
2012-05-10 08:58:48 +02:00
|
|
|
#include "catch_context.h"
|
2017-07-06 22:28:42 +02:00
|
|
|
#include "catch_interfaces_config.h"
|
2017-07-25 21:57:35 +02:00
|
|
|
#include "catch_string_manip.h"
|
2011-01-07 11:22:24 +01:00
|
|
|
|
|
|
|
#include <vector>
|
|
|
|
#include <set>
|
2011-01-18 21:09:21 +01:00
|
|
|
#include <sstream>
|
2014-09-16 00:32:13 +02:00
|
|
|
#include <algorithm>
|
2011-01-07 11:22:24 +01:00
|
|
|
|
2012-05-16 09:02:20 +02:00
|
|
|
|
2016-06-09 09:15:57 +02:00
|
|
|
namespace Catch {
|
2016-10-14 23:06:45 +02:00
|
|
|
|
2015-08-05 00:11:56 +02:00
|
|
|
struct RandomNumberGenerator {
|
2016-10-14 23:06:45 +02:00
|
|
|
typedef std::ptrdiff_t result_type;
|
2016-06-09 09:15:57 +02:00
|
|
|
|
|
|
|
result_type operator()( result_type n ) const { return std::rand() % n; }
|
|
|
|
|
|
|
|
static constexpr result_type min() { return 0; }
|
|
|
|
static constexpr result_type max() { return 1000000; }
|
|
|
|
result_type operator()() const { return std::rand() % max(); }
|
|
|
|
template<typename V>
|
|
|
|
static void shuffle( V& vector ) {
|
2016-06-09 20:07:05 +02:00
|
|
|
RandomNumberGenerator rng;
|
|
|
|
std::shuffle( vector.begin(), vector.end(), rng );
|
2016-06-09 09:15:57 +02:00
|
|
|
}
|
2015-08-05 00:11:56 +02:00
|
|
|
};
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2015-08-05 00:11:56 +02:00
|
|
|
inline std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2015-08-05 00:11:56 +02:00
|
|
|
std::vector<TestCase> sorted = unsortedTestCases;
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2015-08-05 00:11:56 +02:00
|
|
|
switch( config.runOrder() ) {
|
|
|
|
case RunTests::InLexicographicalOrder:
|
2016-06-09 09:15:57 +02:00
|
|
|
std::sort( sorted.begin(), sorted.end() );
|
2015-08-05 00:11:56 +02:00
|
|
|
break;
|
|
|
|
case RunTests::InRandomOrder:
|
2017-07-13 09:25:47 +02:00
|
|
|
seedRng( config );
|
|
|
|
RandomNumberGenerator::shuffle( sorted );
|
2015-08-05 00:11:56 +02:00
|
|
|
break;
|
|
|
|
case RunTests::InDeclarationOrder:
|
|
|
|
// already in declaration order
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return sorted;
|
|
|
|
}
|
|
|
|
bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
|
|
|
|
return testSpec.matches( testCase ) && ( config.allowThrows() || !testCase.throws() );
|
|
|
|
}
|
|
|
|
|
|
|
|
void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
|
|
|
|
std::set<TestCase> seenFunctions;
|
2017-05-05 16:42:57 +02:00
|
|
|
for( auto const& function : functions ) {
|
|
|
|
auto prev = seenFunctions.insert( function );
|
|
|
|
CATCH_ENFORCE( prev.second,
|
|
|
|
"error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
|
|
|
|
<< "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
|
|
|
|
<< "\tRedefined at " << function.getTestCaseInfo().lineInfo );
|
2015-08-05 00:11:56 +02:00
|
|
|
}
|
|
|
|
}
|
2015-11-04 19:01:28 +01:00
|
|
|
|
2015-08-05 00:11:56 +02:00
|
|
|
std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
|
|
|
|
std::vector<TestCase> filtered;
|
2015-08-07 18:53:29 +02:00
|
|
|
filtered.reserve( testCases.size() );
|
2017-04-25 12:06:52 +02:00
|
|
|
for( auto const& testCase : testCases )
|
|
|
|
if( matchTest( testCase, testSpec, config ) )
|
|
|
|
filtered.push_back( testCase );
|
2015-08-05 00:11:56 +02:00
|
|
|
return filtered;
|
|
|
|
}
|
|
|
|
std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
|
|
|
|
return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
|
|
|
|
}
|
2014-09-18 19:24:41 +02:00
|
|
|
|
2015-08-05 00:11:56 +02:00
|
|
|
class TestRegistry : public ITestCaseRegistry {
|
2011-01-07 11:22:24 +01:00
|
|
|
public:
|
2012-08-13 08:46:10 +02:00
|
|
|
virtual ~TestRegistry();
|
2013-07-03 20:14:59 +02:00
|
|
|
|
2013-04-23 19:58:56 +02:00
|
|
|
virtual void registerTest( TestCase const& testCase ) {
|
2012-11-25 12:19:55 +01:00
|
|
|
std::string name = testCase.getTestCaseInfo().name;
|
2017-01-15 09:41:33 +01:00
|
|
|
if( name.empty() ) {
|
2011-01-18 21:09:21 +01:00
|
|
|
std::ostringstream oss;
|
2013-03-16 21:18:52 +01:00
|
|
|
oss << "Anonymous test case " << ++m_unnamedCount;
|
2012-11-25 12:19:55 +01:00
|
|
|
return registerTest( testCase.withName( oss.str() ) );
|
2011-01-18 21:09:21 +01:00
|
|
|
}
|
2015-08-05 00:11:56 +02:00
|
|
|
m_functions.push_back( testCase );
|
2011-01-07 11:22:24 +01:00
|
|
|
}
|
2013-07-03 20:14:59 +02:00
|
|
|
|
2017-07-20 16:57:17 +02:00
|
|
|
std::vector<TestCase> const& getAllTests() const override {
|
2015-08-05 00:11:56 +02:00
|
|
|
return m_functions;
|
2011-01-07 11:22:24 +01:00
|
|
|
}
|
2017-07-20 16:57:17 +02:00
|
|
|
std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override {
|
2015-08-05 00:11:56 +02:00
|
|
|
if( m_sortedFunctions.empty() )
|
|
|
|
enforceNoDuplicateTestCases( m_functions );
|
2011-03-11 20:44:59 +01:00
|
|
|
|
2015-08-05 00:11:56 +02:00
|
|
|
if( m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
|
|
|
|
m_sortedFunctions = sortTests( config, m_functions );
|
|
|
|
m_currentSortOrder = config.runOrder();
|
2011-03-11 20:44:59 +01:00
|
|
|
}
|
2015-08-05 00:11:56 +02:00
|
|
|
return m_sortedFunctions;
|
2014-12-22 21:10:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2015-08-05 00:11:56 +02:00
|
|
|
std::vector<TestCase> m_functions;
|
2017-04-25 19:56:53 +02:00
|
|
|
mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
|
2015-08-05 00:11:56 +02:00
|
|
|
mutable std::vector<TestCase> m_sortedFunctions;
|
2017-04-25 19:56:53 +02:00
|
|
|
size_t m_unnamedCount = 0;
|
2015-07-10 08:44:37 +02:00
|
|
|
std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
|
2011-01-07 11:22:24 +01:00
|
|
|
};
|
2011-01-28 19:56:26 +01:00
|
|
|
|
2017-07-06 22:28:42 +02:00
|
|
|
TestRegistry::~TestRegistry() {}
|
|
|
|
|
|
|
|
|
2011-01-28 19:56:26 +01:00
|
|
|
///////////////////////////////////////////////////////////////////////////
|
2013-07-03 20:14:59 +02:00
|
|
|
|
2017-07-12 19:01:54 +02:00
|
|
|
class TestInvokerAsFunction : public ITestInvoker {
|
|
|
|
void(*m_testAsFunction)();
|
2012-05-10 22:46:46 +02:00
|
|
|
public:
|
2017-07-13 09:25:47 +02:00
|
|
|
TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
|
2012-05-10 22:46:46 +02:00
|
|
|
|
2017-07-12 19:01:54 +02:00
|
|
|
void invoke() const override {
|
|
|
|
m_testAsFunction();
|
2011-01-07 11:22:24 +01:00
|
|
|
}
|
|
|
|
};
|
2017-07-13 09:25:47 +02:00
|
|
|
auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
|
|
|
|
return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
|
2017-07-12 23:39:31 +02:00
|
|
|
}
|
|
|
|
|
2012-11-04 22:11:59 +01:00
|
|
|
|
2013-04-23 19:58:56 +02:00
|
|
|
inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) {
|
2012-11-04 22:11:59 +01:00
|
|
|
std::string className = classOrQualifiedMethodName;
|
2017-01-15 09:41:33 +01:00
|
|
|
if( startsWith( className, '&' ) )
|
2012-11-04 22:11:59 +01:00
|
|
|
{
|
|
|
|
std::size_t lastColons = className.rfind( "::" );
|
|
|
|
std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
|
|
|
|
if( penultimateColons == std::string::npos )
|
|
|
|
penultimateColons = 1;
|
|
|
|
className = className.substr( penultimateColons, lastColons-penultimateColons );
|
|
|
|
}
|
|
|
|
return className;
|
|
|
|
}
|
2013-07-03 20:14:59 +02:00
|
|
|
|
2017-07-12 23:39:31 +02:00
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2017-07-13 09:25:47 +02:00
|
|
|
AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept
|
2017-07-12 23:39:31 +02:00
|
|
|
{
|
2017-06-04 22:37:59 +02:00
|
|
|
try {
|
2017-07-12 23:39:31 +02:00
|
|
|
getMutableRegistryHub()
|
|
|
|
.registerTest(
|
|
|
|
makeTestCase(
|
|
|
|
invoker,
|
|
|
|
extractClassName( classOrMethod.c_str() ),
|
|
|
|
nameAndTags.name.c_str(),
|
|
|
|
nameAndTags.tags.c_str(),
|
|
|
|
lineInfo));
|
2017-06-04 22:37:59 +02:00
|
|
|
} catch (...) {
|
|
|
|
// Do not throw when constructing global objects, instead register the exception to be processed later
|
|
|
|
getMutableRegistryHub().registerStartupException( std::current_exception() );
|
|
|
|
}
|
2015-11-20 17:54:07 +01:00
|
|
|
}
|
2012-05-10 22:46:46 +02:00
|
|
|
AutoReg::~AutoReg() {}
|
2013-07-03 20:14:59 +02:00
|
|
|
|
2011-01-07 11:22:24 +01:00
|
|
|
} // end namespace Catch
|
|
|
|
|
2012-09-17 07:42:29 +02:00
|
|
|
|
|
|
|
#endif // TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
|