deb/beegfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New upstream version 8.1.0

Browse Source
This commit is contained in:
geos_one
2025-08-10 01:34:16 +02:00
commit c891bb7105
4398 changed files with 838833 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
thirdparty/source/boost_1_61_0/boost/test/tree/auto_registration.hpp vendored Normal file
View File

@@ -0,0 +1,53 @@
// (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 : $RCSfile$
//
// Version : $Revision: 74640 $
//
// Description : defines auto_test_unit_registrar
// ***************************************************************************
#ifndef BOOST_TEST_TREE_AUTO_REGISTRATION_HPP_100211GER
#define BOOST_TEST_TREE_AUTO_REGISTRATION_HPP_100211GER
// Boost.Test
#include <boost/test/detail/config.hpp>
#include <boost/test/tree/decorator.hpp>
#include <boost/test/tree/test_unit.hpp>
// STL
#include <list>
#include <boost/test/detail/suppress_warnings.hpp>
//____________________________________________________________________________//
namespace boost {
namespace unit_test {
namespace ut_detail {
// ************************************************************************** //
// ************** auto_test_unit_registrar ************** //
// ************************************************************************** //
struct BOOST_TEST_DECL auto_test_unit_registrar {
// Constructors
auto_test_unit_registrar( test_case* tc, decorator::collector& decorators, counter_t exp_fail = 0 );
explicit auto_test_unit_registrar( const_string ts_name, const_string ts_file, std::size_t ts_line, decorator::collector& decorators );
explicit auto_test_unit_registrar( test_unit_generator const& tc_gen, decorator::collector& decorators );
explicit auto_test_unit_registrar( int );
};
} // namespace ut_detail
} // namespace unit_test
} // namespace boost
#include <boost/test/detail/enable_warnings.hpp>
#endif // BOOST_TEST_TREE_AUTO_REGISTRATION_HPP_100211GER

277
thirdparty/source/boost_1_61_0/boost/test/tree/decorator.hpp vendored Normal file
View File

