[Boost-commit] svn:boost r46099 - trunk/libs/ptr_container/test

From: nesotto_at_[hidden]
Date: 2008-06-03 18:20:39

Author: nesotto
Date: 2008-06-03 18:20:38 EDT (Tue, 03 Jun 2008)
New Revision: 46099
URL: http://svn.boost.org/trac/boost/changeset/46099

Log:
update
Added:
   trunk/libs/ptr_container/test/ptr_circular_buffer.cpp   (contents, props changed)
   trunk/libs/ptr_container/test/ptr_unordered_map.cpp   (contents, props changed)
   trunk/libs/ptr_container/test/ptr_unordered_set.cpp   (contents, props changed)
Text files modified: 
   trunk/libs/ptr_container/test/Jamfile.v2                |     5 +++++                                   
   trunk/libs/ptr_container/test/associative_test_data.hpp |     1 +                                       
   trunk/libs/ptr_container/test/ptr_map.cpp               |    31 +++++++++++++++++++++++++++++++         
   trunk/libs/ptr_container/test/ptr_map_adapter.cpp       |    37 +++++++++++++++++++++++++------------   
   trunk/libs/ptr_container/test/sequence_test_data.hpp    |     9 +++++++++                               
   5 files changed, 71 insertions(+), 12 deletions(-)

Modified: trunk/libs/ptr_container/test/Jamfile.v2
==============================================================================
--- trunk/libs/ptr_container/test/Jamfile.v2	(original)
+++ trunk/libs/ptr_container/test/Jamfile.v2	2008-06-03 18:20:38 EDT (Tue, 03 Jun 2008)
@@ -24,6 +24,7 @@
     [ sc-test ptr_deque ]
     [ sc-test ptr_set ]  
     [ sc-test ptr_map ]
+    [ sc-test ptr_map_adapter ]
     [ sc-test ptr_array ]
     [ sc-test tree_test ]   
     [ sc-test incomplete_type_test ]
@@ -33,5 +34,9 @@
     [ sc-test indirect_fun ]  
     [ sc-test serialization : /boost/serialization//boost_serialization ]  
     [ sc-test no_exceptions ]    
+    
+    #[ sc-test ptr_unordered_set ]
+    #[ sc-test ptr_unordered_map ]        
+    #[ sc-test ptr_circular_buffer ]    
  
     ;

Modified: trunk/libs/ptr_container/test/associative_test_data.hpp
==============================================================================
--- trunk/libs/ptr_container/test/associative_test_data.hpp	(original)
+++ trunk/libs/ptr_container/test/associative_test_data.hpp	2008-06-03 18:20:38 EDT (Tue, 03 Jun 2008)
@@ -111,6 +111,7 @@
     BOOST_CHECK( c3.empty() == false );
     c.clear();
     unsigned long c3size = c3.size();
+    hide_warning( c3size );
     unsigned long num  = c. BOOST_NESTED_TEMPLATE transfer<C>( c3.begin(), 
                                                                c3.end(), 
                                                                c3 );

Added: trunk/libs/ptr_container/test/ptr_circular_buffer.cpp
==============================================================================
Binary file. No diff available.

Modified: trunk/libs/ptr_container/test/ptr_map.cpp
==============================================================================
--- trunk/libs/ptr_container/test/ptr_map.cpp	(original)
+++ trunk/libs/ptr_container/test/ptr_map.cpp	2008-06-03 18:20:38 EDT (Tue, 03 Jun 2008)
@@ -381,6 +381,36 @@
 
 }
 
