diff options
Diffstat (limited to 'src/boost/libs/ptr_container/test/test_data.hpp')
| -rw-r--r-- | src/boost/libs/ptr_container/test/test_data.hpp | 337 |
1 files changed, 337 insertions, 0 deletions
diff --git a/src/boost/libs/ptr_container/test/test_data.hpp b/src/boost/libs/ptr_container/test/test_data.hpp new file mode 100644 index 00000000..31683602 --- /dev/null +++ b/src/boost/libs/ptr_container/test/test_data.hpp @@ -0,0 +1,337 @@ +// +// Boost.Pointer Container +// +// Copyright Thorsten Ottosen 2003-2005. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/ptr_container/ +// + +#include <boost/static_assert.hpp> +#include <boost/type_traits.hpp> +#include <boost/config.hpp> +#include <boost/test/unit_test.hpp> +#include <boost/lexical_cast.hpp> +#include <boost/functional/hash.hpp> +#include <algorithm> +#include <iostream> +#include <string> +#include <utility> +#include <cstdlib> + +using namespace std; +using namespace boost; + +////////////////////////////////////////////////////////////////////////////// +// Test class 1: a class hierarchy +////////////////////////////////////////////////////////////////////////////// + +namespace test +{ + class Base + { + protected: + Base( const Base& r ) : data1(r.data1), data2(r.data2), + data3(r.data3), data(r.data) + { + #ifdef PTR_CONTAINER_DEBUG + objects++; + std::cout <<"+ " << objects << "\n"; + #endif + } + + Base& operator=( const Base& ); + + public: // for test reasons only + int data1, data2, data3; + string data; + + public: + + Base() : data1(1), data2(2), data3(rand()%256), + data(lexical_cast<string>(rand())) + { + #ifdef PTR_CONTAINER_DEBUG + objects++; + std::cout <<"+ " << objects << "\n"; + #endif + } + + virtual ~Base() + { + #ifdef PTR_CONTAINER_DEBUG + objects--; + std::cout <<"- " << objects << "\n"; + if( objects < 0 ) + terminate(); + #endif + } + + void print( ostream& out ) const { do_print( out); } + Base* clone() const { return do_clone(); } + void foo() { do_foo(); } + + virtual bool less_than( const Base& b ) const + { + return data3 < b.data3; + } + + virtual bool equal( const Base& b ) const + { + return data1 == b.data1 && + data2 == b.data2 && + data3 == b.data3 && + data == b.data; + } + + #ifdef PTR_CONTAINER_DEBUG + static int objects; + #endif + + private: + virtual void do_print( ostream& /*out*/ ) const { }; + virtual Base* do_clone() const { return new Base( *this ); }; + virtual void do_foo() { }; + }; + + #ifdef PTR_CONTAINER_DEBUG + int Base::objects = 0; + #endif + + + + ostream& operator<<( ostream& out, const Base& b ) + { + b.print( out ); + return out; + } + + + // + // We rely on argument dependent lookup + // for this to be found + // + inline Base* new_clone( const Base& b ) + { + return b.clone(); + } + + + + inline bool operator<( const Base& l, const Base& r ) + { + return l.less_than( r ); + } + + + + inline bool operator>( const Base& l, const Base& r ) + { + return r < l; + } + + + + inline bool operator==( const Base& l, const Base& r ) + { + return l.equal( r ); + } + + + + inline bool operator!=( const Base& l, const Base& r ) + { + return !l.equal( r ); + } + + + + inline std::size_t hash_value( const Base& b ) + { + std::size_t seed = 0; + boost::hash_combine( seed, b.data ); + boost::hash_combine( seed, b.data1 ); + boost::hash_combine( seed, b.data2 ); + boost::hash_combine( seed, b.data3 ); + return seed; + } + + + class Derived_class : public Base + { + protected: + Derived_class( const Derived_class& r ) : Base( r ), i_(r.i_) + { } + + public: // for test reasons only + int i_; + + private: + + virtual void do_print( ostream& out ) const + { + out << i_; + } + + + virtual Base* do_clone() const + { + return new Derived_class( *this ); + } + + virtual void do_foo() + { + ++i_; + } + + public: + Derived_class() : i_( rand() ) + { } + + virtual bool less_than( const Base& b ) const + { + const Derived_class& d = dynamic_cast<const Derived_class&>( b ); + return i_ < d.i_; + } + }; + + + + inline std::size_t hash_value( const Derived_class& b ) + { + std::size_t seed = hash_value( static_cast<const Base&>( b ) ); + boost::hash_combine( seed, b.i_ ); + return seed; + } +} + +using test::Base; +using test::Derived_class; + +////////////////////////////////////////////////////////////////////////////// +// Test class 2: a value class +////////////////////////////////////////////////////////////////////////////// + +class Value +{ +public: // for test reasons only + string s_; + +public: + + Value() : s_( boost::lexical_cast<string>( rand() ) ) + {} + + ~Value() { /** debug code here */ } + + string name() const + { + return s_; + } +}; + + + +inline bool operator<( const Value& l, const Value& r ) +{ + return l.name() < r.name(); +} + + + +inline bool operator>( const Value& l, const Value& r ) +{ + return l.name() > r.name(); +} + + + +inline bool operator==( const Value& l, const Value& r ) +{ + return l.name() == r.name(); +} + + + +inline bool operator!=( const Value& l, const Value& r ) +{ + return l.name() != r.name(); +} + + + +inline ostream& operator<<( ostream& out, const Value& v ) +{ + return out << v.name() << " "; +} + + + +inline std::size_t hash_value( const Value& v ) +{ + return boost::hash_value( v.s_ ); +} + +// +// used to hide "unused variable" warnings +// +template< class T > +inline void hide_warning( T& /*r*/ ) +{ } + +// +// used to customize tests for circular_buffer +// +template< class Cont > +struct set_capacity +{ + void operator()( Cont& ) const + { } +}; + +// +// transfer() test +// + +template< class Cont1, class Cont2 > +void transfer_test( Cont1& from, Cont2& to ) +{ + BOOST_TEST_MESSAGE( "starting container transfer test" ); + BOOST_CHECK( !from.empty() ); + to. BOOST_NESTED_TEMPLATE transfer<Cont1>( from ); + BOOST_CHECK( !to.empty() ); + BOOST_TEST_MESSAGE( "finishing container transfer test" ); +} + + +// +// test of copy operations +// + +template< class BaseContainer, class DerivedContainer, class Derived > +void container_assignment_test() +{ + BOOST_TEST_MESSAGE( "starting container assignment test" ); + + DerivedContainer derived; + set_capacity<DerivedContainer>()( derived ); + derived.insert( derived.begin(), new Derived ); + derived.insert( derived.begin(), new Derived ); + + BaseContainer base( derived ); + BOOST_CHECK_EQUAL( derived.size(), base.size() ); + base.clear(); + base = derived; + BOOST_CHECK_EQUAL( derived.size(), base.size() ); + BaseContainer base2( base ); + BOOST_CHECK_EQUAL( base2.size(), base.size() ); + base2 = base; + BOOST_CHECK_EQUAL( base2.size(), base.size() ); + base = base; + + BOOST_TEST_MESSAGE( "finished container assignment test" ); +} + + |