Beispiel #1
0
int set_test_copyable ()
{
   typedef typename MyBoostSet::value_type IntType;
   const int max = 100;

   BOOST_TRY{
      //Shared memory allocator must be always be initialized
      //since it has no default constructor
      MyBoostSet *boostset = new MyBoostSet;
      MyStdSet *stdset = new MyStdSet;
      MyBoostMultiSet *boostmultiset = new MyBoostMultiSet;
      MyStdMultiSet *stdmultiset = new MyStdMultiSet;

      for(int i = 0; i < max; ++i){
         IntType move_me(i);
         boostset->insert(boost::move(move_me));
         stdset->insert(i);
         IntType move_me2(i);
         boostmultiset->insert(boost::move(move_me2));
         stdmultiset->insert(i);
      }
      if(!CheckEqualContainers(boostset, stdset)) return 1;
      if(!CheckEqualContainers(boostmultiset, stdmultiset)) return 1;

      {
         //Now, test copy constructor
         MyBoostSet boostsetcopy(*boostset);
         MyStdSet stdsetcopy(*stdset);

         if(!CheckEqualContainers(&boostsetcopy, &stdsetcopy))
            return 1;

         MyBoostMultiSet boostmsetcopy(*boostmultiset);
         MyStdMultiSet stdmsetcopy(*stdmultiset);

         if(!CheckEqualContainers(&boostmsetcopy, &stdmsetcopy))
            return 1;

         //And now assignment
         boostsetcopy  = *boostset;
         stdsetcopy  = *stdset;

         if(!CheckEqualContainers(&boostsetcopy, &stdsetcopy))
            return 1;

         boostmsetcopy = *boostmultiset;
         stdmsetcopy = *stdmultiset;
        
         if(!CheckEqualContainers(&boostmsetcopy, &stdmsetcopy))
            return 1;
      }
      delete boostset;
      delete boostmultiset;
   }
   BOOST_CATCH(...){
      BOOST_RETHROW;
   }
   BOOST_CATCH_END
   return 0;
}
Beispiel #2
0
int set_test ()
{
   typedef typename MyBoostSet::value_type IntType;
   const int max = 100;

   MyBoostSet *boostset = new MyBoostSet;
   MyStdSet *stdset = new MyStdSet;
   MyBoostMultiSet *boostmultiset = new MyBoostMultiSet;
   MyStdMultiSet *stdmultiset = new MyStdMultiSet;

   //Test construction from a range
   {
      IntType aux_vect[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(i/2);
         aux_vect[i] = boost::move(move_me);
      }
      int aux_vect2[50];
      for(int i = 0; i < 50; ++i){
         aux_vect2[i] = i/2;
      }
      IntType aux_vect3[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(i/2);
         aux_vect3[i] = boost::move(move_me);
      }

      MyBoostSet *boostset2 = new MyBoostSet
            ( boost::make_move_iterator(&aux_vect[0])
            , boost::make_move_iterator(aux_vect + 50));
      MyStdSet *stdset2 = new MyStdSet(aux_vect2, aux_vect2 + 50);
      MyBoostMultiSet *boostmultiset2 = new MyBoostMultiSet
            ( boost::make_move_iterator(&aux_vect3[0])
            , boost::make_move_iterator(aux_vect3 + 50));
      MyStdMultiSet *stdmultiset2 = new MyStdMultiSet(aux_vect2, aux_vect2 + 50);
      if(!CheckEqualContainers(boostset2, stdset2)){
         std::cout << "Error in construct<MyBoostSet>(MyBoostSet2)" << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(boostmultiset2, stdmultiset2)){
         std::cout << "Error in construct<MyBoostMultiSet>(MyBoostMultiSet2)" << std::endl;
         return 1;
      }

      //ordered range insertion
      for(int i = 0; i < 50; ++i){
         IntType move_me(i);
         aux_vect[i] = boost::move(move_me);
      }

      for(int i = 0; i < 50; ++i){
         aux_vect2[i] = i;
      }

      for(int i = 0; i < 50; ++i){
         IntType move_me(i);
         aux_vect3[i] = boost::move(move_me);
      }

      MyBoostSet *boostset3 = new MyBoostSet
            ( ordered_unique_range
            , boost::make_move_iterator(&aux_vect[0])
            , boost::make_move_iterator(aux_vect + 50));
      MyStdSet *stdset3 = new MyStdSet(aux_vect2, aux_vect2 + 50);
      MyBoostMultiSet *boostmultiset3 = new MyBoostMultiSet
            ( ordered_range
            , boost::make_move_iterator(&aux_vect3[0])
            , boost::make_move_iterator(aux_vect3 + 50));
      MyStdMultiSet *stdmultiset3 = new MyStdMultiSet(aux_vect2, aux_vect2 + 50);

      if(!CheckEqualContainers(boostset3, stdset3)){
         std::cout << "Error in construct<MyBoostSet>(MyBoostSet3)" << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(boostmultiset3, stdmultiset3)){
         std::cout << "Error in construct<MyBoostMultiSet>(MyBoostMultiSet3)" << std::endl;
         return 1;
      }

      delete boostset2;
      delete boostmultiset2;
      delete stdset2;
      delete stdmultiset2;
      delete boostset3;
      delete boostmultiset3;
      delete stdset3;
      delete stdmultiset3;
   }

   for(int i = 0; i < max; ++i){
      IntType move_me(i);
      boostset->insert(boost::move(move_me));
      stdset->insert(i);
      boostset->insert(IntType(i));
      stdset->insert(i);
      IntType move_me2(i);
      boostmultiset->insert(boost::move(move_me2));
      stdmultiset->insert(i);
      boostmultiset->insert(IntType(i));
      stdmultiset->insert(i);
   }

   if(!CheckEqualContainers(boostset, stdset)){
      std::cout << "Error in boostset->insert(boost::move(move_me)" << std::endl;
      return 1;
   }

   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
      std::cout << "Error in boostmultiset->insert(boost::move(move_me)" << std::endl;
      return 1;
   }

   typename MyBoostSet::iterator it = boostset->begin();
   typename MyBoostSet::const_iterator cit = it;
   (void)cit;

   boostset->erase(boostset->begin());
   stdset->erase(stdset->begin());
   boostmultiset->erase(boostmultiset->begin());
   stdmultiset->erase(stdmultiset->begin());
   if(!CheckEqualContainers(boostset, stdset)){
      std::cout << "Error in boostset->erase(boostset->begin())" << std::endl;
      return 1;
   }
   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
      std::cout << "Error in boostmultiset->erase(boostmultiset->begin())" << std::endl;
      return 1;
   }

   boostset->erase(boostset->begin());
   stdset->erase(stdset->begin());
   boostmultiset->erase(boostmultiset->begin());
   stdmultiset->erase(stdmultiset->begin());
   if(!CheckEqualContainers(boostset, stdset)){
      std::cout << "Error in boostset->erase(boostset->begin())" << std::endl;
      return 1;
   }
   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
      std::cout << "Error in boostmultiset->erase(boostmultiset->begin())" << std::endl;
      return 1;
   }

   //Swapping test
   MyBoostSet tmpboosteset2;
   MyStdSet tmpstdset2;
   MyBoostMultiSet tmpboostemultiset2;
   MyStdMultiSet tmpstdmultiset2;
   boostset->swap(tmpboosteset2);
   stdset->swap(tmpstdset2);
   boostmultiset->swap(tmpboostemultiset2);
   stdmultiset->swap(tmpstdmultiset2);
   boostset->swap(tmpboosteset2);
   stdset->swap(tmpstdset2);
   boostmultiset->swap(tmpboostemultiset2);
   stdmultiset->swap(tmpstdmultiset2);
   if(!CheckEqualContainers(boostset, stdset)){
      std::cout << "Error in boostset->swap(tmpboosteset2)" << std::endl;
      return 1;
   }
   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
      std::cout << "Error in boostmultiset->swap(tmpboostemultiset2)" << std::endl;
      return 1;
   }

   //Insertion from other container
   //Initialize values
   {
      IntType aux_vect[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(-1);
         aux_vect[i] = boost::move(move_me);
      }
      int aux_vect2[50];
      for(int i = 0; i < 50; ++i){
         aux_vect2[i] = -1;
      }
      IntType aux_vect3[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(-1);
         aux_vect3[i] = boost::move(move_me);
      }

      boostset->insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(aux_vect + 50));
      stdset->insert(aux_vect2, aux_vect2 + 50);
      boostmultiset->insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(aux_vect3 + 50));
      stdmultiset->insert(aux_vect2, aux_vect2 + 50);
      if(!CheckEqualContainers(boostset, stdset)){
         std::cout << "Error in boostset->insert(boost::make_move_iterator(&aux_vect[0])..." << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
         std::cout << "Error in boostmultiset->insert(boost::make_move_iterator(&aux_vect3[0]), ..." << std::endl;
         return 1;
      }

      for(int i = 0, j = static_cast<int>(boostset->size()); i < j; ++i){
         IntType erase_me(i);
         boostset->erase(erase_me);
         stdset->erase(i);
         boostmultiset->erase(erase_me);
         stdmultiset->erase(i);
         if(!CheckEqualContainers(boostset, stdset)){
            std::cout << "Error in boostset->erase(erase_me)" << boostset->size() << " " << stdset->size() << std::endl;
            return 1;
         }
         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
            std::cout << "Error in boostmultiset->erase(erase_me)" << std::endl;
            return 1;
         }
      }
   }
   {
      IntType aux_vect[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(-1);
         aux_vect[i] = boost::move(move_me);
      }
      int aux_vect2[50];
      for(int i = 0; i < 50; ++i){
         aux_vect2[i] = -1;
      }
      IntType aux_vect3[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(-1);
         aux_vect3[i] = boost::move(move_me);
      }

      IntType aux_vect4[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(-1);
         aux_vect4[i] = boost::move(move_me);
      }

      IntType aux_vect5[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(-1);
         aux_vect5[i] = boost::move(move_me);
      }

      boostset->insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(aux_vect + 50));
      boostset->insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(aux_vect3 + 50));
      stdset->insert(aux_vect2, aux_vect2 + 50);
      stdset->insert(aux_vect2, aux_vect2 + 50);
      boostmultiset->insert(boost::make_move_iterator(&aux_vect4[0]), boost::make_move_iterator(aux_vect4 + 50));
      boostmultiset->insert(boost::make_move_iterator(&aux_vect5[0]), boost::make_move_iterator(aux_vect5 + 50));
      stdmultiset->insert(aux_vect2, aux_vect2 + 50);
      stdmultiset->insert(aux_vect2, aux_vect2 + 50);
      if(!CheckEqualContainers(boostset, stdset)){
         std::cout << "Error in boostset->insert(boost::make_move_iterator(&aux_vect3[0])..." << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
         std::cout << "Error in boostmultiset->insert(boost::make_move_iterator(&aux_vect5[0])..." << std::endl;
         return 1;
      }

      boostset->erase(*boostset->begin());
      stdset->erase(*stdset->begin());
      boostmultiset->erase(*boostmultiset->begin());
      stdmultiset->erase(*stdmultiset->begin());
      if(!CheckEqualContainers(boostset, stdset)){
         std::cout << "Error in boostset->erase(*boostset->begin())" << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
         std::cout << "Error in boostmultiset->erase(*boostmultiset->begin())" << std::endl;
         return 1;
      }
   }

   for(int i = 0; i < max; ++i){
      IntType move_me(i);
      boostset->insert(boost::move(move_me));
      stdset->insert(i);
      IntType move_me2(i);
      boostmultiset->insert(boost::move(move_me2));
      stdmultiset->insert(i);
   }

   if(!CheckEqualContainers(boostset, stdset)){
      std::cout << "Error in boostset->insert(boost::move(move_me)) try 2" << std::endl;
      return 1;
   }
   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
      std::cout << "Error in boostmultiset->insert(boost::move(move_me2)) try 2" << std::endl;
      return 1;
   }

   for(int i = 0; i < max; ++i){
      {
         IntType move_me(i);
         boostset->insert(boostset->begin(), boost::move(move_me));
         stdset->insert(stdset->begin(), i);
         //PrintContainers(boostset, stdset);
         IntType move_me2(i);
         boostmultiset->insert(boostmultiset->begin(), boost::move(move_me2));
         stdmultiset->insert(stdmultiset->begin(), i);
         //PrintContainers(boostmultiset, stdmultiset);
         if(!CheckEqualContainers(boostset, stdset)){
            std::cout << "Error in boostset->insert(boostset->begin(), boost::move(move_me))" << std::endl;
            return 1;
         }
         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
            std::cout << "Error in boostmultiset->insert(boostmultiset->begin(), boost::move(move_me2))" << std::endl;
            return 1;
         }

         IntType move_me3(i);
         boostset->insert(boostset->end(), boost::move(move_me3));
         stdset->insert(stdset->end(), i);
         IntType move_me4(i);
         boostmultiset->insert(boostmultiset->end(), boost::move(move_me4));
         stdmultiset->insert(stdmultiset->end(), i);
         if(!CheckEqualContainers(boostset, stdset)){
            std::cout << "Error in boostset->insert(boostset->end(), boost::move(move_me3))" << std::endl;
            return 1;
         }
         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
            std::cout << "Error in boostmultiset->insert(boostmultiset->end(), boost::move(move_me4))" << std::endl;
            return 1;
         }
      }
      {
         IntType move_me(i);
         boostset->insert(boostset->upper_bound(move_me), boost::move(move_me));
         stdset->insert(stdset->upper_bound(i), i);
         //PrintContainers(boostset, stdset);
         IntType move_me2(i);
         boostmultiset->insert(boostmultiset->upper_bound(move_me2), boost::move(move_me2));
         stdmultiset->insert(stdmultiset->upper_bound(i), i);
         //PrintContainers(boostmultiset, stdmultiset);
         if(!CheckEqualContainers(boostset, stdset)){
            std::cout << "Error in boostset->insert(boostset->upper_bound(move_me), boost::move(move_me))" << std::endl;
            return 1;
         }
         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
            std::cout << "Error in boostmultiset->insert(boostmultiset->upper_bound(move_me2), boost::move(move_me2))" << std::endl;
            return 1;
         }

      }
      {
         IntType move_me(i);
         IntType move_me2(i);
         boostset->insert(boostset->lower_bound(move_me), boost::move(move_me2));
         stdset->insert(stdset->lower_bound(i), i);
         //PrintContainers(boostset, stdset);
         move_me2 = i;
         boostmultiset->insert(boostmultiset->lower_bound(move_me2), boost::move(move_me2));
         stdmultiset->insert(stdmultiset->lower_bound(i), i);
         //PrintContainers(boostmultiset, stdmultiset);
         if(!CheckEqualContainers(boostset, stdset)){
            std::cout << "Error in boostset->insert(boostset->lower_bound(move_me), boost::move(move_me2))" << std::endl;
            return 1;
         }
         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
            std::cout << "Error in boostmultiset->insert(boostmultiset->lower_bound(move_me2), boost::move(move_me2))" << std::endl;
            return 1;
         }
         set_test_rebalanceable(*boostset
            , container_detail::bool_<has_member_function_callable_with_rebalance<MyBoostSet>::value>());
         if(!CheckEqualContainers(boostset, stdset)){
            std::cout << "Error in boostset->rebalance()" << std::endl;
            return 1;
         }
         set_test_rebalanceable(*boostmultiset
            , container_detail::bool_<has_member_function_callable_with_rebalance<MyBoostMultiSet>::value>());
         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
            std::cout << "Error in boostmultiset->rebalance()" << std::endl;
            return 1;
         }
      }
   }

   //Compare count with std containers
   for(int i = 0; i < max; ++i){
      IntType count_me(i);
      if(boostset->count(count_me) != stdset->count(i)){
         return -1;
      }
      if(boostmultiset->count(count_me) != stdmultiset->count(i)){
         return -1;
      }
   }

   //Compare find/lower_bound/upper_bound in set
   {
      typename MyBoostSet::iterator bs_b = boostset->begin();
      typename MyBoostSet::iterator bs_e = boostset->end();
      typename MyStdSet::iterator ss_b   = stdset->begin();

      std::size_t i = 0;
      while(bs_b != bs_e){
         ++i;
         typename MyBoostSet::iterator bs_i;
         typename MyStdSet::iterator ss_i;
         //find
         bs_i = boostset->find(*bs_b);
         ss_i = stdset->find(*ss_b);
         if(!CheckEqualIt(bs_i, ss_i, *boostset, *stdset)){
            return -1;
         }
         //lower bound
         bs_i = boostset->lower_bound(*bs_b);
         ss_i = stdset->lower_bound(*ss_b);
         if(!CheckEqualIt(bs_i, ss_i, *boostset, *stdset)){
            return -1;
         }
         //upper bound
         bs_i = boostset->upper_bound(*bs_b);
         ss_i = stdset->upper_bound(*ss_b);
         if(!CheckEqualIt(bs_i, ss_i, *boostset, *stdset)){
            return -1;
         }
         //equal range
         std::pair<typename MyBoostSet::iterator
                  ,typename MyBoostSet::iterator> bs_ip;
         std::pair<typename MyStdSet::iterator
                  ,typename MyStdSet::iterator>   ss_ip;
         bs_ip = boostset->equal_range(*bs_b);
         ss_ip = stdset->equal_range(*ss_b);
         if(!CheckEqualIt(bs_ip.first, ss_ip.first, *boostset, *stdset)){
            return -1;
         }
         if(!CheckEqualIt(bs_ip.second, ss_ip.second, *boostset, *stdset)){
            return -1;
         }
         ++bs_b;
         ++ss_b;
      }
   }
   //Compare find/lower_bound/upper_bound in multiset
   {
      typename MyBoostMultiSet::iterator bm_b = boostmultiset->begin();
      typename MyBoostMultiSet::iterator bm_e = boostmultiset->end();
      typename MyStdMultiSet::iterator sm_b   = stdmultiset->begin();

      while(bm_b != bm_e){
         typename MyBoostMultiSet::iterator bm_i;
         typename MyStdMultiSet::iterator sm_i;
         //find
         bm_i = boostmultiset->find(*bm_b);
         sm_i = stdmultiset->find(*sm_b);
         if(!CheckEqualIt(bm_i, sm_i, *boostmultiset, *stdmultiset)){
            return -1;
         }
         //lower bound
         bm_i = boostmultiset->lower_bound(*bm_b);
         sm_i = stdmultiset->lower_bound(*sm_b);
         if(!CheckEqualIt(bm_i, sm_i, *boostmultiset, *stdmultiset)){
            return -1;
         }
         //upper bound
         bm_i = boostmultiset->upper_bound(*bm_b);
         sm_i = stdmultiset->upper_bound(*sm_b);
         if(!CheckEqualIt(bm_i, sm_i, *boostmultiset, *stdmultiset)){
            return -1;
         }
         //equal range
         std::pair<typename MyBoostMultiSet::iterator
                  ,typename MyBoostMultiSet::iterator> bm_ip;
         std::pair<typename MyStdMultiSet::iterator
                  ,typename MyStdMultiSet::iterator>   sm_ip;
         bm_ip = boostmultiset->equal_range(*bm_b);
         sm_ip = stdmultiset->equal_range(*sm_b);
         if(!CheckEqualIt(bm_ip.first, sm_ip.first, *boostmultiset, *stdmultiset)){
            return -1;
         }
         if(!CheckEqualIt(bm_ip.second, sm_ip.second, *boostmultiset, *stdmultiset)){
            return -1;
         }
         ++bm_b;
         ++sm_b;
      }
   }

   //Now do count exercise
   boostset->erase(boostset->begin(), boostset->end());
   boostmultiset->erase(boostmultiset->begin(), boostmultiset->end());
   boostset->clear();
   boostmultiset->clear();

   for(int j = 0; j < 3; ++j)
   for(int i = 0; i < 100; ++i){
      IntType move_me(i);
      boostset->insert(boost::move(move_me));
      IntType move_me2(i);
      boostmultiset->insert(boost::move(move_me2));
      IntType count_me(i);
      if(boostset->count(count_me) != typename MyBoostMultiSet::size_type(1)){
         std::cout << "Error in boostset->count(count_me)" << std::endl;
         return 1;
      }
      if(boostmultiset->count(count_me) != typename MyBoostMultiSet::size_type(j+1)){
         std::cout << "Error in boostmultiset->count(count_me)" << std::endl;
         return 1;
      }
   }

   delete boostset;
   delete stdset;
   delete boostmultiset;
   delete stdmultiset;

   if(set_test_copyable<MyBoostSet, MyStdSet, MyBoostMultiSet, MyStdMultiSet>
      (container_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
      return 1;
   }

   return 0;
}
Beispiel #3
0
int set_test_copyable ()
{
   typedef typename MyShmSet::value_type IntType;
   const int memsize = 65536;
   const char *const shMemName = test::get_process_id_name();
   const int max = 100;

   try{
      //Create shared memory
      shared_memory_object::remove(shMemName);
      ManagedSharedMemory segment(create_only, shMemName, memsize);

      segment.reserve_named_objects(100);

      //Shared memory allocator must be always be initialized
      //since it has no default constructor
      MyShmSet *shmset =
         segment.template construct<MyShmSet>("MyShmSet")
            (std::less<IntType>(), segment.get_segment_manager());

      MyStdSet *stdset = new MyStdSet;

      MyShmMultiSet *shmmultiset =
         segment.template construct<MyShmMultiSet>("MyShmMultiSet")
            (std::less<IntType>(), segment.get_segment_manager());

      MyStdMultiSet *stdmultiset = new MyStdMultiSet;

      for(int i = 0; i < max; ++i){
         IntType move_me(i);
         shmset->insert(boost::move(move_me));
         stdset->insert(i);
         IntType move_me2(i);
         shmmultiset->insert(boost::move(move_me2));
         stdmultiset->insert(i);
      }
      if(!CheckEqualContainers(shmset, stdset)) return 1;
      if(!CheckEqualContainers(shmmultiset, stdmultiset)) return 1;

      {
         //Now, test copy constructor
         MyShmSet shmsetcopy(*shmset);
         MyStdSet stdsetcopy(*stdset);

         if(!CheckEqualContainers(&shmsetcopy, &stdsetcopy))
            return 1;

         MyShmMultiSet shmmsetcopy(*shmmultiset);
         MyStdMultiSet stdmsetcopy(*stdmultiset);

         if(!CheckEqualContainers(&shmmsetcopy, &stdmsetcopy))
            return 1;

         //And now assignment
         shmsetcopy  = *shmset;
         stdsetcopy  = *stdset;

         if(!CheckEqualContainers(&shmsetcopy, &stdsetcopy))
            return 1;

         shmmsetcopy = *shmmultiset;
         stdmsetcopy = *stdmultiset;

         if(!CheckEqualContainers(&shmmsetcopy, &stdmsetcopy))
            return 1;
      }
      segment.destroy_ptr(shmset);
      segment.destroy_ptr(shmmultiset);
      segment.shrink_to_fit_indexes();
      if(!segment.all_memory_deallocated())
         return 1;
   }
   catch(...){
      shared_memory_object::remove(shMemName);
      throw;
   }
   shared_memory_object::remove(shMemName);
   return 0;
}
Beispiel #4
0
int set_test ()
{
   typedef typename MyShmSet::value_type IntType;
   const int memsize = 65536;
   const char *const shMemName = test::get_process_id_name();
   const int max = 100;

   try{
      //Create shared memory
      shared_memory_object::remove(shMemName);
      ManagedSharedMemory segment(create_only, shMemName, memsize);

      segment.reserve_named_objects(100);

      //Shared memory allocator must be always be initialized
      //since it has no default constructor
      MyShmSet *shmset =
         segment.template construct<MyShmSet>("MyShmSet")
            (std::less<IntType>(), segment.get_segment_manager());

      MyStdSet *stdset = new MyStdSet;

      MyShmMultiSet *shmmultiset =
         segment.template construct<MyShmMultiSet>("MyShmMultiSet")
            (std::less<IntType>(), segment.get_segment_manager());

      MyStdMultiSet *stdmultiset = new MyStdMultiSet;

      //Test construction from a range
      {
         IntType aux_vect[50];
         for(int i = 0; i < 50; ++i){
            IntType move_me(i/2);
            aux_vect[i] = boost::move(move_me);
         }
         int aux_vect2[50];
         for(int i = 0; i < 50; ++i){
            aux_vect2[i] = i/2;
         }
         IntType aux_vect3[50];
         for(int i = 0; i < 50; ++i){
            IntType move_me(i/2);
            aux_vect3[i] = boost::move(move_me);
         }

         MyShmSet *shmset2 =
            segment.template construct<MyShmSet>("MyShmSet2")
               ( ::boost::make_move_iterator(&aux_vect[0])
               , ::boost::make_move_iterator(aux_vect + 50)
               , std::less<IntType>(), segment.get_segment_manager());

         MyStdSet *stdset2 = new MyStdSet(aux_vect2, aux_vect2 + 50);

         MyShmMultiSet *shmmultiset2 =
            segment.template construct<MyShmMultiSet>("MyShmMultiSet2")
               ( ::boost::make_move_iterator(&aux_vect3[0])
               , ::boost::make_move_iterator(aux_vect3 + 50)
               , std::less<IntType>(), segment.get_segment_manager());

         MyStdMultiSet *stdmultiset2 = new MyStdMultiSet(aux_vect2, aux_vect2 + 50);
         if(!CheckEqualContainers(shmset2, stdset2)){
            std::cout << "Error in construct<MyShmSet>(MyShmSet2)" << std::endl;
            return 1;
         }
         if(!CheckEqualContainers(shmmultiset2, stdmultiset2)){
            std::cout << "Error in construct<MyShmMultiSet>(MyShmMultiSet2)" << std::endl;
            return 1;
         }

         //ordered range insertion
         for(int i = 0; i < 50; ++i){
            IntType move_me(i);
            aux_vect[i] = boost::move(move_me);
         }

         for(int i = 0; i < 50; ++i){
            aux_vect2[i] = i;
         }

         for(int i = 0; i < 50; ++i){
            IntType move_me(i);
            aux_vect3[i] = boost::move(move_me);
         }

         MyShmSet *shmset3 =
            segment.template construct<MyShmSet>("MyShmSet3")
               ( ordered_unique_range
               , ::boost::make_move_iterator(&aux_vect[0])
               , ::boost::make_move_iterator(aux_vect + 50)
               , std::less<IntType>(), segment.get_segment_manager());

         MyStdSet *stdset3 = new MyStdSet(aux_vect2, aux_vect2 + 50);

         MyShmMultiSet *shmmultiset3 =
            segment.template construct<MyShmMultiSet>("MyShmMultiSet3")
               ( ordered_range
               , ::boost::make_move_iterator(&aux_vect3[0])
               , ::boost::make_move_iterator(aux_vect3 + 50)
               , std::less<IntType>(), segment.get_segment_manager());

         MyStdMultiSet *stdmultiset3 = new MyStdMultiSet(aux_vect2, aux_vect2 + 50);

         if(!CheckEqualContainers(shmset3, stdset3)){
            std::cout << "Error in construct<MyShmSet>(MyShmSet3)" << std::endl;
            return 1;
         }
         if(!CheckEqualContainers(shmmultiset3, stdmultiset3)){
            std::cout << "Error in construct<MyShmMultiSet>(MyShmMultiSet3)" << std::endl;
            return 1;
         }

         segment.destroy_ptr(shmset2);
         segment.destroy_ptr(shmmultiset2);
         delete stdset2;
         delete stdmultiset2;

         segment.destroy_ptr(shmset3);
         segment.destroy_ptr(shmmultiset3);
         delete stdset3;
         delete stdmultiset3;
      }

      if(!CheckEqualContainers(shmset, stdset)){
         std::cout << "Error in shmset->insert(boost::move(move_me)" << std::endl;
         return 1;
      }

      for(int i = 0; i < max/2; ++i){
         IntType move_me(i);
         shmset->insert(boost::move(move_me));
         stdset->insert(i);
         IntType move_me2(i);
         shmmultiset->insert(boost::move(move_me2));
         stdmultiset->insert(i);

      if(!CheckEqualContainers(shmset, stdset)){
         std::cout << "Error in shmset->insert(boost::move(move_me)" << std::endl;
         return 1;
      }
         //
         shmset->insert(IntType(i));
         stdset->insert(i);
         shmmultiset->insert(IntType(i));
         stdmultiset->insert(i);

      if(!CheckEqualContainers(shmset, stdset)){
         std::cout << "Error in shmset->insert(boost::move(move_me)" << std::endl;
         return 1;
      }

      }

      if(!CheckEqualContainers(shmset, stdset)){
         std::cout << "Error in shmset->insert(boost::move(move_me)" << std::endl;
         return 1;
      }

      if(!CheckEqualContainers(shmmultiset, stdmultiset)){
         std::cout << "Error in shmmultiset->insert(boost::move(move_me)" << std::endl;
         return 1;
      }

      typename MyShmSet::iterator it;
      typename MyShmSet::const_iterator cit = it;
      (void)cit;

      shmset->erase(shmset->begin()++);
      stdset->erase(stdset->begin()++);
      shmmultiset->erase(shmmultiset->begin()++);
      stdmultiset->erase(stdmultiset->begin()++);
      if(!CheckEqualContainers(shmset, stdset)){
         std::cout << "Error in shmset->erase(shmset->begin()++)" << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(shmmultiset, stdmultiset)){
         std::cout << "Error in shmmultiset->erase(shmmultiset->begin()++)" << std::endl;
         return 1;
      }

      shmset->erase(shmset->begin());
      stdset->erase(stdset->begin());
      shmmultiset->erase(shmmultiset->begin());
      stdmultiset->erase(stdmultiset->begin());
      if(!CheckEqualContainers(shmset, stdset)){
         std::cout << "Error in shmset->erase(shmset->begin())" << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(shmmultiset, stdmultiset)){
         std::cout << "Error in shmmultiset->erase(shmmultiset->begin())" << std::endl;
         return 1;
      }

      //Swapping test
      std::less<IntType> lessfunc;
      MyShmSet tmpshmeset2 (lessfunc, segment.get_segment_manager());
      MyStdSet tmpstdset2;
      MyShmMultiSet tmpshmemultiset2(lessfunc, segment.get_segment_manager());
      MyStdMultiSet tmpstdmultiset2;
      shmset->swap(tmpshmeset2);
      stdset->swap(tmpstdset2);
      shmmultiset->swap(tmpshmemultiset2);
      stdmultiset->swap(tmpstdmultiset2);
      shmset->swap(tmpshmeset2);
      stdset->swap(tmpstdset2);
      shmmultiset->swap(tmpshmemultiset2);
      stdmultiset->swap(tmpstdmultiset2);
      if(!CheckEqualContainers(shmset, stdset)){
         std::cout << "Error in shmset->swap(tmpshmeset2)" << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(shmmultiset, stdmultiset)){
         std::cout << "Error in shmmultiset->swap(tmpshmemultiset2)" << std::endl;
         return 1;
      }

      //Insertion from other container
      //Initialize values
      {
         IntType aux_vect[50];
         for(int i = 0; i < 50; ++i){
            IntType move_me(-1);
            aux_vect[i] = boost::move(move_me);
         }
         int aux_vect2[50];
         for(int i = 0; i < 50; ++i){
            aux_vect2[i] = -1;
         }
         IntType aux_vect3[50];
         for(int i = 0; i < 50; ++i){
            IntType move_me(-1);
            aux_vect3[i] = boost::move(move_me);
         }

         shmset->insert(::boost::make_move_iterator(&aux_vect[0]), ::boost::make_move_iterator(aux_vect + 50));
         stdset->insert(aux_vect2, aux_vect2 + 50);
         shmmultiset->insert(::boost::make_move_iterator(&aux_vect3[0]), ::boost::make_move_iterator(aux_vect3 + 50));
         stdmultiset->insert(aux_vect2, aux_vect2 + 50);
         if(!CheckEqualContainers(shmset, stdset)){
            std::cout << "Error in shmset->insert(::boost::make_move_iterator(&aux_vect[0])..." << std::endl;
            return 1;
         }
         if(!CheckEqualContainers(shmmultiset, stdmultiset)){
            std::cout << "Error in shmmultiset->insert(::boost::make_move_iterator(&aux_vect3[0]), ..." << std::endl;
            return 1;
         }

         for(int i = 0, j = static_cast<int>(shmset->size()); i < j; ++i){
            IntType erase_me(i);
            shmset->erase(erase_me);
            stdset->erase(i);
            shmmultiset->erase(erase_me);
            stdmultiset->erase(i);
            if(!CheckEqualContainers(shmset, stdset)){
               std::cout << "Error in shmset->erase(erase_me)" << shmset->size() << " " << stdset->size() << std::endl;
               return 1;
            }
            if(!CheckEqualContainers(shmmultiset, stdmultiset)){
               std::cout << "Error in shmmultiset->erase(erase_me)" << std::endl;
               return 1;
            }
         }
      }
      {
         IntType aux_vect[50];
         for(int i = 0; i < 50; ++i){
            IntType move_me(-1);
            aux_vect[i] = boost::move(move_me);
         }
         int aux_vect2[50];
         for(int i = 0; i < 50; ++i){
            aux_vect2[i] = -1;
         }
         IntType aux_vect3[50];
         for(int i = 0; i < 50; ++i){
            IntType move_me(-1);
            aux_vect3[i] = boost::move(move_me);
         }

         IntType aux_vect4[50];
         for(int i = 0; i < 50; ++i){
            IntType move_me(-1);
            aux_vect4[i] = boost::move(move_me);
         }

         IntType aux_vect5[50];
         for(int i = 0; i < 50; ++i){
            IntType move_me(-1);
            aux_vect5[i] = boost::move(move_me);
         }

         shmset->insert(::boost::make_move_iterator(&aux_vect[0]), ::boost::make_move_iterator(aux_vect + 50));
         shmset->insert(::boost::make_move_iterator(&aux_vect3[0]), ::boost::make_move_iterator(aux_vect3 + 50));
         stdset->insert(aux_vect2, aux_vect2 + 50);
         stdset->insert(aux_vect2, aux_vect2 + 50);
         shmmultiset->insert(::boost::make_move_iterator(&aux_vect4[0]), ::boost::make_move_iterator(aux_vect4 + 50));
         shmmultiset->insert(::boost::make_move_iterator(&aux_vect5[0]), ::boost::make_move_iterator(aux_vect5 + 50));
         stdmultiset->insert(aux_vect2, aux_vect2 + 50);
         stdmultiset->insert(aux_vect2, aux_vect2 + 50);
         if(!CheckEqualContainers(shmset, stdset)){
            std::cout << "Error in shmset->insert(::boost::make_move_iterator(&aux_vect3[0])..." << std::endl;
            return 1;
         }
         if(!CheckEqualContainers(shmmultiset, stdmultiset)){
            std::cout << "Error in shmmultiset->insert(::boost::make_move_iterator(&aux_vect5[0])..." << std::endl;
            return 1;
         }

         shmset->erase(*shmset->begin());
         stdset->erase(*stdset->begin());
         shmmultiset->erase(*shmmultiset->begin());
         stdmultiset->erase(*stdmultiset->begin());
         if(!CheckEqualContainers(shmset, stdset)){
            std::cout << "Error in shmset->erase(*shmset->begin())" << std::endl;
            return 1;
         }
         if(!CheckEqualContainers(shmmultiset, stdmultiset)){
            std::cout << "Error in shmmultiset->erase(*shmmultiset->begin())" << std::endl;
            return 1;
         }
      }

      for(int i = 0; i < max/2; ++i){
         IntType move_me(i);
         shmset->insert(shmset->begin(), boost::move(move_me));
         stdset->insert(stdset->begin(), i);
         IntType move_me2(i);
         shmmultiset->insert(shmmultiset->begin(), boost::move(move_me2));
         stdmultiset->insert(stdmultiset->begin(), i);
         //
         shmset->insert(shmset->begin(), IntType(i));
         stdset->insert(stdset->begin(), i);
         shmmultiset->insert(shmmultiset->begin(), IntType(i));
         stdmultiset->insert(stdmultiset->begin(), i);
      }

      if(!CheckEqualContainers(shmset, stdset)){
         std::cout << "Error in shmset->insert(boost::move(move_me)) try 2" << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(shmmultiset, stdmultiset)){
         std::cout << "Error in shmmultiset->insert(boost::move(move_me2)) try 2" << std::endl;
         return 1;
      }

      for(int i = 0; i < max; ++i){
         {
            IntType move_me(i);
            shmset->insert(shmset->begin(), boost::move(move_me));
            stdset->insert(stdset->begin(), i);
            //PrintContainers(shmset, stdset);
            IntType move_me2(i);
            shmmultiset->insert(shmmultiset->begin(), boost::move(move_me2));
            stdmultiset->insert(stdmultiset->begin(), i);
            //PrintContainers(shmmultiset, stdmultiset);
            if(!CheckEqualContainers(shmset, stdset)){
               std::cout << "Error in shmset->insert(shmset->begin(), boost::move(move_me))" << std::endl;
               return 1;
            }
            if(!CheckEqualContainers(shmmultiset, stdmultiset)){
               std::cout << "Error in shmmultiset->insert(shmmultiset->begin(), boost::move(move_me2))" << std::endl;
               return 1;
            }

            IntType move_me3(i);
            shmset->insert(shmset->end(), boost::move(move_me3));
            stdset->insert(stdset->end(), i);
            IntType move_me4(i);
            shmmultiset->insert(shmmultiset->end(), boost::move(move_me4));
            stdmultiset->insert(stdmultiset->end(), i);
            if(!CheckEqualContainers(shmset, stdset)){
               std::cout << "Error in shmset->insert(shmset->end(), boost::move(move_me3))" << std::endl;
               return 1;
            }
            if(!CheckEqualContainers(shmmultiset, stdmultiset)){
               std::cout << "Error in shmmultiset->insert(shmmultiset->end(), boost::move(move_me4))" << std::endl;
               return 1;
            }
         }
         {
            IntType move_me(i);
            shmset->insert(shmset->upper_bound(move_me), boost::move(move_me));
            stdset->insert(stdset->upper_bound(i), i);
            //PrintContainers(shmset, stdset);
            IntType move_me2(i);
            shmmultiset->insert(shmmultiset->upper_bound(move_me2), boost::move(move_me2));
            stdmultiset->insert(stdmultiset->upper_bound(i), i);
            //PrintContainers(shmmultiset, stdmultiset);
            if(!CheckEqualContainers(shmset, stdset)){
               std::cout << "Error in shmset->insert(shmset->upper_bound(move_me), boost::move(move_me))" << std::endl;
               return 1;
            }
            if(!CheckEqualContainers(shmmultiset, stdmultiset)){
               std::cout << "Error in shmmultiset->insert(shmmultiset->upper_bound(move_me2), boost::move(move_me2))" << std::endl;
               return 1;
            }
         }
         {
            IntType move_me(i);
            IntType move_me2(i);
            shmset->insert(shmset->lower_bound(move_me), boost::move(move_me2));
            stdset->insert(stdset->lower_bound(i), i);
            //PrintContainers(shmset, stdset);
            move_me2 = i;
            shmmultiset->insert(shmmultiset->lower_bound(move_me2), boost::move(move_me2));
            stdmultiset->insert(stdmultiset->lower_bound(i), i);
            //PrintContainers(shmmultiset, stdmultiset);
            if(!CheckEqualContainers(shmset, stdset)){
               std::cout << "Error in shmset->insert(shmset->lower_bound(move_me), boost::move(move_me2))" << std::endl;
               return 1;
            }
            if(!CheckEqualContainers(shmmultiset, stdmultiset)){
               std::cout << "Error in shmmultiset->insert(shmmultiset->lower_bound(move_me2), boost::move(move_me2))" << std::endl;
               return 1;
            }
         }
      }

      //Compare count with std containers
      for(int i = 0; i < max; ++i){
         IntType count_me(i);
         if(shmset->count(count_me) != stdset->count(i)){
            return -1;
         }
         if(shmmultiset->count(count_me) != stdmultiset->count(i)){
            return -1;
         }
      }

      //Now do count exercise
      shmset->erase(shmset->begin(), shmset->end());
      shmmultiset->erase(shmmultiset->begin(), shmmultiset->end());
      shmset->clear();
      shmmultiset->clear();

      for(int j = 0; j < 3; ++j)
      for(int i = 0; i < 100; ++i){
         IntType move_me(i);
         shmset->insert(boost::move(move_me));
         IntType move_me2(i);
         shmmultiset->insert(boost::move(move_me2));
         IntType count_me(i);
         if(shmset->count(count_me) != typename MyShmMultiSet::size_type(1)){
            std::cout << "Error in shmset->count(count_me)" << std::endl;
            return 1;
         }
         if(shmmultiset->count(count_me) != typename MyShmMultiSet::size_type(j+1)){
            std::cout << "Error in shmmultiset->count(count_me)" << std::endl;
            return 1;
         }
      }

      segment.template destroy<MyShmSet>("MyShmSet");
      delete stdset;
      segment.destroy_ptr(shmmultiset);
      delete stdmultiset;
      segment.shrink_to_fit_indexes();

      if(!segment.all_memory_deallocated()){
         std::cout << "Error in segment.all_memory_deallocated()" << std::endl;
         return 1;
      }
   }
   catch(...){
      shared_memory_object::remove(shMemName);
      throw;
   }
   shared_memory_object::remove(shMemName);
   return 0;
}
Beispiel #5
0
int set_test ()
{
   typedef typename MyBoostSet::value_type IntType;
   const int max = 100;

   //Shared memory allocator must be always be initialized
   //since it has no default constructor
   MyBoostSet *boostset = new MyBoostSet;
   MyStdSet *stdset = new MyStdSet;
   MyBoostMultiSet *boostmultiset = new MyBoostMultiSet;
   MyStdMultiSet *stdmultiset = new MyStdMultiSet;

   //Test construction from a range  
   {
      IntType aux_vect[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(i/2);
         aux_vect[i] = boost::move(move_me);
      }
      int aux_vect2[50];
      for(int i = 0; i < 50; ++i){
         aux_vect2[i] = i/2;
      }
      IntType aux_vect3[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(i/2);
         aux_vect3[i] = boost::move(move_me);
      }

      MyBoostSet *boostset2 = new MyBoostSet
            ( boost::make_move_iterator(&aux_vect[0])
            , boost::make_move_iterator(aux_vect + 50));
      MyStdSet *stdset2 = new MyStdSet(aux_vect2, aux_vect2 + 50);
      MyBoostMultiSet *boostmultiset2 = new MyBoostMultiSet
            ( boost::make_move_iterator(&aux_vect3[0])
            , boost::make_move_iterator(aux_vect3 + 50));
      MyStdMultiSet *stdmultiset2 = new MyStdMultiSet(aux_vect2, aux_vect2 + 50);
      if(!CheckEqualContainers(boostset2, stdset2)){
         std::cout << "Error in construct<MyBoostSet>(MyBoostSet2)" << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(boostmultiset2, stdmultiset2)){
         std::cout << "Error in construct<MyBoostMultiSet>(MyBoostMultiSet2)" << std::endl;
         return 1;
      }

      //ordered range insertion
      for(int i = 0; i < 50; ++i){
         IntType move_me(i);
         aux_vect[i] = boost::move(move_me);
      }

      for(int i = 0; i < 50; ++i){
         aux_vect2[i] = i;
      }

      for(int i = 0; i < 50; ++i){
         IntType move_me(i);
         aux_vect3[i] = boost::move(move_me);
      }

      MyBoostSet *boostset3 = new MyBoostSet
            ( ordered_unique_range
            , boost::make_move_iterator(&aux_vect[0])
            , boost::make_move_iterator(aux_vect + 50));
      MyStdSet *stdset3 = new MyStdSet(aux_vect2, aux_vect2 + 50);
      MyBoostMultiSet *boostmultiset3 = new MyBoostMultiSet
            ( ordered_range
            , boost::make_move_iterator(&aux_vect3[0])
            , boost::make_move_iterator(aux_vect3 + 50));
      MyStdMultiSet *stdmultiset3 = new MyStdMultiSet(aux_vect2, aux_vect2 + 50);

      if(!CheckEqualContainers(boostset3, stdset3)){
         std::cout << "Error in construct<MyBoostSet>(MyBoostSet3)" << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(boostmultiset3, stdmultiset3)){
         std::cout << "Error in construct<MyBoostMultiSet>(MyBoostMultiSet3)" << std::endl;
         return 1;
      }

      delete boostset2;
      delete boostmultiset2;
      delete stdset2;
      delete stdmultiset2;
      delete boostset3;
      delete boostmultiset3;
      delete stdset3;
      delete stdmultiset3;
   }

   for(int i = 0; i < max; ++i){
      IntType move_me(i);
      boostset->insert(boost::move(move_me));
      stdset->insert(i);
      boostset->insert(IntType(i));
      stdset->insert(i);
      IntType move_me2(i);
      boostmultiset->insert(boost::move(move_me2));
      stdmultiset->insert(i);
      boostmultiset->insert(IntType(i));
      stdmultiset->insert(i);
   }

   if(!CheckEqualContainers(boostset, stdset)){
      std::cout << "Error in boostset->insert(boost::move(move_me)" << std::endl;
      return 1;
   }

   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
      std::cout << "Error in boostmultiset->insert(boost::move(move_me)" << std::endl;
      return 1;
   }

   typename MyBoostSet::iterator it;
   typename MyBoostSet::const_iterator cit = it;
   (void)cit;

   boostset->erase(boostset->begin()++);
   stdset->erase(stdset->begin()++);
   boostmultiset->erase(boostmultiset->begin()++);
   stdmultiset->erase(stdmultiset->begin()++);
   if(!CheckEqualContainers(boostset, stdset)){
      std::cout << "Error in boostset->erase(boostset->begin()++)" << std::endl;
      return 1;
   }
   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
      std::cout << "Error in boostmultiset->erase(boostmultiset->begin()++)" << std::endl;
      return 1;
   }

   boostset->erase(boostset->begin());
   stdset->erase(stdset->begin());
   boostmultiset->erase(boostmultiset->begin());
   stdmultiset->erase(stdmultiset->begin());
   if(!CheckEqualContainers(boostset, stdset)){
      std::cout << "Error in boostset->erase(boostset->begin())" << std::endl;
      return 1;
   }
   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
      std::cout << "Error in boostmultiset->erase(boostmultiset->begin())" << std::endl;
      return 1;
   }

   //Swapping test
   MyBoostSet tmpboosteset2;
   MyStdSet tmpstdset2;
   MyBoostMultiSet tmpboostemultiset2;
   MyStdMultiSet tmpstdmultiset2;
   boostset->swap(tmpboosteset2);
   stdset->swap(tmpstdset2);
   boostmultiset->swap(tmpboostemultiset2);
   stdmultiset->swap(tmpstdmultiset2);
   boostset->swap(tmpboosteset2);
   stdset->swap(tmpstdset2);
   boostmultiset->swap(tmpboostemultiset2);
   stdmultiset->swap(tmpstdmultiset2);
   if(!CheckEqualContainers(boostset, stdset)){
      std::cout << "Error in boostset->swap(tmpboosteset2)" << std::endl;
      return 1;
   }
   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
      std::cout << "Error in boostmultiset->swap(tmpboostemultiset2)" << std::endl;
      return 1;
   }

   //Insertion from other container
   //Initialize values
   {
      IntType aux_vect[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(-1);
         aux_vect[i] = boost::move(move_me);
      }
      int aux_vect2[50];
      for(int i = 0; i < 50; ++i){
         aux_vect2[i] = -1;
      }
      IntType aux_vect3[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(-1);
         aux_vect3[i] = boost::move(move_me);
      }

      boostset->insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(aux_vect + 50));
      stdset->insert(aux_vect2, aux_vect2 + 50);
      boostmultiset->insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(aux_vect3 + 50));
      stdmultiset->insert(aux_vect2, aux_vect2 + 50);
      if(!CheckEqualContainers(boostset, stdset)){
         std::cout << "Error in boostset->insert(boost::make_move_iterator(&aux_vect[0])..." << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
         std::cout << "Error in boostmultiset->insert(boost::make_move_iterator(&aux_vect3[0]), ..." << std::endl;
         return 1;
      }

      for(int i = 0, j = static_cast<int>(boostset->size()); i < j; ++i){
         IntType erase_me(i);
         boostset->erase(erase_me);
         stdset->erase(i);
         boostmultiset->erase(erase_me);
         stdmultiset->erase(i);
         if(!CheckEqualContainers(boostset, stdset)){
            std::cout << "Error in boostset->erase(erase_me)" << boostset->size() << " " << stdset->size() << std::endl;
            return 1;
         }
         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
            std::cout << "Error in boostmultiset->erase(erase_me)" << std::endl;
            return 1;
         }
      }
   }
   {
      IntType aux_vect[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(-1);
         aux_vect[i] = boost::move(move_me);
      }
      int aux_vect2[50];
      for(int i = 0; i < 50; ++i){
         aux_vect2[i] = -1;
      }
      IntType aux_vect3[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(-1);
         aux_vect3[i] = boost::move(move_me);
      }

      IntType aux_vect4[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(-1);
         aux_vect4[i] = boost::move(move_me);
      }

      IntType aux_vect5[50];
      for(int i = 0; i < 50; ++i){
         IntType move_me(-1);
         aux_vect5[i] = boost::move(move_me);
      }

      boostset->insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(aux_vect + 50));
      boostset->insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(aux_vect3 + 50));
      stdset->insert(aux_vect2, aux_vect2 + 50);
      stdset->insert(aux_vect2, aux_vect2 + 50);
      boostmultiset->insert(boost::make_move_iterator(&aux_vect4[0]), boost::make_move_iterator(aux_vect4 + 50));
      boostmultiset->insert(boost::make_move_iterator(&aux_vect5[0]), boost::make_move_iterator(aux_vect5 + 50));
      stdmultiset->insert(aux_vect2, aux_vect2 + 50);
      stdmultiset->insert(aux_vect2, aux_vect2 + 50);
      if(!CheckEqualContainers(boostset, stdset)){
         std::cout << "Error in boostset->insert(boost::make_move_iterator(&aux_vect3[0])..." << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
         std::cout << "Error in boostmultiset->insert(boost::make_move_iterator(&aux_vect5[0])..." << std::endl;
         return 1;
      }

      boostset->erase(*boostset->begin());
      stdset->erase(*stdset->begin());
      boostmultiset->erase(*boostmultiset->begin());
      stdmultiset->erase(*stdmultiset->begin());
      if(!CheckEqualContainers(boostset, stdset)){
         std::cout << "Error in boostset->erase(*boostset->begin())" << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
         std::cout << "Error in boostmultiset->erase(*boostmultiset->begin())" << std::endl;
         return 1;
      }
   }

   for(int i = 0; i < max; ++i){
      IntType move_me(i);
      boostset->insert(boost::move(move_me));
      stdset->insert(i);
      IntType move_me2(i);
      boostmultiset->insert(boost::move(move_me2));
      stdmultiset->insert(i);
   }

   if(!CheckEqualContainers(boostset, stdset)){
      std::cout << "Error in boostset->insert(boost::move(move_me)) try 2" << std::endl;
      return 1;
   }
   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
      std::cout << "Error in boostmultiset->insert(boost::move(move_me2)) try 2" << std::endl;
      return 1;
   }

   for(int i = 0; i < max; ++i){
      {
         IntType move_me(i);
         boostset->insert(boostset->begin(), boost::move(move_me));
         stdset->insert(stdset->begin(), i);
         //PrintContainers(boostset, stdset);
         IntType move_me2(i);
         boostmultiset->insert(boostmultiset->begin(), boost::move(move_me2));
         stdmultiset->insert(stdmultiset->begin(), i);
         //PrintContainers(boostmultiset, stdmultiset);
         if(!CheckEqualContainers(boostset, stdset)){
            std::cout << "Error in boostset->insert(boostset->begin(), boost::move(move_me))" << std::endl;
            return 1;
         }
         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
            std::cout << "Error in boostmultiset->insert(boostmultiset->begin(), boost::move(move_me2))" << std::endl;
            return 1;
         }

         IntType move_me3(i);
         boostset->insert(boostset->end(), boost::move(move_me3));
         stdset->insert(stdset->end(), i);
         IntType move_me4(i);
         boostmultiset->insert(boostmultiset->end(), boost::move(move_me4));
         stdmultiset->insert(stdmultiset->end(), i);
         if(!CheckEqualContainers(boostset, stdset)){
            std::cout << "Error in boostset->insert(boostset->end(), boost::move(move_me3))" << std::endl;
            return 1;
         }
         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
            std::cout << "Error in boostmultiset->insert(boostmultiset->end(), boost::move(move_me4))" << std::endl;
            return 1;
         }
      }
      {
      IntType move_me(i);
      boostset->insert(boostset->upper_bound(move_me), boost::move(move_me));
      stdset->insert(stdset->upper_bound(i), i);
      //PrintContainers(boostset, stdset);
      IntType move_me2(i);
      boostmultiset->insert(boostmultiset->upper_bound(move_me2), boost::move(move_me2));
      stdmultiset->insert(stdmultiset->upper_bound(i), i);
      //PrintContainers(boostmultiset, stdmultiset);
      if(!CheckEqualContainers(boostset, stdset)){
         std::cout << "Error in boostset->insert(boostset->upper_bound(move_me), boost::move(move_me))" << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
         std::cout << "Error in boostmultiset->insert(boostmultiset->upper_bound(move_me2), boost::move(move_me2))" << std::endl;
         return 1;
      }

      }
      {
      IntType move_me(i);
      IntType move_me2(i);
      boostset->insert(boostset->lower_bound(move_me), boost::move(move_me2));
      stdset->insert(stdset->lower_bound(i), i);
      //PrintContainers(boostset, stdset);
      move_me2 = i;
      boostmultiset->insert(boostmultiset->lower_bound(move_me2), boost::move(move_me2));
      stdmultiset->insert(stdmultiset->lower_bound(i), i);
      //PrintContainers(boostmultiset, stdmultiset);
      if(!CheckEqualContainers(boostset, stdset)){
         std::cout << "Error in boostset->insert(boostset->lower_bound(move_me), boost::move(move_me2))" << std::endl;
         return 1;
      }
      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
         std::cout << "Error in boostmultiset->insert(boostmultiset->lower_bound(move_me2), boost::move(move_me2))" << std::endl;
         return 1;
      }
      }
   }

   //Compare count with std containers
   for(int i = 0; i < max; ++i){
      IntType count_me(i);
      if(boostset->count(count_me) != stdset->count(i)){
         return -1;
      }
      if(boostmultiset->count(count_me) != stdmultiset->count(i)){
         return -1;
      }
   }

   //Now do count exercise
   boostset->erase(boostset->begin(), boostset->end());
   boostmultiset->erase(boostmultiset->begin(), boostmultiset->end());
   boostset->clear();
   boostmultiset->clear();

   for(int j = 0; j < 3; ++j)
   for(int i = 0; i < 100; ++i){
      IntType move_me(i);
      boostset->insert(boost::move(move_me));
      IntType move_me2(i);
      boostmultiset->insert(boost::move(move_me2));
      IntType count_me(i);
      if(boostset->count(count_me) != typename MyBoostMultiSet::size_type(1)){
         std::cout << "Error in boostset->count(count_me)" << std::endl;
         return 1;
      }
      if(boostmultiset->count(count_me) != typename MyBoostMultiSet::size_type(j+1)){
         std::cout << "Error in boostmultiset->count(count_me)" << std::endl;
         return 1;
      }
   }

   delete boostset;
   delete stdset;
   delete boostmultiset;
   delete stdmultiset;
   return 0;
}