//

 // 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/test/unit_test.hpp>

 #include <boost/archive/text_oarchive.hpp>

 #include <boost/archive/text_iarchive.hpp>

 #include <boost/ptr_container/ptr_vector.hpp>

 #include <boost/ptr_container/ptr_deque.hpp>

 #include <boost/ptr_container/ptr_list.hpp>

 #include <boost/ptr_container/ptr_array.hpp>

 #include <boost/ptr_container/ptr_set.hpp>

 #include <boost/ptr_container/ptr_map.hpp>

 #include <boost/serialization/export.hpp>

 #include <boost/serialization/base_object.hpp>

 #include <boost/serialization/utility.hpp>

 #include <boost/serialization/string.hpp>

 #include <fstream>

 #include <string>

 //

 // serialization helper: we can't save a non-const object

 // 

 template< class T >

 inline T const& as_const( T const& r )

 {

     return r;

 }

 //

 // class hierarchy

 // 

 struct Base

 {

     friend class boost::serialization::access;

     int i;

     template< class Archive >

     void serialize( Archive& ar, const unsigned int version )

     {

         ar & i;

     }

     Base() : i(42)

     { }

     Base( int i ) : i(i)

     { }

     virtual ~Base()

     { }

 };

 inline bool operator<( const Base& l, const Base& r )

 {

     return l.i < r.i;

 }

 struct Derived : Base

 {

     int i2;

     template< class Archive >

     void serialize( Archive& ar, const unsigned int version )

     {

         ar & boost::serialization::base_object<Base>( *this );

         ar & i2;

     }

     Derived() : Base(42), i2(42)

     { }

     explicit Derived( int i2 ) : Base(0), i2(i2)

     { }

 };

 BOOST_CLASS_EXPORT_GUID( Derived, "Derived" )

 //

 // test of containers

 // 

 // 

 template< class C, class T >

 void add( C& c, T* r, unsigned n )

 {

     c.insert( c.end(), r ); 

 }

 template< class U, class T >

 void add( boost::ptr_array<U,2>& c, T* r, unsigned n )

 {

     c.replace( n, r );

 }

 template< class Cont >

 void test_serialization_helper()

 {

     Cont vec;

     add( vec, new Base( -1 ), 0u );

     add( vec, new Derived( 1 ), 1u );

     std::ofstream ofs("filename");

     boost::archive::text_oarchive oa(ofs);

     oa << as_const(vec);

     ofs.close();

     std::ifstream ifs("filename", std::ios::binary);

     boost::archive::text_iarchive ia(ifs);

     Cont vec2;

     ia >> vec2;

     ifs.close();

     BOOST_CHECK_EQUAL( vec.size(), vec2.size() );

     BOOST_CHECK_EQUAL( (*vec2.begin()).i, -1 );

     BOOST_CHECK_EQUAL( (*--vec2.end()).i, 0 );

     typename Cont::iterator i = vec2.end();

     --i;

     Derived* d = dynamic_cast<Derived*>( &*i ); 

     BOOST_CHECK_EQUAL( d->i2, 1 );

 }

 template< class Map >

 void test_serialization_map_helper()

 {

     Map m;

     std::string key1("key1"), key2("key2");

     m.insert( key1, new Base( -1 ) );

     m.insert( key2, new Derived( 1 ) );

     BOOST_CHECK_EQUAL( m.size(), 2u );

     std::ofstream ofs("filename");

     boost::archive::text_oarchive oa(ofs);

     oa << as_const(m);

     ofs.close();

     std::ifstream ifs("filename", std::ios::binary);

     boost::archive::text_iarchive ia(ifs);

     Map m2;

     ia >> m2;

     ifs.close();

     BOOST_CHECK_EQUAL( m.size(), m2.size() );

     BOOST_CHECK_EQUAL( m2.find(key1)->second->i, -1 );

     BOOST_CHECK_EQUAL( m2.find(key2)->second->i, 0 );

     typename Map::iterator i = m2.find(key2);

     Derived* d = dynamic_cast<Derived*>( i->second ); 

     BOOST_CHECK_EQUAL( d->i2, 1 );

 }

 //

 // basic test of hierarchy

 // 

 void test_hierarchy()

 {

     Base* p = new Derived();

     std::ofstream ofs("filename");

     boost::archive::text_oarchive oa(ofs);

     oa << as_const(p);

     ofs.close();

     Base* d = 0; 

     std::ifstream ifs("filename", std::ios::binary);

     boost::archive::text_iarchive ia(ifs);

     ia >> d;

     ifs.close();

     BOOST_CHECK_EQUAL( p->i, d->i );

     BOOST_CHECK( p != d );

     BOOST_CHECK( dynamic_cast<Derived*>( d ) );

     delete p;

     delete d;

 } 

 //

 // test initializer

 // 

 void test_serialization()

 {

     test_hierarchy();

     test_serialization_helper< boost::ptr_deque<Base> >();

     test_serialization_helper< boost::ptr_list<Base> >();

     test_serialization_helper< boost::ptr_vector<Base> >();

     test_serialization_helper< boost::ptr_array<Base,2> >();

     test_serialization_helper< boost::ptr_set<Base> >();

     test_serialization_helper< boost::ptr_multiset<Base> >();

     test_serialization_map_helper< boost::ptr_map<std::string,Base> >();

 //

 // GCC hangs when calling find() on a multimap!

 //      

 //#if !BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0300))

     test_serialization_map_helper< boost::ptr_multimap<std::string,Base> >();

 //#endif

 }

 using boost::unit_test::test_suite;

 test_suite* init_unit_test_suite( int argc, char* argv[] )

 {

     test_suite* test = BOOST_TEST_SUITE( "Pointer Container Test Suite" );

     test->add( BOOST_TEST_CASE( &test_serialization ) );

     return test;

 }