示例#1
0
int list_test (bool copied_allocators_equal = true)
{
   typedef std::list<int> MyStdList;
   typedef typename MyBoostList::value_type IntType;
   const int max = 100;
   typedef list_push_data_function<DoublyLinked> push_data_t;

   BOOST_TRY{
      MyBoostList *boostlist = new MyBoostList;
      MyStdList *stdlist = new MyStdList;

      if(push_data_t::execute(max, boostlist, stdlist)){
         return 1;
      }

      boostlist->erase(boostlist->begin()++);
      stdlist->erase(stdlist->begin()++);
      if(!CheckEqualContainers(boostlist, stdlist)) return 1;

      if(list_pop_back_function<DoublyLinked>::execute(boostlist, stdlist)){
         return 1;
      }

      boostlist->pop_front();
      stdlist->pop_front();
      if(!CheckEqualContainers(boostlist, stdlist)) 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;
         }
         boostlist->assign(boost::make_move_iterator(&aux_vect[0])
                          ,boost::make_move_iterator(&aux_vect[50]));
         stdlist->assign(&aux_vect2[0], &aux_vect2[50]);
         if(!CheckEqualContainers(boostlist, stdlist)) return 1;

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

         for(int i = 0; i < 50; ++i){
            aux_vect2[i] = -1;
         }
         boostlist->assign(boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[0]))
                          ,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[50])));
         stdlist->assign(&aux_vect2[0], &aux_vect2[50]);
         if(!CheckEqualContainers(boostlist, stdlist)) return 1;
      }

      if(copied_allocators_equal){
         boostlist->sort();
         stdlist->sort();
         if(!CheckEqualContainers(boostlist, stdlist)) return 1;
      }

      boostlist->reverse();
      stdlist->reverse();
      if(!CheckEqualContainers(boostlist, stdlist)) return 1;

      boostlist->reverse();
      stdlist->reverse();
      if(!CheckEqualContainers(boostlist, stdlist)) 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;
         }
         typename MyBoostList::iterator old_begin = boostlist->begin();
         typename MyBoostList::iterator it_insert =
            boostlist->insert(boostlist->begin()
                        ,boost::make_move_iterator(&aux_vect[0])
                        ,boost::make_move_iterator(&aux_vect[50]));
         if(it_insert != boostlist->begin() || std::distance(it_insert, old_begin) != 50)
            return 1;

         stdlist->insert(stdlist->begin(), &aux_vect2[0], &aux_vect2[50]);
         if(!CheckEqualContainers(boostlist, stdlist))
            return 1;

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

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

         old_begin = boostlist->begin();
         it_insert = boostlist->insert(boostlist->end()
                        ,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[0]))
                        ,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[50])));
         if(std::distance(it_insert, boostlist->end()) != 50)
            return 1;
         stdlist->insert(stdlist->end(), &aux_vect2[0], &aux_vect2[50]);
         if(!CheckEqualContainers(boostlist, stdlist))
            return 1;
      }

      boostlist->unique();
      stdlist->unique();
      if(!CheckEqualContainers(boostlist, stdlist))
         return 1;

      if(copied_allocators_equal){
         boostlist->sort(std::greater<IntType>());
         stdlist->sort(std::greater<int>());
         if(!CheckEqualContainers(boostlist, stdlist))
            return 1;
      }

      for(int i = 0; i < max; ++i){
         IntType new_int(i);
         boostlist->insert(boostlist->end(), boost::move(new_int));
         stdlist->insert(stdlist->end(), i);
         if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
      }
      if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;

      boostlist->resize(25);
      stdlist->resize(25);
      boostlist->resize(50);
      stdlist->resize(50);
      boostlist->resize(0);
      stdlist->resize(0);
      if(!CheckEqualContainers(boostlist, stdlist))
         return 1;

      if(push_data_t::execute(max, boostlist, stdlist)){
         return 1;
      }
      {
         MyBoostList otherboostlist(boostlist->get_allocator());
         MyStdList otherstdlist;

         int listsize = (int)boostlist->size();

         if(push_data_t::execute(listsize, boostlist, stdlist)){
            return 1;
         }

         if(copied_allocators_equal){
            boostlist->splice(boostlist->begin(), otherboostlist);
            stdlist->splice(stdlist->begin(), otherstdlist);
            if(!CheckEqualContainers(boostlist, stdlist))
               return 1;  
         }

         listsize = (int)boostlist->size();

         if(push_data_t::execute(listsize, boostlist, stdlist)){
            return 1;
         }

         if(push_data_t::execute(listsize, &otherboostlist, &otherstdlist)){
            return 1;
         }

         if(copied_allocators_equal){
            boostlist->sort(std::greater<IntType>());
            stdlist->sort(std::greater<int>());
            if(!CheckEqualContainers(boostlist, stdlist))
               return 1;

            otherboostlist.sort(std::greater<IntType>());
            otherstdlist.sort(std::greater<int>());
            if(!CheckEqualContainers(&otherboostlist, &otherstdlist))
               return 1;

            boostlist->merge(otherboostlist, std::greater<IntType>());
            stdlist->merge(otherstdlist, std::greater<int>());
            if(!CheckEqualContainers(boostlist, stdlist))
               return 1;
         }

         if(!list_copyable_only(boostlist, stdlist
                        ,container_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
            return 1;
         }
      }

      delete boostlist;
      delete stdlist;
   }
   BOOST_CATCH(...){
      BOOST_RETHROW;
   }
   BOOST_CATCH_END
   return 0;
}
int list_test (bool copied_allocators_equal = true)
{
   typedef std::list<int> MyStdList;
   typedef typename MyShmList::value_type IntType;
   const int memsize = 65536;
   const char *const shMemName = test::get_process_id_name();
   const int max = 100;
   typedef push_data_function<DoublyLinked> push_data_t;

   try{
      //Named new capable shared mem allocator
      //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
      MyShmList *shmlist = segment.template construct<MyShmList>("MyList")
                              (segment.get_segment_manager());


      MyStdList *stdlist = new MyStdList;

      if(push_data_t::execute(max, shmlist, stdlist)){
         return 1;
      }

      shmlist->erase(shmlist->begin()++);
      stdlist->erase(stdlist->begin()++);
      if(!CheckEqualContainers(shmlist, stdlist)) return 1;

      if(pop_back_function<DoublyLinked>::execute(shmlist, stdlist)){
         return 1;
      }

      shmlist->pop_front();
      stdlist->pop_front();
      if(!CheckEqualContainers(shmlist, stdlist)) return 1;

      {
         IntType aux_vect[50];
         for(int i = 0; i < 50; ++i){
            IntType move_me(-1);
            aux_vect[i] = boost::interprocess::move(move_me);
         }
         int aux_vect2[50];
         for(int i = 0; i < 50; ++i){
            aux_vect2[i] = -1;
         }
         shmlist->assign(boost::interprocess::make_move_iterator(&aux_vect[0])
                        ,boost::interprocess::make_move_iterator(&aux_vect[50]));
         stdlist->assign(&aux_vect2[0], &aux_vect2[50]);
         if(!CheckEqualContainers(shmlist, stdlist)) return 1;
      }

      if(copied_allocators_equal){
         shmlist->sort();
         stdlist->sort();
         if(!CheckEqualContainers(shmlist, stdlist)) return 1;
      }

      shmlist->reverse();
      stdlist->reverse();
      if(!CheckEqualContainers(shmlist, stdlist)) return 1;

      shmlist->reverse();
      stdlist->reverse();
      if(!CheckEqualContainers(shmlist, stdlist)) return 1;

      {
         IntType aux_vect[50];
         for(int i = 0; i < 50; ++i){
            IntType move_me(-1);
            aux_vect[i] = boost::interprocess::move(move_me);
         }
         int aux_vect2[50];
         for(int i = 0; i < 50; ++i){
            aux_vect2[i] = -1;
         }
         shmlist->insert(shmlist->begin()
                        ,boost::interprocess::make_move_iterator(&aux_vect[0])
                        ,boost::interprocess::make_move_iterator(&aux_vect[50]));
         stdlist->insert(stdlist->begin(), &aux_vect2[0], &aux_vect2[50]);
      }

      shmlist->unique();
      stdlist->unique();
      if(!CheckEqualContainers(shmlist, stdlist))
         return 1;

      if(copied_allocators_equal){
         shmlist->sort(std::greater<IntType>());
         stdlist->sort(std::greater<int>());
         if(!CheckEqualContainers(shmlist, stdlist))
            return 1;
      }

      shmlist->resize(25);
      stdlist->resize(25);
      shmlist->resize(50);
      stdlist->resize(50);
      shmlist->resize(0);
      stdlist->resize(0);
      if(!CheckEqualContainers(shmlist, stdlist))
         return 1;

      if(push_data_t::execute(max, shmlist, stdlist)){
         return 1;
      }
      {
         MyShmList othershmlist(shmlist->get_allocator());
         MyStdList otherstdlist;

         int listsize = (int)shmlist->size();

         if(push_data_t::execute(listsize, shmlist, stdlist)){
            return 1;
         }

         if(copied_allocators_equal){
            shmlist->splice(shmlist->begin(), othershmlist);
            stdlist->splice(stdlist->begin(), otherstdlist);
            if(!CheckEqualContainers(shmlist, stdlist))
               return 1;   
         }

         listsize = (int)shmlist->size();

         if(push_data_t::execute(listsize, shmlist, stdlist)){
            return 1;
         }

         if(push_data_t::execute(listsize, &othershmlist, &otherstdlist)){
            return 1;
         }

         if(copied_allocators_equal){
            shmlist->sort(std::greater<IntType>());
            stdlist->sort(std::greater<int>());
            if(!CheckEqualContainers(shmlist, stdlist))
               return 1;

            othershmlist.sort(std::greater<IntType>());
            otherstdlist.sort(std::greater<int>());
            if(!CheckEqualContainers(&othershmlist, &otherstdlist))
               return 1;

            shmlist->merge(othershmlist, std::greater<IntType>());
            stdlist->merge(otherstdlist, std::greater<int>());
            if(!CheckEqualContainers(shmlist, stdlist))
               return 1;
         }
      }

      segment.template destroy<MyShmList>("MyList");
      delete stdlist;
      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;
}
示例#3
0
int list_test (bool copied_allocators_equal = true)
{
   typedef std::list<int> MyStdList;
   typedef typename MyShmList::value_type IntType;
   const int max = 100;
   typedef list_push_data_function<DoublyLinked> push_data_t;

   try{
      MyShmList *shmlist = new MyShmList;
      MyStdList *stdlist = new MyStdList;

      if(push_data_t::execute(max, shmlist, stdlist)){
         return 1;
      }

      shmlist->erase(shmlist->begin()++);
      stdlist->erase(stdlist->begin()++);
      if(!CheckEqualContainers(shmlist, stdlist)) return 1;

      if(list_pop_back_function<DoublyLinked>::execute(shmlist, stdlist)){
         return 1;
      }

      shmlist->pop_front();
      stdlist->pop_front();
      if(!CheckEqualContainers(shmlist, stdlist)) 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;
         }
         shmlist->assign(boost::make_move_iterator(&aux_vect[0])
                        ,boost::make_move_iterator(&aux_vect[50]));
         stdlist->assign(&aux_vect2[0], &aux_vect2[50]);
         if(!CheckEqualContainers(shmlist, stdlist)) return 1;
      }

      if(copied_allocators_equal){
         shmlist->sort();
         stdlist->sort();
         if(!CheckEqualContainers(shmlist, stdlist)) return 1;
      }

      shmlist->reverse();
      stdlist->reverse();
      if(!CheckEqualContainers(shmlist, stdlist)) return 1;

      shmlist->reverse();
      stdlist->reverse();
      if(!CheckEqualContainers(shmlist, stdlist)) 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;
         }
         shmlist->insert(shmlist->begin()
                        ,boost::make_move_iterator(&aux_vect[0])
                        ,boost::make_move_iterator(&aux_vect[50]));
         stdlist->insert(stdlist->begin(), &aux_vect2[0], &aux_vect2[50]);
      }

      shmlist->unique();
      stdlist->unique();
      if(!CheckEqualContainers(shmlist, stdlist))
         return 1;

      if(copied_allocators_equal){
         shmlist->sort(std::greater<IntType>());
         stdlist->sort(std::greater<int>());
         if(!CheckEqualContainers(shmlist, stdlist))
            return 1;
      }

      for(int i = 0; i < max; ++i){
         IntType new_int(i);
         shmlist->insert(shmlist->end(), boost::move(new_int));
         stdlist->insert(stdlist->end(), i);
         if(!test::CheckEqualContainers(shmlist, stdlist)) return 1;
      }
      if(!test::CheckEqualContainers(shmlist, stdlist)) return 1;

      shmlist->resize(25);
      stdlist->resize(25);
      shmlist->resize(50);
      stdlist->resize(50);
      shmlist->resize(0);
      stdlist->resize(0);
      if(!CheckEqualContainers(shmlist, stdlist))
         return 1;

      if(push_data_t::execute(max, shmlist, stdlist)){
         return 1;
      }
      {
         MyShmList othershmlist(shmlist->get_allocator());
         MyStdList otherstdlist;

         int listsize = (int)shmlist->size();

         if(push_data_t::execute(listsize, shmlist, stdlist)){
            return 1;
         }

         if(copied_allocators_equal){
            shmlist->splice(shmlist->begin(), othershmlist);
            stdlist->splice(stdlist->begin(), otherstdlist);
            if(!CheckEqualContainers(shmlist, stdlist))
               return 1;   
         }

         listsize = (int)shmlist->size();

         if(push_data_t::execute(listsize, shmlist, stdlist)){
            return 1;
         }

         if(push_data_t::execute(listsize, &othershmlist, &otherstdlist)){
            return 1;
         }

         if(copied_allocators_equal){
            shmlist->sort(std::greater<IntType>());
            stdlist->sort(std::greater<int>());
            if(!CheckEqualContainers(shmlist, stdlist))
               return 1;

            othershmlist.sort(std::greater<IntType>());
            otherstdlist.sort(std::greater<int>());
            if(!CheckEqualContainers(&othershmlist, &otherstdlist))
               return 1;

            shmlist->merge(othershmlist, std::greater<IntType>());
            stdlist->merge(otherstdlist, std::greater<int>());
            if(!CheckEqualContainers(shmlist, stdlist))
               return 1;
         }

         if(!list_copyable_only(shmlist, stdlist
                        ,containers_detail::bool_<!is_movable<IntType>::value>())){
            return 1;
         }
      }

      delete shmlist;
      delete stdlist;
   }
   catch(...){
      throw;
   }
   return 0;
}