@@ -0,0 +1,277 @@
// (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 : $RCSfile$
//
// Version : $Revision: 62016 $
//
// Description : defines decorators to be using with auto registered test units
// ***************************************************************************
#ifndef BOOST_TEST_TREE_DECORATOR_HPP_091911GER
#define BOOST_TEST_TREE_DECORATOR_HPP_091911GER
// Boost.Test
#include <boost/test/detail/config.hpp>
#include <boost/test/detail/global_typedef.hpp>
#include <boost/test/tree/fixture.hpp>
#include <boost/test/tools/assertion_result.hpp>
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
#include <boost/test/utils/trivial_singleton.hpp>
// Boost
#include <boost/shared_ptr.hpp>
#include <boost/function/function0.hpp>
#include <boost/function/function1.hpp>
#include <boost/test/detail/suppress_warnings.hpp>
// STL
#include <vector>
//____________________________________________________________________________//
namespace boost {
namespace unit_test {
class test_unit;
namespace decorator {
// ************************************************************************** //
// ************** decorator::collector ************** //
// ************************************************************************** //
class base;
typedef boost::shared_ptr<base> base_ptr;
class BOOST_TEST_DECL collector : public singleton<collector> {
public:
collector& operator*( base const& d );
void store_in( test_unit& tu );
void reset();
private:
BOOST_TEST_SINGLETON_CONS( collector )
// Data members
std::vector<base_ptr> m_tu_decorators;
};
// ************************************************************************** //
// ************** decorator::base ************** //
// ************************************************************************** //
class BOOST_TEST_DECL base {
public:
// composition interface
collector& operator*() const;
// application interface
virtual void apply( test_unit& tu ) = 0;
// deep cloning interface
virtual base_ptr clone() const = 0;
protected:
virtual ~base() {}
};
// ************************************************************************** //
// ************** decorator::label ************** //
// ************************************************************************** //
class BOOST_TEST_DECL label : public decorator::base {
public:
explicit label( const_string l ) : m_label( l ) {}
private:
// decorator::base interface
virtual void apply( test_unit& tu );
virtual base_ptr clone() const { return base_ptr(new label( m_label )); }
// Data members
const_string m_label;
};
// ************************************************************************** //
// ************** decorator::expected_failures ************** //
// ************************************************************************** //
class BOOST_TEST_DECL expected_failures : public decorator::base {
public:
explicit expected_failures( counter_t ef ) : m_exp_fail( ef ) {}
private:
// decorator::base interface
virtual void apply( test_unit& tu );
virtual base_ptr clone() const { return base_ptr(new expected_failures( m_exp_fail )); }
// Data members
counter_t m_exp_fail;
};
// ************************************************************************** //
// ************** decorator::timeout ************** //
// ************************************************************************** //
class BOOST_TEST_DECL timeout : public decorator::base {
public:
explicit timeout( unsigned t ) : m_timeout( t ) {}
private:
// decorator::base interface
virtual void apply( test_unit& tu );
virtual base_ptr clone() const { return base_ptr(new timeout( m_timeout )); }
// Data members
unsigned m_timeout;
};
// ************************************************************************** //
// ************** decorator::description ************** //
// ************************************************************************** //
class BOOST_TEST_DECL description : public decorator::base {
public:
explicit description( const_string descr ) : m_description( descr ) {}
private:
// decorator::base interface
virtual void apply( test_unit& tu );
virtual base_ptr clone() const { return base_ptr(new description( m_description )); }
// Data members
const_string m_description;
};
// ************************************************************************** //
// ************** decorator::depends_on ************** //
// ************************************************************************** //
class BOOST_TEST_DECL depends_on : public decorator::base {
public:
explicit depends_on( const_string dependency ) : m_dependency( dependency ) {}
private:
// decorator::base interface
virtual void apply( test_unit& tu );
virtual base_ptr clone() const { return base_ptr(new depends_on( m_dependency )); }
// Data members
const_string m_dependency;
};
// ************************************************************************** //
// ************** decorator::enable_if/enabled/disabled ************** //
// ************************************************************************** //
class BOOST_TEST_DECL enable_if_impl : public decorator::base {
protected:
void apply_impl( test_unit& tu, bool condition );
};
template<bool condition>
class enable_if : public enable_if_impl {
private:
// decorator::base interface
virtual void apply( test_unit& tu ) { this->apply_impl( tu, condition ); }
virtual base_ptr clone() const { return base_ptr(new enable_if<condition>()); }
};
typedef enable_if<true> enabled;
typedef enable_if<false> disabled;
// ************************************************************************** //
// ************** decorator::fixture ************** //
// ************************************************************************** //
class BOOST_TEST_DECL fixture_t : public decorator::base {
public:
// Constructor
explicit fixture_t( test_unit_fixture_ptr impl ) : m_impl( impl ) {}
private:
// decorator::base interface
virtual void apply( test_unit& tu );
virtual base_ptr clone() const { return base_ptr(new fixture_t( m_impl )); }
// Data members
test_unit_fixture_ptr m_impl;
};
//____________________________________________________________________________//
template<typename F>
inline fixture_t
fixture()
{
return fixture_t( test_unit_fixture_ptr( new unit_test::class_based_fixture<F>() ) );
}
//____________________________________________________________________________//
template<typename F, typename Arg>
inline fixture_t
fixture( Arg const& arg )
{
return fixture_t( test_unit_fixture_ptr( new unit_test::class_based_fixture<F,Arg>( arg ) ) );
}
//____________________________________________________________________________//
inline fixture_t
fixture( boost::function<void()> const& setup, boost::function<void()> const& teardown = boost::function<void()>() )
{
return fixture_t( test_unit_fixture_ptr( new unit_test::function_based_fixture( setup, teardown ) ) );
}
//____________________________________________________________________________//
// ************************************************************************** //
// ************** decorator::depends_on ************** //
// ************************************************************************** //
class BOOST_TEST_DECL precondition : public decorator::base {
public:
typedef boost::function<test_tools::assertion_result (test_unit_id)> predicate_t;
explicit precondition( predicate_t p ) : m_precondition( p ) {}
private:
// decorator::base interface
virtual void apply( test_unit& tu );
virtual base_ptr clone() const { return base_ptr(new precondition( m_precondition )); }
// Data members
predicate_t m_precondition;
};
} // namespace decorator
using decorator::label;
using decorator::expected_failures;
using decorator::timeout;
using decorator::description;
using decorator::depends_on;
using decorator::enable_if;
using decorator::enabled;
using decorator::disabled;
using decorator::fixture;
using decorator::precondition;
} // namespace unit_test
} // namespace boost
#include <boost/test/detail/enable_warnings.hpp>
#endif // BOOST_TEST_TREE_DECORATOR_HPP_091911GER