+#include <boost/tuple/tuple.hpp>
+#include <boost/iterator/zip_iterator.hpp>
+#include <map>
+#include <boost/ptr_container/ptr_map.hpp>
+
+void test_map_iterators()
+{
+    using boost::zip_iterator;
+    using boost::tuple;
+    using boost::make_tuple;
+    using boost::ptr_map;
+    using std::map;
+
+    //typedef map<int, int> theMapType;
+    /*
+    @remark: the following will not compile
+             because of the proxy (non-reference) returned by operator*()
+             of the ptr_map's iterator type.
+             
+    typedef boost::ptr_map<int, int> theMapType;
+    typedef zip_iterator
+        <tuple<theMapType::iterator, theMapType::iterator> > zipIter;
+    theMapType map1;
+    theMapType map2;
+    zipIter zip(make_tuple(map1.begin(), map2.begin()));
+    */
+}
+
+
+
 using boost::unit_test::test_suite;
 
 test_suite* init_unit_test_suite( int argc, char* argv[] )
@@ -388,6 +418,7 @@
     test_suite* test = BOOST_TEST_SUITE( "Pointer Container Test Suite" );
 
     test->add( BOOST_TEST_CASE( &test_map ) );
+    test->add( BOOST_TEST_CASE( &test_map_iterators ) );
 
     return test;
 }

Modified: trunk/libs/ptr_container/test/ptr_map_adapter.cpp
==============================================================================
--- trunk/libs/ptr_container/test/ptr_map_adapter.cpp	(original)
+++ trunk/libs/ptr_container/test/ptr_map_adapter.cpp	2008-06-03 18:20:38 EDT (Tue, 03 Jun 2008)
@@ -8,25 +8,26 @@
 //
 // For more information, see http://www.boost.org/libs/ptr_container/
 //
- 
+
+#include "test_data.hpp"
 #include <boost/ptr_container/ptr_map.hpp>
 #include <string>
 
 using namespace std;
 
-int test_main( int, char*[] )
+void test_ptr_map_adapter()
 {
-    typedef_test< ptr_map<int, Base>, Derived >();
-    typedef_test< ptr_map<int, Value>, Value >();
+    //typedef_test< ptr_map<int, Base>, Derived >();
+    //typedef_test< ptr_map<int, Value>, Value >();
 
-    associative_container_test< ptr_map<int, Base>, Base, Derived >();
-    associative_container_test< ptr_map<int, Value>, Value, Value >();
+    //associative_container_test< ptr_map<int, Base>, Base, Derived >();
+    //associative_container_test< ptr_map<int, Value>, Value, Value >();
     
-    typedef_test< ptr_multimap<int, Base>, Derived >();
-    typedef_test< ptr_multimap<int, Value>, Value >();
+    //typedef_test< ptr_multimap<int, Base>, Derived >();
+    //typedef_test< ptr_multimap<int, Value>, Value >();
 
-    associative_container_test< ptr_multimap<int, Base>, Base, Derived >();
-    associative_container_test< ptr_multimap<int, Value>, Value, Value >();
+    //associative_container_test< ptr_multimap<int, Base>, Base, Derived >();
+    //associative_container_test< ptr_multimap<int, Value>, Value, Value >();
     
     string joe   = "joe";
     string brian = "brian";
@@ -44,7 +45,19 @@
     catch( const bad_ptr_container_operation& )
     { }
 
-    return 0;
+    ptr_map<string,int> m2;
+    m2.insert( m2.begin(), *m.begin() );
+    BOOST_CHECK( m != m2 );
+    BOOST_CHECK( m2 < m );
+    m2.insert( m2.begin(), joe, new int(5) );
+    BOOST_CHECK( m != m2 );
+    BOOST_CHECK( m2 > m );
+
+    ptr_multimap<string,int> m3;
+    m3.insert( m3.begin(), *m.begin() );
+    BOOST_CHECK( m3.size() == 1u );
+    m3.insert( m3.begin(), brian,  new int(11 ) );
+    BOOST_CHECK( m3.size() == 2u );
 }
 
 
@@ -56,7 +69,7 @@
 {
     test_suite* test = BOOST_TEST_SUITE( "Pointer Container Test Suite" );
 
-    test->add( BOOST_TEST_CASE( &test_container_adapter ) );
+    test->add( BOOST_TEST_CASE( &test_ptr_map_adapter ) );
 
     return test;
 }

