bool do_move(state_t *s)
{
return queue_move(move_me(s, 1, 0))
|| queue_move(move_me(s, -1, 0))
|| queue_move(move_me(s, 0, 1))
|| queue_move(move_me(s, 0, -1));
}
bool copyable_only(V1 *shmvector, V2 *stdvector, boost::interprocess::detail::true_type)
{
typedef typename V1::value_type IntType;
std::size_t size = shmvector->size();
stdvector->insert(stdvector->end(), 50, 1);
shmvector->insert(shmvector->end(), 50, IntType(1));
if(!test::CheckEqualContainers(shmvector, stdvector)) return false;
{
IntType move_me(1);
stdvector->insert(stdvector->begin()+size/2, 50, 1);
shmvector->insert(shmvector->begin()+size/2, 50, boost::interprocess::move(move_me));
if(!test::CheckEqualContainers(shmvector, stdvector)) return false;
}
{
IntType move_me(2);
shmvector->assign(shmvector->size()/2, boost::interprocess::move(move_me));
stdvector->assign(stdvector->size()/2, 2);
if(!test::CheckEqualContainers(shmvector, stdvector)) return false;
}
{
IntType move_me(3);
shmvector->assign(shmvector->size()*3-1, boost::interprocess::move(move_me));
stdvector->assign(stdvector->size()*3-1, 3);
if(!test::CheckEqualContainers(shmvector, stdvector)) return false;
}
return true;
}
bool vector_copyable_only(V1 *boostvector, V2 *stdvector, boost::container::container_detail::true_type)
{
typedef typename V1::value_type IntType;
std::size_t size = boostvector->size();
boostvector->insert(boostvector->end(), 50, IntType(1));
stdvector->insert(stdvector->end(), 50, 1);
if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
{
IntType move_me(1);
boostvector->insert(boostvector->begin()+size/2, 50, boost::move(move_me));
stdvector->insert(stdvector->begin()+size/2, 50, 1);
if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
}
{
IntType move_me(2);
boostvector->assign(boostvector->size()/2, boost::move(move_me));
stdvector->assign(stdvector->size()/2, 2);
if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
}
{
IntType move_me(3);
boostvector->assign(boostvector->size()*3-1, boost::move(move_me));
stdvector->assign(stdvector->size()*3-1, 3);
if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
}
{
IntType copy_me(3);
const IntType ccopy_me(3);
boostvector->push_back(copy_me);
stdvector->push_back(int(3));
boostvector->push_back(ccopy_me);
stdvector->push_back(int(3));
if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
}
{
V1 *pv1 = new V1(*boostvector);
V2 *pv2 = new V2(*stdvector);
boostvector->clear();
stdvector->clear();
boostvector->assign(pv1->begin(), pv1->end());
stdvector->assign(pv2->begin(), pv2->end());
if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
delete pv1;
delete pv2;
}
return true;
}
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;
}
static int execute(int max, MyShmList *shmlist, MyStdList *stdlist)
{
typedef typename MyShmList::value_type IntType;
for(int i = 0; i < max; ++i){
IntType move_me(i);
shmlist->push_front(boost::interprocess::move(move_me));
stdlist->push_front(i);
}
if(!CheckEqualContainers(shmlist, stdlist))
return 1;
return 0;
}
bool list_copyable_only(V1 *boostlist, V2 *stdlist, boost::container::container_detail::true_type)
{
typedef typename V1::value_type IntType;
boostlist->insert(boostlist->end(), 50, IntType(1));
stdlist->insert(stdlist->end(), 50, 1);
if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
{
IntType move_me(1);
boostlist->insert(boostlist->begin(), 50, boost::move(move_me));
stdlist->insert(stdlist->begin(), 50, 1);
if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
}
{
IntType move_me(2);
boostlist->assign(boostlist->size()/2, boost::move(move_me));
stdlist->assign(stdlist->size()/2, 2);
if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
}
{
IntType move_me(3);
boostlist->assign(boostlist->size()*3-1, boost::move(move_me));
stdlist->assign(stdlist->size()*3-1, 3);
if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
}
{
IntType copy_me(3);
const IntType ccopy_me(3);
boostlist->push_front(copy_me);
stdlist->push_front(int(3));
boostlist->push_front(ccopy_me);
stdlist->push_front(int(3));
if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
}
return true;
}
static int execute(int max, MyBoostList *boostlist, MyStdList *stdlist)
{
typedef typename MyBoostList::value_type IntType;
for(int i = 0; i < max; ++i){
IntType move_me(i);
boostlist->push_back(boost::move(move_me));
stdlist->push_back(i);
boostlist->push_front(IntType(i));
stdlist->push_front(int(i));
}
if(!CheckEqualContainers(boostlist, stdlist))
return 1;
return 0;
}
t_bunny_response mainloop(void *data)
{
t_win *win;
t_bunny_position origin;
origin.x = 0;
origin.y = 0;
win = data;
move_me(win);
draw_wall(win);
bunny_blit(&win->win->buffer, &win->array->clipable, &origin);
bunny_display(win->win);
return (GO_ON);
}
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;
}
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;
}
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 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;
}
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;
}
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;
}
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;
}