116
thirdparty/source/boost_1_61_0/boost/test/tree/fixture.hpp vendored Normal file
View File

@@ -0,0 +1,116 @@
// (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 : $RCSfile$
//
// Version : $Revision: 74640 $
//
// Description : defines fixture interface and object makers
// ***************************************************************************
#ifndef BOOST_TEST_TREE_FIXTURE_HPP_100311GER
#define BOOST_TEST_TREE_FIXTURE_HPP_100311GER
// Boost.Test
#include <boost/test/detail/config.hpp>
// Boost
#include <boost/shared_ptr.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/function/function0.hpp>
#include <boost/test/detail/suppress_warnings.hpp>
//____________________________________________________________________________//
namespace boost {
namespace unit_test {
// ************************************************************************** //
// ************** test_unit_fixture ************** //
// ************************************************************************** //
class BOOST_TEST_DECL test_unit_fixture {
public:
virtual ~test_unit_fixture() {}
// Fixture interface
virtual void setup() = 0;
virtual void teardown() = 0;
};
typedef shared_ptr<test_unit_fixture> test_unit_fixture_ptr;
// ************************************************************************** //
// ************** class_based_fixture ************** //
// ************************************************************************** //
template<typename F, typename Arg=void>
class class_based_fixture : public test_unit_fixture {
public:
// Constructor
explicit class_based_fixture( Arg const& arg ) : m_inst(), m_arg( arg ) {}
private:
// Fixture interface
virtual void setup() { m_inst.reset( new F( m_arg ) ); }
virtual void teardown() { m_inst.reset(); }
// Data members
scoped_ptr<F> m_inst;
Arg m_arg;
};
//____________________________________________________________________________//
template<typename F>
class class_based_fixture<F,void> : public test_unit_fixture {
public:
// Constructor
class_based_fixture() : m_inst( 0 ) {}
private:
// Fixture interface
virtual void setup() { m_inst.reset( new F ); }
virtual void teardown() { m_inst.reset(); }
// Data members
scoped_ptr<F> m_inst;
};
//____________________________________________________________________________//
// ************************************************************************** //
// ************** function_based_fixture ************** //
// ************************************************************************** //
class function_based_fixture : public test_unit_fixture {
public:
// Constructor
function_based_fixture( boost::function<void ()> const& setup_, boost::function<void ()> const& teardown_ )
: m_setup( setup_ )
, m_teardown( teardown_ )
{
}
private:
// Fixture interface
virtual void setup() { if( m_setup ) m_setup(); }
virtual void teardown() { if( m_teardown ) m_teardown(); }
// Data members
boost::function<void ()> m_setup;
boost::function<void ()> m_teardown;
};
} // namespace unit_test
} // namespace boost
#include <boost/test/detail/enable_warnings.hpp>
#endif // BOOST_TEST_TREE_FIXTURE_HPP_100311GER

68
thirdparty/source/boost_1_61_0/boost/test/tree/global_fixture.hpp vendored Normal file
View File