Added: trunk/libs/ptr_container/test/ptr_unordered_map.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/ptr_container/test/ptr_unordered_map.cpp	2008-06-03 18:20:38 EDT (Tue, 03 Jun 2008)
@@ -0,0 +1,431 @@
+//
+// 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 "test_data.hpp"
+#include <boost/test/unit_test.hpp>
+#include <boost/ptr_container/exception.hpp>
+#include <boost/range/sub_range.hpp>
+#include <boost/cast.hpp>
+#include <cstdlib>
+#include <iostream>
+#include <memory>
+#include <string>
+
+//
+// abstract base class definition
+// 
+struct abstract_base
+{
+    virtual ~abstract_base() {}
+    virtual void foo() = 0;
+    virtual abstract_base* clone() const = 0;
+};
+
+struct implementation : abstract_base
+{
+    implementation()
+    { }
+
+    implementation( const implementation& )
+    { }
+    
+    implementation( int, std::string, int, std::string )
+    { }
+
+    virtual void foo() {}
+    virtual abstract_base* clone() const
+    {
+        return new implementation( *this );
+    }
+};
+
+inline std::ostream& operator<<( std::ostream& out, const abstract_base& r )
+{
+    return out;    
+}
+
+inline abstract_base* new_clone( const abstract_base& r )
+{
+    return r.clone();
+}
+
+//
+// ptr_map test
+// 
+
+template< typename C, typename B, typename T >
+void ptr_map_test();
+
+template< class Key >
+Key get_next_key( const Key& k );
+
+template<>
+int get_next_key<int>( const int& )
+{
+    return rand();
+}
+
+template<>
+std::string get_next_key<std::string>( const std::string& )
+{
+    return boost::lexical_cast<std::string>( rand() );
+}
+
+
+template< typename C, typename B, typename T >
+void ptr_map_test()
+{
+    using namespace boost;
+
+    BOOST_MESSAGE( "starting associative container test" );
+    enum { max_cnt = 10, size = 100 };
+    C  c;
+    BOOST_CHECK( c.size() == 0 );
+
+    const C c2( c.begin(), c.end() );
+    BOOST_CHECK( c.size() == c2.size() );
+
+    C c3;
+
+    BOOST_MESSAGE( "finished construction test" );
+
+    BOOST_DEDUCED_TYPENAME C::allocator_type alloc        = c.get_allocator();
+    BOOST_DEDUCED_TYPENAME C::iterator i                  = c.begin();
+    BOOST_DEDUCED_TYPENAME C::const_iterator ci           = c2.begin();
+    BOOST_DEDUCED_TYPENAME C::iterator i2                 = c.end();
+    BOOST_DEDUCED_TYPENAME C::const_iterator ci2          = c2.begin();
+    BOOST_DEDUCED_TYPENAME C::reverse_iterator ri         = c.rbegin();
+    BOOST_DEDUCED_TYPENAME C::const_reverse_iterator cri  = c2.rbegin();
+    BOOST_DEDUCED_TYPENAME C::reverse_iterator rv2        = c.rend();
+    BOOST_DEDUCED_TYPENAME C::const_reverse_iterator cvr2 = c2.rend();
+
+    BOOST_DEDUCED_TYPENAME C::key_type a_key;
+
+    BOOST_MESSAGE( "finished iterator test" );
+
+    BOOST_DEDUCED_TYPENAME C::size_type s                 = c.size();
+    BOOST_DEDUCED_TYPENAME C::size_type s2                = c.max_size();
+    hide_warning(s2);
+    BOOST_CHECK_EQUAL( c.size(), s );
+    bool b                                                = c.empty();
+    hide_warning(b);
+    BOOST_MESSAGE( "finished accessors test" );
+
+    a_key = get_next_key( a_key );
+    c.insert( a_key, new T );
+    a_key = get_next_key( a_key );
+    c.insert( a_key, new T );
+    c3.insert( c.begin(), c.end() );
+    c.insert( c3 );
+    c.erase( c.begin() );
+    BOOST_CHECK( c3.end() == c3.erase( boost::make_iterator_range(c3) ) );
+    c3.erase( a_key );
+
+    BOOST_CHECK( c3.empty() );
+    c.swap( c3 );
+    swap(c,c3);
+    swap(c3,c);
+    BOOST_CHECK( !c3.empty() );
+    c3.clear();
+    BOOST_CHECK( c3.empty() );
+    BOOST_MESSAGE( "finished modifiers test" );
+
+
+    a_key = get_next_key( a_key );
+    c.insert( a_key, new T );
+    a_key = get_next_key( a_key );
+    c.insert( a_key, std::auto_ptr<T>( new T ) );
+    typename C::auto_type ptr2  = c.release( c.begin() );
+    std::auto_ptr<C> ap         = c.release();
+    c                           = c2.clone();
+    BOOST_MESSAGE( "finished release/clone test" );
+
+
+    a_key = get_next_key( a_key );
+    c3.insert( a_key, new T );
+    a_key = get_next_key( a_key );
+    c3.insert( a_key, new T );
+
+    c. BOOST_NESTED_TEMPLATE transfer<C>( c3.begin(), c3 );
+    c. BOOST_NESTED_TEMPLATE transfer<C>( c3.begin(), c3.end(), c3 );
+    BOOST_CHECK( c3.empty() );
+    BOOST_CHECK( !c.empty() );
+    c3. BOOST_NESTED_TEMPLATE transfer<C>( c );
+    BOOST_CHECK( !c3.empty() );
+    BOOST_CHECK( c.empty() );
+#ifdef BOOST_NO_SFINAE
+#else
+    c. BOOST_NESTED_TEMPLATE transfer<C>( make_iterator_range(c3), c3 );
+    BOOST_CHECK( !c.empty() );
+    BOOST_CHECK( c3.empty() );
+    c3. BOOST_NESTED_TEMPLATE transfer<C>(c);
+#endif
+    BOOST_MESSAGE( "finished transfer test" );
+
+    BOOST_CHECK( !c3.empty() );
+    c3.replace( c3.begin(), new T );
+    c3.replace( c3.begin(), std::auto_ptr<T>( new T ) );
+    BOOST_MESSAGE( "finished set/map interface test" );
+
+    // @todo: make macro with algorithms so that the right erase() is called.
+    //  c.unique();
+    //  c.unique( std::not_equal_to<T>() );
+    //  c.remove( T() );
+    //  c.remove_if( std::binder1st< std::equal_to<T> >( T() ) );
+
+    sub_range<C>        sub;
+    sub_range<const C> csub;
+
+    i  = c.find( get_next_key( a_key ) );
+    ci = c2.find( get_next_key( a_key ) );
+    c2.count( get_next_key( a_key ) );
+    i  = c.lower_bound( get_next_key( a_key ) );
+    ci = c2.lower_bound( get_next_key( a_key ) );
+    i  = c.upper_bound( get_next_key( a_key ) );
+    ci = c2.upper_bound( get_next_key( a_key ) );
+    sub  = c.equal_range( get_next_key( a_key ) );
+    csub = c2.equal_range( get_next_key( a_key ) );
+
+    try
+    {
+        c.at( get_next_key( a_key ) );
+    }
+    catch( const bad_ptr_container_operation& )
+    { }
+
+    try
+    {
+        c2.at( get_next_key( a_key ) );
+    }
+    catch( const bad_ptr_container_operation& )
+    { }
+
+    BOOST_MESSAGE( "finished algorithms interface test" );
+
+    typename C::iterator it = c.begin(), e = c.end();
+    for( ; it != e; ++it )
+    {
+        std::cout << "\n mapped value = " << *it->second << " key = " << it->first;
+        //std::cout << "\n mapped value = " << it.value() << " key = " << it.key();
+    }
+    
+    typename C::reverse_iterator rit = c.rbegin(), re = c.rend();
+    for( ; rit != re; ++rit )
+    {
+        std::cout << "\n mapped value = " << *rit->second << " key = " << rit->first;
+        //std::cout << "\n mapped value = " << rit.value() << " key = " << rit.key();    
+        //std::cout << "\n mapped value (base) = " 
+        //          << rit.base().value() << " key = " << rit.base().key();   
+    }
+    
+    typename C::const_reverse_iterator crit = c2.rbegin(), cre = c2.rend();
+    for( ; crit != cre; ++crit )
+    {
+        std::cout << "\n mapped value = " << *(*crit).second << " key = " << (*crit).first;
+        //std::cout << "\n mapped value = " << crit.value() << " key = " << crit.key();    
+        //std::cout << "\n mapped value (base) = " 
+        //          << crit.base().value() << " key = " << crit.base().key();   
+    }
+    
+    BOOST_MESSAGE( "finished iterator test" );
+
+    a_key = get_next_key( a_key );
+    c.insert( a_key, new T );
+    c.erase( a_key );
+    c.erase( a_key );
+
+}
+
+
+
+template< class CDerived, class CBase, class T >
+void test_transfer()
+{
+    CDerived from;
+    CBase    to;
+
+    int key = get_next_key( key );
+    from.insert( key, new T );
+    key = get_next_key( key );
+    from.insert( key, new T );
+    transfer_test( from, to );
+}
+
+
+
+template< class BaseContainer, class DerivedContainer, class Derived >
+void map_container_assignment_test()
+{
+    DerivedContainer derived;
+    std::string foo( "foo" );
+    std::string bar( "foo" );
+    derived.insert( foo, new Derived );
+    derived.insert( bar, new Derived );
+
+    BaseContainer base_container( derived );
+    BOOST_CHECK_EQUAL( derived.size(), base_container.size() );
+    base_container.clear();
+    base_container = derived;
+    BOOST_CHECK_EQUAL( derived.size(), base_container.size() );
+    
+    BaseContainer base2( base_container );
+    BOOST_CHECK_EQUAL( base2.size(), base_container.size() );
+    base2 = base_container;
+    BOOST_CHECK_EQUAL( base2.size(), base_container.size() );
+    base_container = base_container;
+}
+
+
+
+#include <boost/ptr_container/ptr_map.hpp>
+
+using namespace std;
+
+void test_map()
+{
+    ptr_map_test< ptr_map<int, Base>, Base, Derived_class >();
+    ptr_map_test< ptr_map<int, Value>, Value, Value >();
+    ptr_map_test< ptr_map<int, nullable<Base> >, Base, Derived_class >();
+    ptr_map_test< ptr_map<int, nullable<Value> >, Value, Value >();
+    ptr_map_test< ptr_map<int, abstract_base>, abstract_base, implementation >();
+
+    ptr_map_test< ptr_multimap<int,Base>, Base, Derived_class >();
+    ptr_map_test< ptr_multimap<int,Value>, Value, Value >();    
+    ptr_map_test< ptr_multimap<int, nullable<Base> >, Base, Derived_class >();
+    ptr_map_test< ptr_multimap<int, nullable<Value> >, Value, Value >();
+
+    map_container_assignment_test< ptr_map<std::string,Base>,
+                                   ptr_map<std::string,Derived_class>,
+                                   Derived_class>();
+    map_container_assignment_test< ptr_map<std::string, nullable<Base> >,
+                                   ptr_map<std::string,Derived_class>,
+                                   Derived_class>();                            
+    map_container_assignment_test< ptr_map<std::string, nullable<Base> >,
+                                   ptr_map<std::string, nullable<Derived_class> >, 
+                                   Derived_class>();                               
+   map_container_assignment_test< ptr_multimap<std::string,Base>,
+                                   ptr_multimap<std::string,Derived_class>,
+                                   Derived_class>();
+    map_container_assignment_test< ptr_multimap<std::string, nullable<Base> >,
+                                   ptr_multimap<std::string,Derived_class>,
+                                   Derived_class>();                            
+    map_container_assignment_test< ptr_multimap<std::string, nullable<Base> >,
+                                   ptr_multimap<std::string, nullable<Derived_class> >, 
+                                   Derived_class>();                               
+
+                                      
+    test_transfer< ptr_map<int,Derived_class>, ptr_map<int,Base>, Derived_class >();
+    test_transfer< ptr_multimap<int,Derived_class>, ptr_multimap<int,Base>, Derived_class >();
+    
+    string joe   = "joe";
+    string brian = "brian";
+    string kenny = "kenny"; 
+    
+    ptr_map<string,int> m;
+    m.insert( joe, new int( 4 ) );
+    m.insert( brian, new int( 6 ) );
+    BOOST_CHECK( m[ "foo" ] == 0 );
+    m[ "bar" ] += 5;
+    BOOST_CHECK( m[ "bar" ] == 5 );
+    m[ joe ]   += 56;
+    m[ brian ] += 10;
+
+    BOOST_CHECK_THROW( (m.insert(kenny, 0 )), bad_ptr_container_operation );
+    BOOST_CHECK_THROW( (m.replace(m.begin(), 0 )), bad_ptr_container_operation ); 
+    BOOST_CHECK_THROW( (m.at("not there")), bad_ptr_container_operation );
+
+    for( ptr_map<string,int>::iterator i = m.begin();
+         i != m.end(); ++i )
+    {
+        if( is_null(i) )
+            BOOST_CHECK( false );
+        const string& ref  = i->first;
+        hide_warning(ref);
+        int&          ref2 = *(*i).second;
+        ref2++;
+    }
+
+    typedef ptr_map<string,Derived_class> map_type;
+    map_type m2;
+    m2.insert( joe, new Derived_class );
+    //
+    // This works fine since 'm2' is not const
+    //
+    m2.begin()->second->foo();
+
+    //
+    // These all return an implementation-defined proxy
+    // with two public members: 'first' and 'second'
+    //
+    map_type::value_type       a_value      = *m2.begin();
+    a_value.second->foo();
+    map_type::reference        a_reference  = *m2.begin();
+    a_reference.second->foo();
+    map_type::const_reference  a_creference = *const_begin(m2);
+   
+    //
+    //
+    // These will fail as iterators propagate constness
+    // 
+    //a_creference.second->foo();
+    //a_cpointer->second->foo();
+    //const_begin(m2)->second->foo();
+
+}
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/iterator/zip_iterator.hpp>
+#include <map>
+#include <boost/ptr_container/ptr_map.hpp>
+
+void test_map_iterators()
+{
+    using boost::zip_iterator;
+    using boost::tuple;
+    using boost::make_tuple;
+    using boost::ptr_map;
+    using std::map;
+
+    //typedef map<int, int> theMapType;
+    /*
+    @remark: the following will not compile
+             because of proxy (non-reference) returned by operator*()
+             of the ptr_map's iterator type.
+             
+    typedef boost::ptr_map<int, int> theMapType;
+    typedef zip_iterator
+        <tuple<theMapType::iterator, theMapType::iterator> > zipIter;
+    theMapType map1;
+    theMapType map2;
+    zipIter zip(make_tuple(map1.begin(), map2.begin()));
+    */
+}
+
+
+
+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_map ) );
+    test->add( BOOST_TEST_CASE( &test_map_iterators ) );
+
+    return test;
+}
+
+
+
+
+
+
+

