bool do_test() { //Test for recursive types { deque<recursive_deque> recursive_deque_deque; } { //Now test move semantics deque<recursive_deque> original; deque<recursive_deque> move_ctor(boost::move(original)); deque<recursive_deque> move_assign; move_assign = boost::move(move_ctor); move_assign.swap(original); } //Alias deque types typedef deque<IntType> MyCntDeque; typedef std::deque<int> MyStdDeque; const int max = 100; BOOST_TRY{ MyCntDeque *cntdeque = new MyCntDeque; MyStdDeque *stddeque = new MyStdDeque; for(int i = 0; i < max*100; ++i){ IntType move_me(i); cntdeque->insert(cntdeque->end(), boost::move(move_me)); stddeque->insert(stddeque->end(), i); } if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; cntdeque->clear(); stddeque->clear(); for(int i = 0; i < max*100; ++i){ IntType move_me(i); cntdeque->push_back(boost::move(move_me)); stddeque->push_back(i); } if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; cntdeque->clear(); stddeque->clear(); for(int i = 0; i < max*100; ++i){ IntType move_me(i); cntdeque->push_front(boost::move(move_me)); stddeque->push_front(i); } if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; typename MyCntDeque::iterator it; typename MyCntDeque::const_iterator cit = it; (void)cit; cntdeque->erase(cntdeque->begin()++); stddeque->erase(stddeque->begin()++); if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; cntdeque->erase(cntdeque->begin()); stddeque->erase(stddeque->begin()); if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; { //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; } cntdeque->insert(cntdeque->end() ,boost::make_move_iterator(&aux_vect[0]) ,boost::make_move_iterator(aux_vect + 50)); stddeque->insert(stddeque->end(), aux_vect2, aux_vect2 + 50); if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; 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; } cntdeque->insert(cntdeque->begin()+cntdeque->size() ,boost::make_move_iterator(&aux_vect[0]) ,boost::make_move_iterator(aux_vect + 50)); stddeque->insert(stddeque->begin()+stddeque->size(), aux_vect2, aux_vect2 + 50); if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; for(int i = 0, j = static_cast<int>(cntdeque->size()); i < j; ++i){ cntdeque->erase(cntdeque->begin()); stddeque->erase(stddeque->begin()); } if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; } { 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; } cntdeque->insert(cntdeque->begin() ,boost::make_move_iterator(&aux_vect[0]) ,boost::make_move_iterator(aux_vect + 50)); stddeque->insert(stddeque->begin(), aux_vect2, aux_vect2 + 50); if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; } if(!deque_copyable_only(cntdeque, stddeque ,container_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){ return false; } cntdeque->erase(cntdeque->begin()); stddeque->erase(stddeque->begin()); if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; for(int i = 0; i < max; ++i){ IntType move_me(i); cntdeque->insert(cntdeque->begin(), boost::move(move_me)); stddeque->insert(stddeque->begin(), i); } if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; //Test insertion from list { std::list<int> l(50, int(1)); cntdeque->insert(cntdeque->begin(), l.begin(), l.end()); stddeque->insert(stddeque->begin(), l.begin(), l.end()); if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1; cntdeque->assign(l.begin(), l.end()); stddeque->assign(l.begin(), l.end()); if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1; } cntdeque->resize(100); stddeque->resize(100); if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1; cntdeque->resize(200); stddeque->resize(200); if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1; delete cntdeque; delete stddeque; } BOOST_CATCH(std::exception &ex){ #ifndef BOOST_NO_EXCEPTIONS std::cout << ex.what() << std::endl; #endif return false; }
bool do_test() { //Test for recursive types { deque<recursive_deque> recursive_deque_deque; } { //Now test move semantics deque<recursive_deque> original; deque<recursive_deque> move_ctor(boost::interprocess::move(original)); deque<recursive_deque> move_assign; move_assign = boost::interprocess::move(move_ctor); move_assign.swap(original); } //Customize managed_shared_memory class typedef basic_managed_shared_memory <char, //simple_seq_fit<mutex_family>, rbtree_best_fit<mutex_family>, //flat_map_index iset_index > my_managed_shared_memory; //Alias AllocatorType type typedef AllocatorType<IntType, my_managed_shared_memory::segment_manager> shmem_allocator_t; //Alias deque types typedef deque<IntType, shmem_allocator_t> MyShmDeque; typedef std::deque<int> MyStdDeque; const int Memsize = 65536; const char *const shMemName = test::get_process_id_name(); const int max = 100; try{ shared_memory_object::remove(shMemName); //Create shared memory my_managed_shared_memory segment(create_only, shMemName, Memsize); segment.reserve_named_objects(100); //Shared memory allocator must be always be initialized //since it has no default constructor MyShmDeque *shmdeque = segment.template construct<MyShmDeque>("MyShmDeque") (segment.get_segment_manager()); MyStdDeque *stddeque = new MyStdDeque; try{ //Compare several shared memory deque operations with std::deque int i; for(i = 0; i < max*100; ++i){ IntType move_me(i); shmdeque->insert(shmdeque->end(), boost::interprocess::move(move_me)); stddeque->insert(stddeque->end(), i); } if(!test::CheckEqualContainers(shmdeque, stddeque)) return false; shmdeque->clear(); stddeque->clear(); for(i = 0; i < max*100; ++i){ IntType move_me(i); shmdeque->push_back(boost::interprocess::move(move_me)); stddeque->push_back(i); } if(!test::CheckEqualContainers(shmdeque, stddeque)) return false; shmdeque->clear(); stddeque->clear(); for(i = 0; i < max*100; ++i){ IntType move_me(i); shmdeque->push_front(boost::interprocess::move(move_me)); stddeque->push_front(i); } if(!test::CheckEqualContainers(shmdeque, stddeque)) return false; typename MyShmDeque::iterator it; typename MyShmDeque::const_iterator cit = it; shmdeque->erase(shmdeque->begin()++); stddeque->erase(stddeque->begin()++); if(!test::CheckEqualContainers(shmdeque, stddeque)) return false; shmdeque->erase(shmdeque->begin()); stddeque->erase(stddeque->begin()); if(!test::CheckEqualContainers(shmdeque, stddeque)) return false; { //Initialize values 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; } shmdeque->insert(shmdeque->end() ,boost::interprocess::make_move_iterator(&aux_vect[0]) ,boost::interprocess::make_move_iterator(aux_vect + 50)); stddeque->insert(stddeque->end(), aux_vect2, aux_vect2 + 50); if(!test::CheckEqualContainers(shmdeque, stddeque)) return false; for(int i = 0, j = static_cast<int>(shmdeque->size()); i < j; ++i){ shmdeque->erase(shmdeque->begin()); stddeque->erase(stddeque->begin()); } if(!test::CheckEqualContainers(shmdeque, stddeque)) return false; } { 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; } shmdeque->insert(shmdeque->begin() ,boost::interprocess::make_move_iterator(&aux_vect[0]) ,boost::interprocess::make_move_iterator(aux_vect + 50)); stddeque->insert(stddeque->begin(), aux_vect2, aux_vect2 + 50); if(!test::CheckEqualContainers(shmdeque, stddeque)) return false; } if(!copyable_only(shmdeque, stddeque ,detail::bool_<!boost::interprocess::is_movable<IntType>::value>())){ return false; } shmdeque->erase(shmdeque->begin()); stddeque->erase(stddeque->begin()); if(!test::CheckEqualContainers(shmdeque, stddeque)) return false; for(i = 0; i < max; ++i){ IntType move_me(i); shmdeque->insert(shmdeque->begin(), boost::interprocess::move(move_me)); stddeque->insert(stddeque->begin(), i); } if(!test::CheckEqualContainers(shmdeque, stddeque)) return false; //Test insertion from list { std::list<int> l(50, int(1)); shmdeque->insert(shmdeque->begin(), l.begin(), l.end()); stddeque->insert(stddeque->begin(), l.begin(), l.end()); if(!test::CheckEqualContainers(shmdeque, stddeque)) return 1; shmdeque->assign(l.begin(), l.end()); stddeque->assign(l.begin(), l.end()); if(!test::CheckEqualContainers(shmdeque, stddeque)) return 1; } shmdeque->resize(100); stddeque->resize(100); if(!test::CheckEqualContainers(shmdeque, stddeque)) return 1; shmdeque->resize(200); stddeque->resize(200); if(!test::CheckEqualContainers(shmdeque, stddeque)) return 1; segment.template destroy<MyShmDeque>("MyShmDeque"); delete stddeque; segment.shrink_to_fit_indexes(); if(!segment.all_memory_deallocated()) return false; } catch(std::exception &ex){ std::cout << ex.what() << std::endl; return false; } std::cout << std::endl << "Test OK!" << std::endl; } catch(...){ shared_memory_object::remove(shMemName); throw; } shared_memory_object::remove(shMemName); return true; }
bool do_test() { //Test for recursive types { deque<recursive_deque> recursive_deque_deque; } { //Now test move semantics deque<recursive_deque> original; deque<recursive_deque> move_ctor(boost::move(original)); deque<recursive_deque> move_assign; move_assign = boost::move(move_ctor); move_assign.swap(original); } //Alias deque types typedef deque<IntType> MyCntDeque; typedef std::deque<int> MyStdDeque; const int max = 100; try { //Shared memory allocator must be always be initialized //since it has no default constructor MyCntDeque *cntdeque = new MyCntDeque; MyStdDeque *stddeque = new MyStdDeque; //Compare several shared memory deque operations with std::deque for(int i = 0; i < max*100; ++i) { IntType move_me(i); cntdeque->insert(cntdeque->end(), boost::move(move_me)); stddeque->insert(stddeque->end(), i); } if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; cntdeque->clear(); stddeque->clear(); for(int i = 0; i < max*100; ++i) { IntType move_me(i); cntdeque->push_back(boost::move(move_me)); stddeque->push_back(i); } if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; cntdeque->clear(); stddeque->clear(); for(int i = 0; i < max*100; ++i) { IntType move_me(i); cntdeque->push_front(boost::move(move_me)); stddeque->push_front(i); } if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; typename MyCntDeque::iterator it; typename MyCntDeque::const_iterator cit = it; (void)cit; cntdeque->erase(cntdeque->begin()++); stddeque->erase(stddeque->begin()++); if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; cntdeque->erase(cntdeque->begin()); stddeque->erase(stddeque->begin()); if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; { //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; } cntdeque->insert(cntdeque->end() ,boost::make_move_iterator(&aux_vect[0]) ,boost::make_move_iterator(aux_vect + 50)); stddeque->insert(stddeque->end(), aux_vect2, aux_vect2 + 50); if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; for(int i = 0, j = static_cast<int>(cntdeque->size()); i < j; ++i) { cntdeque->erase(cntdeque->begin()); stddeque->erase(stddeque->begin()); } if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; } { 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; } cntdeque->insert(cntdeque->begin() ,boost::make_move_iterator(&aux_vect[0]) ,boost::make_move_iterator(aux_vect + 50)); stddeque->insert(stddeque->begin(), aux_vect2, aux_vect2 + 50); if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; } if(!deque_copyable_only(cntdeque, stddeque ,container_detail::bool_<boost::container::test::is_copyable<IntType>::value>())) { return false; } cntdeque->erase(cntdeque->begin()); stddeque->erase(stddeque->begin()); if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; for(int i = 0; i < max; ++i) { IntType move_me(i); cntdeque->insert(cntdeque->begin(), boost::move(move_me)); stddeque->insert(stddeque->begin(), i); } if(!test::CheckEqualContainers(cntdeque, stddeque)) return false; //Test insertion from list { std::list<int> l(50, int(1)); cntdeque->insert(cntdeque->begin(), l.begin(), l.end()); stddeque->insert(stddeque->begin(), l.begin(), l.end()); if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1; cntdeque->assign(l.begin(), l.end()); stddeque->assign(l.begin(), l.end()); if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1; } cntdeque->resize(100); stddeque->resize(100); if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1; cntdeque->resize(200); stddeque->resize(200); if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1; delete cntdeque; delete stddeque; } catch(std::exception &ex) { std::cout << ex.what() << std::endl; return false; } std::cout << std::endl << "Test OK!" << std::endl; return true; }