@@ -0,0 +1,68 @@
// (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 : $RCSfile$
//
// Version : $Revision: 74640 $
//
// Description : defines global_fixture
// ***************************************************************************
#ifndef BOOST_TEST_TREE_GLOBAL_FIXTURE_HPP_091911GER
#define BOOST_TEST_TREE_GLOBAL_FIXTURE_HPP_091911GER
// Boost.Test
#include <boost/test/detail/config.hpp>
#include <boost/test/detail/global_typedef.hpp>
#include <boost/test/tree/observer.hpp>
#include <boost/test/detail/suppress_warnings.hpp>
//____________________________________________________________________________//
namespace boost {
namespace unit_test {
// ************************************************************************** //
// ************** global_fixture ************** //
// ************************************************************************** //
class BOOST_TEST_DECL global_fixture : public test_observer {
public:
// Constructor
global_fixture();
};
//____________________________________________________________________________//
namespace ut_detail {
template<typename F>
struct global_fixture_impl : public global_fixture {
// Constructor
global_fixture_impl() : m_fixture( 0 ) {}
// test observer interface
virtual void test_start( counter_t ) { m_fixture = new F; }
virtual void test_finish() { delete m_fixture; m_fixture = 0; }
virtual void test_aborted() { delete m_fixture; m_fixture = 0; }
private:
// Data members
F* m_fixture;
};
} // namespace ut_detail
} // namespace unit_test
} // namespace boost
#include <boost/test/detail/enable_warnings.hpp>
#endif // BOOST_TEST_TREE_GLOBAL_FIXTURE_HPP_091911GER

70
thirdparty/source/boost_1_61_0/boost/test/tree/observer.hpp vendored Normal file
View File

@@ -0,0 +1,70 @@
// (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
//!@brief defines abstract interface for test observer
// ***************************************************************************
#ifndef BOOST_TEST_TEST_OBSERVER_HPP_021005GER
#define BOOST_TEST_TEST_OBSERVER_HPP_021005GER
// Boost.Test
#include <boost/test/detail/fwd_decl.hpp>
#include <boost/test/detail/global_typedef.hpp>
#include <boost/test/detail/config.hpp>
#include <boost/test/detail/suppress_warnings.hpp>
//____________________________________________________________________________//
namespace boost {
namespace unit_test {
// ************************************************************************** //
// ************** test_observer ************** //
// ************************************************************************** //
class BOOST_TEST_DECL test_observer {
public:
// test observer interface
virtual void test_start( counter_t /* test_cases_amount */ ) {}
virtual void test_finish() {}
virtual void test_aborted() {}
virtual void test_unit_start( test_unit const& ) {}
virtual void test_unit_finish( test_unit const&, unsigned long /* elapsed */ ) {}
virtual void test_unit_skipped( test_unit const& tu, const_string ) { test_unit_skipped( tu ); }
virtual void test_unit_skipped( test_unit const& ) {} ///< backward compatibility
virtual void test_unit_aborted( test_unit const& ) {}
virtual void assertion_result( unit_test::assertion_result ar )
{
switch( ar ) {
case AR_PASSED: assertion_result( true ); break;
case AR_FAILED: assertion_result( false ); break;
case AR_TRIGGERED: break;
default: break;
}
}
virtual void exception_caught( execution_exception const& ) {}
virtual int priority() { return 0; }
protected:
// depracated now
virtual void assertion_result( bool /* passed */ ) {}
BOOST_TEST_PROTECTED_VIRTUAL ~test_observer() {}
};
} // namespace unit_test
} // namespace boost
#include <boost/test/detail/enable_warnings.hpp>
#endif // BOOST_TEST_TEST_OBSERVER_HPP_021005GER

54
thirdparty/source/boost_1_61_0/boost/test/tree/test_case_counter.hpp vendored Normal file
View File

@@ -0,0 +1,54 @@
// (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 : $RCSfile$
//
// Version : $Revision: 74640 $
//
// Description : defines test_case_counter
// ***************************************************************************
#ifndef BOOST_TEST_TREE_TEST_CASE_COUNTER_HPP_100211GER
#define BOOST_TEST_TREE_TEST_CASE_COUNTER_HPP_100211GER
// Boost.Test
#include <boost/test/detail/config.hpp>
#include <boost/test/utils/class_properties.hpp>
#include <boost/test/tree/test_unit.hpp>
#include <boost/test/tree/visitor.hpp>
#include <boost/test/detail/suppress_warnings.hpp>
//____________________________________________________________________________//
namespace boost {
namespace unit_test {
// ************************************************************************** //
// ************** test_case_counter ************** //
// ************************************************************************** //
class test_case_counter : public test_tree_visitor {
public:
// Constructor
test_case_counter() : p_count( 0 ) {}
BOOST_READONLY_PROPERTY( counter_t, (test_case_counter)) p_count;
private:
// test tree visitor interface
virtual void visit( test_case const& tc ) { if( tc.is_enabled() ) ++p_count.value; }
virtual bool test_suite_start( test_suite const& ts ) { return ts.is_enabled(); }
};
} // namespace unit_test
} // namespace boost
#include <boost/test/detail/enable_warnings.hpp>
#endif // BOOST_TEST_TREE_TEST_CASE_COUNTER_HPP_100211GER