Added: trunk/libs/ptr_container/test/ptr_unordered_set.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/ptr_container/test/ptr_unordered_set.cpp	2008-06-03 18:20:38 EDT (Tue, 03 Jun 2008)
@@ -0,0 +1,84 @@
+//
+// 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 "associative_test_data.hpp"
+#include <boost/ptr_container/ptr_unordered_set.hpp>
+
+template< class SetDerived, class SetBase, class T >
+void test_transfer()
+{
+    SetBase to;
+    SetDerived from;
+    from.insert( new T );
+    from.insert( new T );
+    transfer_test( from, to );
+}
+
+template< class BaseContainer, class DerivedContainer, class Derived >
+void test_copy()
+{
+    DerivedContainer derived;
+    derived.insert( new Derived );
+    derived.insert( new Derived );
+
+    BaseContainer base( derived );
+    BOOST_CHECK_EQUAL( derived.size(), base.size() );
+    base.clear();
+    base = derived;
+    BOOST_CHECK_EQUAL( derived.size(), base.size() );
+    base = base;
+}
+
+void test_set()
+{    
+    srand( 0 );
+    ptr_set_test< ptr_unordered_set<Base>, Base, Derived_class >();
+/*    ptr_set_test< ptr_unordered_set<Value>, Value, Value >();
+
+    ptr_set_test< ptr_unordered_multiset<Base>, Base, Derived_class >();
+    ptr_set_test< ptr_unordered_multiset<Value>, Value, Value >();
+
+    test_copy< ptr_unordered_set<Base>, ptr_unordered_set<Derived_class>, 
+               Derived_class>();
+    test_copy< ptr_unordered_multiset<Base>, ptr_unordered_multiset<Derived_class>, 
+               Derived_class>();
+
+    test_transfer< ptr_unordered_set<Derived_class>, ptr_unordered_set<Base>, Derived_class>();
+    test_transfer< ptr_unordered_multiset<Derived_class>, ptr_unordered_multiset<Base>, Derived_class>();
+    
+    ptr_unordered_set<int> set;
+
+    BOOST_CHECK_THROW( set.insert( 0 ), bad_ptr_container_operation );
+    set.insert( new int(0) );
+    set.insert( std::auto_ptr<int>( new int(1) ) );
+    BOOST_CHECK_THROW( (set.replace(set.begin(), 0 )), bad_ptr_container_operation );
+    BOOST_CHECK_THROW( (set.replace(set.begin(), std::auto_ptr<int>(0) )), bad_ptr_container_operation );
+*/
+
+}
+
+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_set ) );
+
+    return test;
+}
+
+
+
+
+
+

