ceph/src/boost/libs/ptr_container/test/associative_test_data.hpp

   1 //
   2 // Boost.Pointer Container
   3 //
   4 //  Copyright Thorsten Ottosen 2003-2005. Use, modification and
   5 //  distribution is subject to the Boost Software License, Version
   6 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
   7 //  http://www.boost.org/LICENSE_1_0.txt)
   8 //
   9 // For more information, see http://www.boost.org/libs/ptr_container/
  10 //
  11
  12 #include "test_data.hpp"
  13 #include <boost/ptr_container/exception.hpp>
  14 #include <boost/range/sub_range.hpp>
  15
  16 template< typename C, typename B, typename T, bool Ordered >
  17 void ptr_set_test();
  18
  19 template< class T, bool Ordered >
  20 struct test_algorithms
  21 {
  22     template< class Cont >
  23     void operator()( Cont& c, const Cont& c2 ) const
  24     {
  25         typename Cont::iterator i;
  26         typename Cont::const_iterator ci;
  27
  28         T* t = new T;
  29         i  = c.lower_bound( *t );
  30         ci = c2.lower_bound( *t );
  31         i  = c.upper_bound( *t );
  32         ci = c2.upper_bound( *t );
  33         delete t;
  34
  35         BOOST_DEDUCED_TYPENAME Cont::reverse_iterator ri         = c.rbegin();
  36         BOOST_DEDUCED_TYPENAME Cont::const_reverse_iterator cri  = c2.rbegin();
  37         BOOST_DEDUCED_TYPENAME Cont::reverse_iterator rv2        = c.rend();
  38         BOOST_DEDUCED_TYPENAME Cont::const_reverse_iterator cvr2 = c2.rend();
  39         cri = c.crbegin();
  40         cri = c.crend();
  41     }
  42 };
  43
  44 template< class T >
  45 struct test_algorithms<T,false>
  46 {
  47     template< class Cont>
  48     void operator()( Cont& c, const Cont& c2 ) const
  49     {
  50     }
  51 };
  52
  53 template< typename C, typename B, typename T, bool Ordered >
  54 void ptr_set_test()
  55 {
  56     using namespace boost;
  57
  58     BOOST_TEST_MESSAGE( "starting associative container test" );
  59     enum { max_cnt = 10, size = 100 };
  60     C  c;
  61     BOOST_CHECK( c.size() == 0 );
  62     c.insert( c.end(), new T );
  63     c.insert( c.end(), new T );
  64
  65     const C c2( c.begin(), c.end() );
  66     BOOST_CHECK( c.size() == c2.size() );
  67
  68     C c3;
  69
  70     BOOST_TEST_MESSAGE( "finished construction test" );
  71
  72     C a_copy( c );
  73     BOOST_CHECK_EQUAL( a_copy.size(), c.size() );
  74     a_copy = a_copy;
  75     BOOST_CHECK_EQUAL( a_copy.size(), c.size() );
  76     c.clear();
  77     a_copy = c;
  78     a_copy = a_copy;
  79     BOOST_CHECK( a_copy.empty() );
  80
  81     BOOST_TEST_MESSAGE( "finished copying test" );
  82
  83     BOOST_DEDUCED_TYPENAME C::allocator_type alloc        = c.get_allocator();
  84     BOOST_DEDUCED_TYPENAME C::iterator i                  = c.begin();
  85     BOOST_DEDUCED_TYPENAME C::const_iterator ci           = c2.begin();
  86     ci = c.cbegin();
  87     ci = c.cend();
  88     BOOST_DEDUCED_TYPENAME C::iterator i2                 = c.end();
  89     BOOST_DEDUCED_TYPENAME C::const_iterator ci2          = c2.begin();
  90
  91     BOOST_TEST_MESSAGE( "finished iterator test" );
  92
  93     BOOST_DEDUCED_TYPENAME C::size_type s                 = c.size();
  94     BOOST_DEDUCED_TYPENAME C::size_type s2                = c.max_size();
  95     hide_warning(s2);
  96     BOOST_CHECK_EQUAL( c.size(), s );
  97     bool b                                                = c.empty();
  98     hide_warning(b);
  99     BOOST_TEST_MESSAGE( "finished accessors test" );
 100
 101     T* t = new T;
 102     c.insert( c.end(), t );
 103     c.insert( c.end(), std::auto_ptr<T>( new T ) );
 104     c.insert( new T );
 105     std::auto_ptr<T> ap( new T );
 106     c.insert( ap );
 107     c3.insert( c.begin(), c.end() );
 108     c.erase( c.begin() );
 109     c3.erase( c3.begin(), c3.end() );
 110     t = new T;
 111     c.insert( new T );
 112     c.erase( *t );
 113     delete t;
 114
 115     BOOST_CHECK( c3.empty() );
 116     c.swap( c3 );
 117     BOOST_CHECK( !c3.empty() );
 118     BOOST_CHECK( c.empty() );
 119     c3.clear();
 120
 121     //
 122     // remark: we cannot pass c3 directly as it would
 123     //         extract const iterators ... and the
 124     //         current standard does not allow erase()
 125     //         to be given const iterators
 126     //
 127     c3.erase( boost::make_iterator_range(c3) );
 128     BOOST_CHECK( c3.empty() );
 129     BOOST_TEST_MESSAGE( "finished modifiers test" );
 130
 131     c.insert( c.end(), new T );
 132     typename C::auto_type ptr2  = c.release( c.begin() );
 133     std::auto_ptr<C> ap2         = c.release();
 134     c                           = c2.clone();
 135     BOOST_TEST_MESSAGE( "finished release/clone test" );
 136
 137     c3.insert( new T );
 138     c3.insert( new T );
 139     BOOST_CHECK_EQUAL( c3.size(), 2u );
 140 #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
 141 #else
 142     c3.insert( make_iterator_range( c ) );
 143 //    BOOST_CHECK_EQUAL( c3.size(), 4u );
 144 #endif
 145     c. BOOST_NESTED_TEMPLATE transfer<C>( c3.begin(), c3 );
 146     BOOST_CHECK( c3.empty() == false );
 147     c.clear();
 148     unsigned long c3size = c3.size();
 149     hide_warning( c3size );
 150     unsigned long num  = c. BOOST_NESTED_TEMPLATE transfer<C>( c3.begin(),
 151                                                                c3.end(),
 152                                                               c3 );
 153
 154     BOOST_CHECK( num > 0 );
 155     BOOST_CHECK_EQUAL( num, c.size() );
 156     BOOST_CHECK( c3.empty() );
 157     BOOST_CHECK( !c.empty() );
 158     c3. BOOST_NESTED_TEMPLATE transfer<C>( c );
 159     BOOST_CHECK( !c3.empty() );
 160     BOOST_CHECK( c.empty() );
 161 #ifdef BOOST_NO_SFINAE
 162 #else
 163     c.  BOOST_NESTED_TEMPLATE transfer<C>( make_iterator_range( c3 ), c3 );
 164     BOOST_CHECK( !c.empty() );
 165     BOOST_CHECK( c3.empty() );
 166 #endif
 167
 168     BOOST_TEST_MESSAGE( "finished transfer test" );
 169
 170     C c4;
 171     c4.swap(c3);
 172     swap(c4,c3);
 173     BOOST_TEST_MESSAGE( "finished set/map interface test" );
 174
 175     sub_range<C>        sub;
 176     sub_range<const C> csub;
 177
 178     t = new T;
 179     i  = c.find( *t );
 180     ci = c2.find( *t );
 181     c2.count( *t );
 182
 183     test_algorithms<T,Ordered>()( c, c2 );
 184     sub  = c.equal_range( *t );
 185     csub = c2.equal_range( *t );
 186     delete t;
 187
 188     BOOST_TEST_MESSAGE( "finished algorithms interface test" );
 189
 190 }
 191