144
thirdparty/source/boost_1_61_0/boost/test/tree/test_case_template.hpp vendored Normal file
View File

@@ -0,0 +1,144 @@
// (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 : $RCSfile$
//
// Version : $Revision: -1 $
//
// Description : defines template_test_case_gen
// ***************************************************************************
#ifndef BOOST_TEST_TREE_TEST_CASE_TEMPLATE_HPP_091911GER
#define BOOST_TEST_TREE_TEST_CASE_TEMPLATE_HPP_091911GER
// Boost.Test
#include <boost/test/detail/config.hpp>
#include <boost/test/detail/global_typedef.hpp>
#include <boost/test/detail/fwd_decl.hpp>
#include <boost/test/detail/workaround.hpp>
#include <boost/test/utils/class_properties.hpp>
#include <boost/test/tree/observer.hpp>
// Boost
#include <boost/shared_ptr.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/type.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/function/function0.hpp>
#ifndef BOOST_NO_RTTI
#include <typeinfo> // for typeid
#else
#include <boost/current_function.hpp>
#endif
// STL
#include <string> // for std::string
#include <list> // for std::list
#include <boost/test/detail/suppress_warnings.hpp>
//____________________________________________________________________________//
namespace boost {
namespace unit_test {
namespace ut_detail {
// ************************************************************************** //
// ************** test_case_template_invoker ************** //
// ************************************************************************** //
template<typename TestCaseTemplate,typename TestType>
class test_case_template_invoker {
public:
void operator()() { TestCaseTemplate::run( (boost::type<TestType>*)0 ); }
};
// ************************************************************************** //
// ************** generate_test_case_4_type ************** //
// ************************************************************************** //
template<typename Generator,typename TestCaseTemplate>
struct generate_test_case_4_type {
explicit generate_test_case_4_type( const_string tc_name, const_string tc_file, std::size_t tc_line, Generator& G )
: m_test_case_name( tc_name )
, m_test_case_file( tc_file )
, m_test_case_line( tc_line )
, m_holder( G )
{}
template<typename TestType>
void operator()( mpl::identity<TestType> )
{
std::string full_name;
assign_op( full_name, m_test_case_name, 0 );
full_name += '<';
#ifndef BOOST_NO_RTTI
full_name += typeid(TestType).name();
#else
full_name += BOOST_CURRENT_FUNCTION;
#endif
if( boost::is_const<TestType>::value )
full_name += "_const";
full_name += '>';
m_holder.m_test_cases.push_back( new test_case( ut_detail::normalize_test_case_name( full_name ),
m_test_case_file,
m_test_case_line,
test_case_template_invoker<TestCaseTemplate,TestType>() ) );
}
private:
// Data members
const_string m_test_case_name;
const_string m_test_case_file;
std::size_t m_test_case_line;
Generator& m_holder;
};
// ************************************************************************** //
// ************** test_case_template ************** //
// ************************************************************************** //
template<typename TestCaseTemplate,typename TestTypesList>
class template_test_case_gen : public test_unit_generator {
public:
// Constructor
template_test_case_gen( const_string tc_name, const_string tc_file, std::size_t tc_line )
{
typedef generate_test_case_4_type<template_test_case_gen<TestCaseTemplate,TestTypesList>,TestCaseTemplate> single_test_gen;
mpl::for_each<TestTypesList,mpl::make_identity<mpl::_> >( single_test_gen( tc_name, tc_file, tc_line, *this ) );
}
virtual test_unit* next() const
{
if( m_test_cases.empty() )
return 0;
test_unit* res = m_test_cases.front();
m_test_cases.pop_front();
return res;
}
// Data members
mutable std::list<test_unit*> m_test_cases;
};
} // namespace ut_detail
} // unit_test
} // namespace boost
#include <boost/test/detail/enable_warnings.hpp>
#endif // BOOST_TEST_TREE_TEST_CASE_TEMPLATE_HPP_091911GER

