예제 #1
0
int vector_test()
{
   typedef std::vector<int>                     MyStdVector;
   typedef typename MyBoostVector::value_type     IntType;
   const int max = 100;

   {
      try{
         MyBoostVector *boostvector = new MyBoostVector;
         MyStdVector *stdvector = new MyStdVector;
         boostvector->resize(100);
         stdvector->resize(100);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;         

         boostvector->resize(200);
         stdvector->resize(200);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;         

         boostvector->resize(0);
         stdvector->resize(0);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;         

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

         typename MyBoostVector::iterator boostit(boostvector->begin());
         typename MyStdVector::iterator stdit(stdvector->begin());
         typename MyBoostVector::const_iterator cboostit = boostit;
         ++boostit; ++stdit;
         boostvector->erase(boostit);
         stdvector->erase(stdit);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         boostvector->erase(boostvector->begin());
         stdvector->erase(stdvector->begin());
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         {
            //Initialize values
            IntType aux_vect[50];
            for(int i = 0; i < 50; ++i){
               IntType new_int(-1);
               BOOST_STATIC_ASSERT((boost::container::test::is_copyable<boost::container::test::movable_int>::value == false));
               aux_vect[i] = boost::move(new_int);
            }
            int aux_vect2[50];
            for(int i = 0; i < 50; ++i){
               aux_vect2[i] = -1;
            }

            boostvector->insert(boostvector->end()
                              ,boost::make_move_iterator(&aux_vect[0])
                              ,boost::make_move_iterator(aux_vect + 50));
            stdvector->insert(stdvector->end(), aux_vect2, aux_vect2 + 50);
            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

            for(int i = 0, j = static_cast<int>(boostvector->size()); i < j; ++i){
               boostvector->erase(boostvector->begin());
               stdvector->erase(stdvector->begin());
            }
            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
         }
         {
            IntType aux_vect[50];
            for(int i = 0; i < 50; ++i){
               IntType new_int(-1);
               aux_vect[i] = boost::move(new_int);
            }
            int aux_vect2[50];
            for(int i = 0; i < 50; ++i){
               aux_vect2[i] = -1;
            }
            boostvector->insert(boostvector->begin()
                              ,boost::make_move_iterator(&aux_vect[0])
                              ,boost::make_move_iterator(aux_vect + 50));
            stdvector->insert(stdvector->begin(), aux_vect2, aux_vect2 + 50);
            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
         }
/*
         boostvector->reserve(boostvector->size()*2);
         stdvector->reserve(stdvector->size()*2);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
*/
         boostvector->shrink_to_fit();
         MyStdVector(*stdvector).swap(*stdvector);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         boostvector->shrink_to_fit();
         MyStdVector(*stdvector).swap(*stdvector);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         IntType push_back_this(1);
         boostvector->push_back(boost::move(push_back_this));
         stdvector->push_back(int(1));
         boostvector->push_back(IntType(1));
         stdvector->push_back(int(1));

         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         if(!vector_copyable_only(boostvector, stdvector
                        ,containers_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
            return 1;
         }

         boostvector->erase(boostvector->begin());
         stdvector->erase(stdvector->begin());
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         for(int i = 0; i < max; ++i){
            IntType insert_this(i);
            boostvector->insert(boostvector->begin(), boost::move(insert_this));
            stdvector->insert(stdvector->begin(), i);
            boostvector->insert(boostvector->begin(), IntType(i));
            stdvector->insert(stdvector->begin(), int(i));
         }
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         //Test insertion from list
         {
            std::list<int> l(50, int(1));
            boostvector->insert(boostvector->begin(), l.begin(), l.end());
            stdvector->insert(stdvector->begin(), l.begin(), l.end());
            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
            boostvector->assign(l.begin(), l.end());
            stdvector->assign(l.begin(), l.end());
            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
         }
/*
         std::size_t cap = boostvector->capacity();
         boostvector->reserve(cap*2);
         stdvector->reserve(cap*2);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
         boostvector->resize(0);
         stdvector->resize(0);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         boostvector->resize(cap*2);
         stdvector->resize(cap*2);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         boostvector->clear();
         stdvector->clear();
         boostvector->shrink_to_fit();
         MyStdVector(*stdvector).swap(*stdvector);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         boostvector->resize(cap*2);
         stdvector->resize(cap*2);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
*/

         delete stdvector;
         delete boostvector;
      }
      catch(std::exception &ex){
         std::cout << ex.what() << std::endl;
         return 1;
      }
   }
   std::cout << std::endl << "Test OK!" << std::endl;
   return 0;
}
예제 #2
0
int vector_test()
{
   typedef std::vector<int>                     MyStdVector;
   typedef typename MyBoostVector::value_type   IntType;
   const int max = 100;

   if(!test_range_insertion<MyBoostVector>()){
      return 1;
   }

   {
      BOOST_TRY{
         MyBoostVector *boostvector = new MyBoostVector;
         MyStdVector *stdvector = new MyStdVector;
         boostvector->resize(100);
         stdvector->resize(100);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;        

         boostvector->resize(200);
         stdvector->resize(200);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;        

         boostvector->resize(0);
         stdvector->resize(0);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;        

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

         typename MyBoostVector::iterator boostit(boostvector->begin());
         typename MyStdVector::iterator stdit(stdvector->begin());
         typename MyBoostVector::const_iterator cboostit = boostit;
         (void)cboostit;
         ++boostit; ++stdit;
         boostvector->erase(boostit);
         stdvector->erase(stdit);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         boostvector->erase(boostvector->begin());
         stdvector->erase(stdvector->begin());
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         {
            //Initialize values
            IntType aux_vect[50];
            for(int i = 0; i < 50; ++i){
               IntType new_int(-1);
               BOOST_STATIC_ASSERT((boost::container::test::is_copyable<boost::container::test::movable_int>::value == false));
               aux_vect[i] = boost::move(new_int);
            }
            int aux_vect2[50];
            for(int i = 0; i < 50; ++i){
               aux_vect2[i] = -1;
            }
            typename MyBoostVector::iterator insert_it =
               boostvector->insert(boostvector->end()
                              ,boost::make_move_iterator(&aux_vect[0])
                              ,boost::make_move_iterator(aux_vect + 50));
            if(std::size_t(std::distance(insert_it, boostvector->end())) != 50) return 1;
            stdvector->insert(stdvector->end(), aux_vect2, aux_vect2 + 50);
            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

            for(int i = 0, j = static_cast<int>(boostvector->size()); i < j; ++i){
               boostvector->erase(boostvector->begin());
               stdvector->erase(stdvector->begin());
            }
            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
         }
         {
            boostvector->resize(100);
            stdvector->resize(100);
            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

            IntType aux_vect[50];
            for(int i = 0; i < 50; ++i){
               IntType new_int(-i);
               aux_vect[i] = boost::move(new_int);
            }
            int aux_vect2[50];
            for(int i = 0; i < 50; ++i){
               aux_vect2[i] = -i;
            }
            typename MyBoostVector::size_type old_size = boostvector->size();
            typename MyBoostVector::iterator insert_it =
               boostvector->insert(boostvector->begin() + old_size/2
                              ,boost::make_move_iterator(&aux_vect[0])
                              ,boost::make_move_iterator(aux_vect + 50));
            if(boostvector->begin() + old_size/2 != insert_it) return 1;
            stdvector->insert(stdvector->begin() + old_size/2, aux_vect2, aux_vect2 + 50);
            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

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

            for(int i = 0; i < 50; ++i){
               aux_vect2[i] = -i;
            }
            old_size = boostvector->size();
            //Now try with input iterators instead
            insert_it = boostvector->insert(boostvector->begin() + old_size/2
                              ,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(boostvector->begin() + old_size/2 != insert_it) return 1;
            stdvector->insert(stdvector->begin() + old_size/2, aux_vect2, aux_vect2 + 50);
            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
         }
/*       //deque has no reserve
         boostvector->reserve(boostvector->size()*2);
         stdvector->reserve(stdvector->size()*2);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
*/
         boostvector->shrink_to_fit();
         MyStdVector(*stdvector).swap(*stdvector);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         boostvector->shrink_to_fit();
         MyStdVector(*stdvector).swap(*stdvector);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         {  //push_back with not enough capacity
         IntType push_back_this(1);
         boostvector->push_back(boost::move(push_back_this));
         stdvector->push_back(int(1));
         boostvector->push_back(IntType(1));
         stdvector->push_back(int(1));
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
         }

         {  //test back()
         const IntType test_this(1);
         if(test_this != boostvector->back())   return 1;
         }
         {  //pop_back with enough capacity
         boostvector->pop_back();
         boostvector->pop_back();
         stdvector->pop_back();
         stdvector->pop_back();

         IntType push_back_this(1);
         boostvector->push_back(boost::move(push_back_this));
         stdvector->push_back(int(1));
         boostvector->push_back(IntType(1));
         stdvector->push_back(int(1));
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
         }

         if(!vector_copyable_only(boostvector, stdvector
                        ,container_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
            return 1;
         }

         boostvector->erase(boostvector->begin());
         stdvector->erase(stdvector->begin());
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         for(int i = 0; i < max; ++i){
            IntType insert_this(i);
            boostvector->insert(boostvector->begin(), boost::move(insert_this));
            stdvector->insert(stdvector->begin(), i);
            boostvector->insert(boostvector->begin(), IntType(i));
            stdvector->insert(stdvector->begin(), int(i));
         }
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         //Test insertion from list
         {
            std::list<int> l(50, int(1));
            typename MyBoostVector::iterator it_insert =
               boostvector->insert(boostvector->begin(), l.begin(), l.end());
            if(boostvector->begin() != it_insert) return 1;
            stdvector->insert(stdvector->begin(), l.begin(), l.end());
            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
            boostvector->assign(l.begin(), l.end());
            stdvector->assign(l.begin(), l.end());
            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

            boostvector->clear();
            stdvector->clear();
            boostvector->assign(make_input_from_forward_iterator(l.begin()), make_input_from_forward_iterator(l.end()));
            stdvector->assign(l.begin(), l.end());
            if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
         }
/*       deque has no reserve or capacity
         std::size_t cap = boostvector->capacity();
         boostvector->reserve(cap*2);
         stdvector->reserve(cap*2);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
         boostvector->resize(0);
         stdvector->resize(0);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         boostvector->resize(cap*2);
         stdvector->resize(cap*2);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         boostvector->clear();
         stdvector->clear();
         boostvector->shrink_to_fit();
         MyStdVector(*stdvector).swap(*stdvector);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;

         boostvector->resize(cap*2);
         stdvector->resize(cap*2);
         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
*/

         delete stdvector;
         delete boostvector;
      }
      BOOST_CATCH(std::exception &ex){
         #ifndef BOOST_NO_EXCEPTIONS
         std::cout << ex.what() << std::endl;
         #endif
         return 1;
      }
      BOOST_CATCH_END
   }