585 lines
18 KiB
C++
Executable File
585 lines
18 KiB
C++
Executable File
// (C) Copyright Gennadiy Rozental 2001.
|
|
// 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)
|
|
|
|
// See http://www.boost.org/libs/test for the library home page.
|
|
//
|
|
/// @file
|
|
/// Provides core implementation for Unit Test Framework.
|
|
/// Extensions can be provided in separate files
|
|
// ***************************************************************************
|
|
|
|
#ifndef BOOST_TEST_UNIT_TEST_SUITE_IPP_012205GER
|
|
#define BOOST_TEST_UNIT_TEST_SUITE_IPP_012205GER
|
|
|
|
// Boost.Test
|
|
#include <boost/detail/workaround.hpp>
|
|
|
|
#include <boost/test/framework.hpp>
|
|
#include <boost/test/results_collector.hpp>
|
|
|
|
#include <boost/test/tree/test_unit.hpp>
|
|
#include <boost/test/tree/visitor.hpp>
|
|
#include <boost/test/tree/traverse.hpp>
|
|
#include <boost/test/tree/auto_registration.hpp>
|
|
#include <boost/test/tree/global_fixture.hpp>
|
|
|
|
#include <boost/test/utils/foreach.hpp>
|
|
#include <boost/test/utils/basic_cstring/io.hpp>
|
|
|
|
#include <boost/test/unit_test_parameters.hpp>
|
|
|
|
// STL
|
|
#include <algorithm>
|
|
#include <vector>
|
|
#include <set>
|
|
|
|
#include <boost/test/detail/suppress_warnings.hpp>
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
namespace boost {
|
|
namespace unit_test {
|
|
|
|
// ************************************************************************** //
|
|
// ************** test_unit ************** //
|
|
// ************************************************************************** //
|
|
|
|
test_unit::test_unit( const_string name, const_string file_name, std::size_t line_num, test_unit_type t )
|
|
: p_type( t )
|
|
, p_type_name( t == TUT_CASE ? "case" : "suite" )
|
|
, p_file_name( file_name )
|
|
, p_line_num( line_num )
|
|
, p_id( INV_TEST_UNIT_ID )
|
|
, p_parent_id( INV_TEST_UNIT_ID )
|
|
, p_name( std::string( name.begin(), name.size() ) )
|
|
, p_timeout( 0 )
|
|
, p_expected_failures( 0 )
|
|
, p_default_status( RS_INHERIT )
|
|
, p_run_status( RS_INVALID )
|
|
, p_sibling_rank(0)
|
|
{
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
test_unit::test_unit( const_string module_name )
|
|
: p_type( TUT_SUITE )
|
|
, p_type_name( "module" )
|
|
, p_line_num( 0 )
|
|
, p_id( INV_TEST_UNIT_ID )
|
|
, p_parent_id( INV_TEST_UNIT_ID )
|
|
, p_name( std::string( module_name.begin(), module_name.size() ) )
|
|
, p_timeout( 0 )
|
|
, p_expected_failures( 0 )
|
|
, p_default_status( RS_INHERIT )
|
|
, p_run_status( RS_INVALID )
|
|
, p_sibling_rank(0)
|
|
{
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
test_unit::~test_unit()
|
|
{
|
|
framework::deregister_test_unit( this );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
void
|
|
test_unit::depends_on( test_unit* tu )
|
|
{
|
|
BOOST_TEST_SETUP_ASSERT( p_id != framework::master_test_suite().p_id,
|
|
"Can't add dependency to the master test suite" );
|
|
|
|
p_dependencies.value.push_back( tu->p_id );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
void
|
|
test_unit::add_precondition( precondition_t const& pc )
|
|
{
|
|
p_preconditions.value.push_back( pc );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
test_tools::assertion_result
|
|
test_unit::check_preconditions() const
|
|
{
|
|
BOOST_TEST_FOREACH( test_unit_id, dep_id, p_dependencies.get() ) {
|
|
test_unit const& dep = framework::get( dep_id, TUT_ANY );
|
|
|
|
if( !dep.is_enabled() ) {
|
|
test_tools::assertion_result res(false);
|
|
res.message() << "dependency test " << dep.p_type_name << " \"" << dep.full_name() << "\" is disabled";
|
|
return res;
|
|
}
|
|
|
|
test_results const& test_rslt = unit_test::results_collector.results( dep_id );
|
|
if( !test_rslt.passed() ) {
|
|
test_tools::assertion_result res(false);
|
|
res.message() << "dependency test " << dep.p_type_name << " \"" << dep.full_name() << (test_rslt.skipped() ? "\" was skipped":"\" has failed");
|
|
return res;
|
|
}
|
|
|
|
if( test_rslt.p_test_cases_skipped > 0 ) {
|
|
test_tools::assertion_result res(false);
|
|
res.message() << "dependency test " << dep.p_type_name << " \"" << dep.full_name() << "\" has skipped test cases";
|
|
return res;
|
|
}
|
|
}
|
|
|
|
BOOST_TEST_FOREACH( precondition_t, precondition, p_preconditions.get() ) {
|
|
test_tools::assertion_result res = precondition( p_id );
|
|
if( !res ) {
|
|
test_tools::assertion_result res_out(false);
|
|
res_out.message() << "precondition failed";
|
|
if( !res.has_empty_message() )
|
|
res_out.message() << ": " << res.message();
|
|
return res_out;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
void
|
|
test_unit::increase_exp_fail( counter_t num )
|
|
{
|
|
p_expected_failures.value += num;
|
|
|
|
if( p_parent_id != INV_TEST_UNIT_ID )
|
|
framework::get<test_suite>( p_parent_id ).increase_exp_fail( num );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
std::string
|
|
test_unit::full_name() const
|
|
{
|
|
if( p_parent_id == INV_TEST_UNIT_ID || p_parent_id == framework::master_test_suite().p_id )
|
|
return p_name;
|
|
|
|
std::string res = framework::get<test_suite>( p_parent_id ).full_name();
|
|
res.append("/");
|
|
|
|
res.append( p_name );
|
|
|
|
return res;
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
void
|
|
test_unit::add_label( const_string l )
|
|
{
|
|
p_labels.value.push_back( std::string() + l );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
bool
|
|
test_unit::has_label( const_string l ) const
|
|
{
|
|
return std::find( p_labels->begin(), p_labels->end(), l ) != p_labels->end();
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
// ************************************************************************** //
|
|
// ************** test_case ************** //
|
|
// ************************************************************************** //
|
|
|
|
test_case::test_case( const_string name, boost::function<void ()> const& test_func )
|
|
: test_unit( name, "", 0, static_cast<test_unit_type>(type) )
|
|
, p_test_func( test_func )
|
|
{
|
|
framework::register_test_unit( this );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
test_case::test_case( const_string name, const_string file_name, std::size_t line_num, boost::function<void ()> const& test_func )
|
|
: test_unit( name, file_name, line_num, static_cast<test_unit_type>(type) )
|
|
, p_test_func( test_func )
|
|
{
|
|
framework::register_test_unit( this );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
// ************************************************************************** //
|
|
// ************** test_suite ************** //
|
|
// ************************************************************************** //
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
test_suite::test_suite( const_string name, const_string file_name, std::size_t line_num )
|
|
: test_unit( ut_detail::normalize_test_case_name( name ), file_name, line_num, static_cast<test_unit_type>(type) )
|
|
{
|
|
framework::register_test_unit( this );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
test_suite::test_suite( const_string module_name )
|
|
: test_unit( module_name )
|
|
{
|
|
framework::register_test_unit( this );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
void
|
|
test_suite::add( test_unit* tu, counter_t expected_failures, unsigned timeout )
|
|
{
|
|
tu->p_timeout.value = timeout;
|
|
|
|
m_children.push_back( tu->p_id );
|
|
tu->p_parent_id.value = p_id;
|
|
|
|
if( tu->p_expected_failures != 0 )
|
|
increase_exp_fail( tu->p_expected_failures );
|
|
|
|
if( expected_failures )
|
|
tu->increase_exp_fail( expected_failures );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
void
|
|
test_suite::add( test_unit_generator const& gen, unsigned timeout )
|
|
{
|
|
test_unit* tu;
|
|
while((tu = gen.next()) != 0)
|
|
add( tu, 0, timeout );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
void
|
|
test_suite::add( test_unit_generator const& gen, decorator::collector_t& decorators )
|
|
{
|
|
test_unit* tu;
|
|
while((tu = gen.next()) != 0) {
|
|
decorators.store_in( *tu );
|
|
add( tu, 0 );
|
|
}
|
|
decorators.reset();
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
void
|
|
test_suite::add( boost::shared_ptr<test_unit_generator> gen_ptr, decorator::collector_t& decorators )
|
|
{
|
|
std::pair<boost::shared_ptr<test_unit_generator>, std::vector<decorator::base_ptr> > tmp_p(gen_ptr, decorators.get_lazy_decorators() );
|
|
m_generators.push_back(tmp_p);
|
|
decorators.reset();
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
void
|
|
test_suite::generate( )
|
|
{
|
|
typedef std::pair<boost::shared_ptr<test_unit_generator>, std::vector<decorator::base_ptr> > element_t;
|
|
|
|
for(std::vector<element_t>::iterator it(m_generators.begin()), ite(m_generators.end());
|
|
it < ite;
|
|
++it)
|
|
{
|
|
test_unit* tu;
|
|
while((tu = it->first->next()) != 0) {
|
|
tu->p_decorators.value.insert( tu->p_decorators.value.end(), it->second.begin(), it->second.end() );
|
|
//it->second.store_in( *tu );
|
|
add( tu, 0 );
|
|
}
|
|
|
|
}
|
|
m_generators.clear();
|
|
|
|
#if 0
|
|
test_unit* tu;
|
|
while((tu = gen.next()) != 0) {
|
|
decorators.store_in( *tu );
|
|
add( tu, 0 );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
void
|
|
test_suite::check_for_duplicate_test_cases() {
|
|
// check for clashing names #12597
|
|
std::set<std::string> names;
|
|
for( test_unit_id_list::const_iterator it(m_children.begin()), ite(m_children.end());
|
|
it < ite;
|
|
++it) {
|
|
std::string name = framework::get(*it, TUT_ANY).p_name;
|
|
std::pair<std::set<std::string>::iterator, bool> ret = names.insert(name);
|
|
BOOST_TEST_SETUP_ASSERT(ret.second,
|
|
"test unit with name '"
|
|
+ name
|
|
+ std::string("' registered multiple times in the test suite '")
|
|
+ this->p_name.value
|
|
+ "'");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
void
|
|
test_suite::remove( test_unit_id id )
|
|
{
|
|
test_unit_id_list::iterator it = std::find( m_children.begin(), m_children.end(), id );
|
|
|
|
if( it != m_children.end() )
|
|
m_children.erase( it );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
test_unit_id
|
|
test_suite::get( const_string tu_name ) const
|
|
{
|
|
BOOST_TEST_FOREACH( test_unit_id, id, m_children ) {
|
|
if( tu_name == framework::get( id, ut_detail::test_id_2_unit_type( id ) ).p_name.get() )
|
|
return id;
|
|
}
|
|
|
|
return INV_TEST_UNIT_ID;
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
// ************************************************************************** //
|
|
// ************** master_test_suite ************** //
|
|
// ************************************************************************** //
|
|
|
|
master_test_suite_t::master_test_suite_t()
|
|
: test_suite( "Master Test Suite" )
|
|
, argc( 0 )
|
|
, argv( 0 )
|
|
{
|
|
p_default_status.value = RS_ENABLED;
|
|
}
|
|
|
|
// ************************************************************************** //
|
|
// ************** traverse_test_tree ************** //
|
|
// ************************************************************************** //
|
|
|
|
void
|
|
traverse_test_tree( test_case const& tc, test_tree_visitor& V, bool ignore_status )
|
|
{
|
|
if( tc.is_enabled() || ignore_status )
|
|
V.visit( tc );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
void
|
|
traverse_test_tree( test_suite const& suite, test_tree_visitor& V, bool ignore_status )
|
|
{
|
|
// skip disabled test suite unless we asked to ignore this condition
|
|
if( !ignore_status && !suite.is_enabled() )
|
|
return;
|
|
|
|
// Invoke test_suite_start callback
|
|
if( !V.test_suite_start( suite ) )
|
|
return;
|
|
|
|
// Recurse into children
|
|
std::size_t total_children = suite.m_children.size();
|
|
for( std::size_t i=0; i < total_children; ) {
|
|
// this statement can remove the test unit from this list
|
|
traverse_test_tree( suite.m_children[i], V, ignore_status );
|
|
if( total_children > suite.m_children.size() )
|
|
total_children = suite.m_children.size();
|
|
else
|
|
++i;
|
|
}
|
|
|
|
// Invoke test_suite_finish callback
|
|
V.test_suite_finish( suite );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
void
|
|
traverse_test_tree( test_unit_id id, test_tree_visitor& V, bool ignore_status )
|
|
{
|
|
if( ut_detail::test_id_2_unit_type( id ) == TUT_CASE )
|
|
traverse_test_tree( framework::get<test_case>( id ), V, ignore_status );
|
|
else
|
|
traverse_test_tree( framework::get<test_suite>( id ), V, ignore_status );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
// ************************************************************************** //
|
|
// ************** object generators ************** //
|
|
// ************************************************************************** //
|
|
|
|
namespace ut_detail {
|
|
|
|
std::string
|
|
normalize_test_case_name( const_string name )
|
|
{
|
|
std::string norm_name( name.begin(), name.size() );
|
|
|
|
if( name[0] == '&' )
|
|
norm_name = norm_name.substr( 1 );
|
|
|
|
// trim spaces
|
|
std::size_t first_not_space = norm_name.find_first_not_of(' ');
|
|
if( first_not_space ) {
|
|
norm_name.erase(0, first_not_space);
|
|
}
|
|
|
|
std::size_t last_not_space = norm_name.find_last_not_of(' ');
|
|
if( last_not_space !=std::string::npos ) {
|
|
norm_name.erase(last_not_space + 1);
|
|
}
|
|
|
|
// sanitize all chars that might be used in runtime filters
|
|
static const char to_replace[] = { ':', '*', '@', '+', '!', '/', ',' };
|
|
for(std::size_t index = 0;
|
|
index < sizeof(to_replace)/sizeof(to_replace[0]);
|
|
index++) {
|
|
std::replace(norm_name.begin(), norm_name.end(), to_replace[index], '_');
|
|
}
|
|
|
|
return norm_name;
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
// ************************************************************************** //
|
|
// ************** auto_test_unit_registrar ************** //
|
|
// ************************************************************************** //
|
|
|
|
auto_test_unit_registrar::auto_test_unit_registrar( test_case* tc, decorator::collector_t& decorators, counter_t exp_fail )
|
|
{
|
|
framework::current_auto_test_suite().add( tc, exp_fail );
|
|
|
|
decorators.store_in( *tc );
|
|
decorators.reset();
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
auto_test_unit_registrar::auto_test_unit_registrar( const_string ts_name, const_string ts_file, std::size_t ts_line, decorator::collector_t& decorators )
|
|
{
|
|
test_unit_id id = framework::current_auto_test_suite().get( ts_name );
|
|
|
|
test_suite* ts;
|
|
|
|
if( id != INV_TEST_UNIT_ID ) {
|
|
ts = &framework::get<test_suite>( id );
|
|
BOOST_ASSERT( ts->p_parent_id == framework::current_auto_test_suite().p_id );
|
|
}
|
|
else {
|
|
ts = new test_suite( ts_name, ts_file, ts_line );
|
|
framework::current_auto_test_suite().add( ts );
|
|
}
|
|
|
|
decorators.store_in( *ts );
|
|
decorators.reset();
|
|
|
|
framework::current_auto_test_suite( ts );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
auto_test_unit_registrar::auto_test_unit_registrar( test_unit_generator const& tc_gen, decorator::collector_t& decorators )
|
|
{
|
|
framework::current_auto_test_suite().add( tc_gen, decorators );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
auto_test_unit_registrar::auto_test_unit_registrar( boost::shared_ptr<test_unit_generator> tc_gen, decorator::collector_t& decorators )
|
|
{
|
|
framework::current_auto_test_suite().add( tc_gen, decorators );
|
|
}
|
|
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
auto_test_unit_registrar::auto_test_unit_registrar( int )
|
|
{
|
|
framework::current_auto_test_suite( 0, false );
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
} // namespace ut_detail
|
|
|
|
// ************************************************************************** //
|
|
// ************** global_fixture ************** //
|
|
// ************************************************************************** //
|
|
|
|
global_fixture::global_fixture(): registered(false)
|
|
{
|
|
framework::register_global_fixture( *this );
|
|
registered = true;
|
|
}
|
|
|
|
void global_fixture::unregister_from_framework() {
|
|
// not accessing the framework singleton after deregistering -> release
|
|
// of the observer from the framework
|
|
if(registered) {
|
|
framework::deregister_global_fixture( *this );
|
|
}
|
|
registered = false;
|
|
}
|
|
|
|
global_fixture::~global_fixture()
|
|
{
|
|
this->unregister_from_framework();
|
|
}
|
|
|
|
// ************************************************************************** //
|
|
// ************** global_configuration ************** //
|
|
// ************************************************************************** //
|
|
|
|
global_configuration::global_configuration(): registered(false)
|
|
{
|
|
framework::register_observer( *this );
|
|
registered = true;
|
|
}
|
|
|
|
void global_configuration::unregister_from_framework()
|
|
{
|
|
// not accessing the framework singleton after deregistering -> release
|
|
// of the observer from the framework
|
|
if(registered) {
|
|
framework::deregister_observer( *this );
|
|
}
|
|
registered = false;
|
|
}
|
|
|
|
global_configuration::~global_configuration()
|
|
{
|
|
this->unregister_from_framework();
|
|
}
|
|
|
|
//____________________________________________________________________________//
|
|
|
|
} // namespace unit_test
|
|
} // namespace boost
|
|
|
|
#include <boost/test/detail/enable_warnings.hpp>
|
|
|
|
#endif // BOOST_TEST_UNIT_TEST_SUITE_IPP_012205GER
|