275
thirdparty/source/boost_1_61_0/boost/test/tree/test_unit.hpp vendored Normal file
View File

@@ -0,0 +1,275 @@
// (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
/// Defines @ref boost::unit_test::test_unit "test_unit", @ref boost::unit_test::test_case "test_case",
/// @ref boost::unit_test::test_suite "test_suite" and @ref boost::unit_test::master_test_suite_t "master_test_suite_t"
// ***************************************************************************
#ifndef BOOST_TEST_TREE_TEST_UNIT_HPP_100211GER
#define BOOST_TEST_TREE_TEST_UNIT_HPP_100211GER
// Boost.Test
#include <boost/test/detail/config.hpp>
#include <boost/test/detail/global_typedef.hpp>
#include <boost/test/detail/fwd_decl.hpp>
#include <boost/test/tree/decorator.hpp>
#include <boost/test/tree/fixture.hpp>
#include <boost/test/tools/assertion_result.hpp>
#include <boost/test/utils/class_properties.hpp>
// Boost
#include <boost/function/function0.hpp>
#include <boost/function/function1.hpp>
// STL
#include <vector>
#include <string>
#include <map>
#include <boost/test/detail/suppress_warnings.hpp>
//____________________________________________________________________________//
namespace boost {
namespace unit_test {
namespace framework {
class state;
}
// ************************************************************************** //
// ************** test_unit ************** //
// ************************************************************************** //
typedef std::vector<test_unit_id> test_unit_id_list;
class BOOST_TEST_DECL test_unit {
public:
enum { type = TUT_ANY };
enum run_status { RS_DISABLED, RS_ENABLED, RS_INHERIT, RS_INVALID };
typedef std::vector<test_unit_id> id_list;
typedef std::vector<test_unit_fixture_ptr> fixture_list_t;
typedef BOOST_READONLY_PROPERTY(test_unit_id,(framework::state)) id_t;
typedef BOOST_READONLY_PROPERTY(test_unit_id,(test_suite)) parent_id_t;
typedef BOOST_READONLY_PROPERTY(id_list,(test_unit)) id_list_t;
typedef std::vector<decorator::base_ptr> decor_list_t;
typedef BOOST_READONLY_PROPERTY(std::vector<std::string>,(test_unit)) label_list_t;
typedef boost::function<test_tools::assertion_result (test_unit_id)> precondition_t;
typedef BOOST_READONLY_PROPERTY(std::vector<precondition_t>,(test_unit)) precond_list_t;
// preconditions management
void depends_on( test_unit* tu );
void add_precondition( precondition_t const& );
test_tools::assertion_result check_preconditions() const;
// labels management
void add_label( const_string l );
bool has_label( const_string l ) const;
// helper access methods
void increase_exp_fail( counter_t num );
bool is_enabled() const { return p_run_status == RS_ENABLED; }
std::string full_name() const;
// Public r/o properties
test_unit_type const p_type; ///< type for this test unit
const_string const p_type_name; ///< "case"/"suite"/"module"
const_string const p_file_name;
std::size_t const p_line_num;
id_t p_id; ///< unique id for this test unit
parent_id_t p_parent_id; ///< parent test suite id
label_list_t p_labels; ///< list of labels associated with this test unit
id_list_t p_dependencies; ///< list of test units this one depends on
precond_list_t p_preconditions; ///< user supplied preconditions for this test unit;
// Public r/w properties
readwrite_property<std::string> p_name; ///< name for this test unit
readwrite_property<std::string> p_description; ///< description for this test unit
readwrite_property<unsigned> p_timeout; ///< timeout for the test unit execution in seconds
readwrite_property<counter_t> p_expected_failures; ///< number of expected failures in this test unit
readwrite_property<run_status> p_default_status; ///< run status obtained by this unit during setup phase
readwrite_property<run_status> p_run_status; ///< run status assigned to this unit before execution phase after applying all filters
readwrite_property<counter_t> p_sibling_rank; ///< rank of this test unit amoung siblings of the same parent
readwrite_property<decor_list_t> p_decorators; ///< automatically assigned decorators; execution is delayed till framework::finalize_setup_phase function
readwrite_property<fixture_list_t> p_fixtures; ///< fixtures associated with this test unit
protected:
~test_unit();
// Constructor
test_unit( const_string tu_name, const_string tc_file, std::size_t tc_line, test_unit_type t );
// Master test suite constructor
explicit test_unit( const_string module_name );
private:
};
// ************************************************************************** //
// ************** test_unit_generator ************** //
// ************************************************************************** //
class BOOST_TEST_DECL test_unit_generator {
public:
virtual test_unit* next() const = 0;
protected:
BOOST_TEST_PROTECTED_VIRTUAL ~test_unit_generator() {}
};
// ************************************************************************** //
// ************** test_case ************** //
// ************************************************************************** //
class BOOST_TEST_DECL test_case : public test_unit {
public:
enum { type = TUT_CASE };
// Constructor
test_case( const_string tc_name, boost::function<void ()> const& test_func );
test_case( const_string tc_name, const_string tc_file, std::size_t tc_line, boost::function<void ()> const& test_func );
// Public property
typedef BOOST_READONLY_PROPERTY(boost::function<void ()>,(test_case)) test_func;
test_func p_test_func;
private:
friend class framework::state;
~test_case() {}
};
// ************************************************************************** //
// ************** test_suite ************** //
// ************************************************************************** //
//! Class representing test suites
class BOOST_TEST_DECL test_suite : public test_unit {
public:
enum { type = TUT_SUITE };
// Constructor
explicit test_suite( const_string ts_name, const_string ts_file, std::size_t ts_line );
// test unit list management
/*!@brief Adds a test unit to a test suite.
*
* It is possible to specify the timeout and the expected failures.
*/
void add( test_unit* tu, counter_t expected_failures = 0, unsigned timeout = 0 );
/// @overload
void add( test_unit_generator const& gen, unsigned timeout = 0 );
/// @overload
void add( test_unit_generator const& gen, decorator::collector& decorators );
//! Removes a test from the test suite.
void remove( test_unit_id id );
// access methods
test_unit_id get( const_string tu_name ) const;
std::size_t size() const { return m_children.size(); }
protected:
// Master test suite constructor
explicit test_suite( const_string module_name );
friend BOOST_TEST_DECL
void traverse_test_tree( test_suite const&, test_tree_visitor&, bool );
friend class framework::state;
virtual ~test_suite() {}
typedef std::multimap<counter_t,test_unit_id> children_per_rank;
// Data members
test_unit_id_list m_children;
children_per_rank m_ranked_children; ///< maps child sibling rank to list of children with that rank
};
// ************************************************************************** //
// ************** master_test_suite ************** //
// ************************************************************************** //
class BOOST_TEST_DECL master_test_suite_t : public test_suite {
public:
master_test_suite_t();
// Data members
int argc;
char** argv;
};
// ************************************************************************** //
// ************** user_tc_method_invoker ************** //
// ************************************************************************** //
namespace ut_detail {
BOOST_TEST_DECL std::string normalize_test_case_name( const_string tu_name );
//____________________________________________________________________________//
template<typename InstanceType,typename UserTestCase>
struct user_tc_method_invoker {
typedef void (UserTestCase::*TestMethod )();
user_tc_method_invoker( shared_ptr<InstanceType> inst, TestMethod test_method )
: m_inst( inst ), m_test_method( test_method ) {}
void operator()() { ((*m_inst).*m_test_method)(); }
shared_ptr<InstanceType> m_inst;
TestMethod m_test_method;
};
} // namespace ut_detail
// ************************************************************************** //
// ************** make_test_case ************** //
// ************************************************************************** //
inline test_case*
make_test_case( boost::function<void ()> const& test_func, const_string tc_name, const_string tc_file, std::size_t tc_line )
{
return new test_case( ut_detail::normalize_test_case_name( tc_name ), tc_file, tc_line, test_func );
}
//____________________________________________________________________________//
template<typename UserTestCase, typename InstanceType>
inline test_case*
make_test_case( void (UserTestCase::* test_method )(),
const_string tc_name,
const_string tc_file,
std::size_t tc_line,
boost::shared_ptr<InstanceType> user_test_case )
{
return new test_case( ut_detail::normalize_test_case_name( tc_name ),
tc_file,
tc_line,
ut_detail::user_tc_method_invoker<InstanceType,UserTestCase>( user_test_case, test_method ) );
}
//____________________________________________________________________________//
} // namespace unit_test
} // namespace boost
#include <boost/test/detail/enable_warnings.hpp>
#endif // BOOST_TEST_TREE_TEST_UNIT_HPP_100211GER