Modified: trunk/libs/ptr_container/test/sequence_test_data.hpp
==============================================================================
--- trunk/libs/ptr_container/test/sequence_test_data.hpp	(original)
+++ trunk/libs/ptr_container/test/sequence_test_data.hpp	2008-06-03 18:20:38 EDT (Tue, 03 Jun 2008)
@@ -19,6 +19,13 @@
 template< class IntContainer >
 void algorithms_test();
 
+template< class Cont >
+struct set_capacity
+{
+    void operator()( Cont& ) const
+    { }
+};
+
 template< typename C, typename B, typename T >
 void reversible_container_test()
 {
@@ -27,6 +34,7 @@
     BOOST_MESSAGE( "starting reversible container test" ); 
     enum { max_cnt = 10, size = 100 };
     C  c;
+    set_capacity<C>()( c );
     BOOST_CHECK( c.size() == 0 );
     c.push_back( new T );
     BOOST_CHECK( c.size() == 1 );
@@ -50,6 +58,7 @@
     a_copy.clear();
     a_copy = a_copy;
     BOOST_CHECK( a_copy.empty() );
+    BOOST_CHECK( !c.empty() );
     BOOST_MESSAGE( "finished copying test" ); 
 
     BOOST_DEDUCED_TYPENAME C::allocator_type alloc        = c.get_allocator();