58
thirdparty/source/boost_1_61_0/boost/test/tree/traverse.hpp vendored Normal file
View File

@@ -0,0 +1,58 @@
// (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 : $RCSfile$
//
// Version : $Revision: -1 $
//
// Description : defines traverse_test_tree algorithm
// ***************************************************************************
#ifndef BOOST_TEST_TREE_TRAVERSE_HPP_100211GER
#define BOOST_TEST_TREE_TRAVERSE_HPP_100211GER
// Boost.Test
#include <boost/test/detail/config.hpp>
#include <boost/test/tree/test_unit.hpp>
#include <boost/test/tree/visitor.hpp>
#include <boost/test/detail/suppress_warnings.hpp>
//____________________________________________________________________________//
namespace boost {
namespace unit_test {
// ************************************************************************** //
// ************** traverse_test_tree ************** //
// ************************************************************************** //
BOOST_TEST_DECL void traverse_test_tree( test_case const&, test_tree_visitor&, bool ignore_status = false );
BOOST_TEST_DECL void traverse_test_tree( test_suite const&, test_tree_visitor&, bool ignore_status = false );
BOOST_TEST_DECL void traverse_test_tree( test_unit_id , test_tree_visitor&, bool ignore_status = false );
//____________________________________________________________________________//
inline void
traverse_test_tree( test_unit const& tu, test_tree_visitor& V, bool ignore_status = false )
{
if( tu.p_type == TUT_CASE )
traverse_test_tree( static_cast<test_case const&>( tu ), V, ignore_status );
else
traverse_test_tree( static_cast<test_suite const&>( tu ), V, ignore_status );
}
//____________________________________________________________________________//
} // namespace unit_test
} // namespace boost
#include <boost/test/detail/enable_warnings.hpp>
#endif // BOOST_TEST_TREE_TRAVERSE_HPP_100211GER

52
thirdparty/source/boost_1_61_0/boost/test/tree/visitor.hpp vendored Normal file
View File

@@ -0,0 +1,52 @@
// (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 : $RCSfile$
//
// Version : $Revision: -1 $
//
// Description : defines test_tree_visitor
// ***************************************************************************
#ifndef BOOST_TEST_TREE_VISITOR_HPP_100211GER
#define BOOST_TEST_TREE_VISITOR_HPP_100211GER
// Boost.Test
#include <boost/test/detail/config.hpp>
#include <boost/test/tree/test_unit.hpp>
#include <boost/test/detail/suppress_warnings.hpp>
//____________________________________________________________________________//
namespace boost {
namespace unit_test {
// ************************************************************************** //
// ************** test_tree_visitor ************** //
// ************************************************************************** //
class BOOST_TEST_DECL test_tree_visitor {
public:
// test tree visitor interface
virtual bool visit( test_unit const& ) { return true; }
virtual void visit( test_case const& tc ) { visit( (test_unit const&)tc ); }
virtual bool test_suite_start( test_suite const& ts ){ return visit( (test_unit const&)ts ); }
virtual void test_suite_finish( test_suite const& ) {}
protected:
BOOST_TEST_PROTECTED_VIRTUAL ~test_tree_visitor() {}
};
} // namespace unit_test
} // namespace boost
#include <boost/test/detail/enable_warnings.hpp>
#endif // BOOST_TEST_TREE_VISITOR_HPP_100211GER