{

return std::equal(userlist->begin(), userlist->end(), stdlist->begin()) &&

std::equal(heaplist->begin(), heaplist->end(), stdlist->begin());

{

//Create the user memory who will store all objects

const int size_aligner = sizeof(::boost::container::dtl::max_align_t);

const int memsize = 65536/size_aligner*size_aligner;

static ::boost::container::dtl::max_align_t static_buffer[memsize/size_aligner];

{

//Now test move semantics

managed_heap_memory original(memsize);

managed_heap_memory move_ctor(boost::move(original));

managed_heap_memory move_assign;

move_assign = boost::move(move_ctor);

original.swap(move_assign);

}

{

//Now test move semantics

managed_external_buffer original(create_only, static_buffer, memsize);

managed_external_buffer move_ctor(boost::move(original));

managed_external_buffer move_assign;

move_assign = boost::move(move_ctor);

original.swap(move_assign);

}

//Named new capable user mem allocator

wmanaged_external_buffer user_buffer(create_only, static_buffer, memsize);

//Named new capable heap mem allocator

wmanaged_heap_memory heap_buffer(memsize);

//Test move semantics

{

wmanaged_external_buffer user_default;

wmanaged_external_buffer temp_external(boost::move(user_buffer));

user_default = boost::move(temp_external);

user_buffer = boost::move(user_default);

wmanaged_heap_memory heap_default;

wmanaged_heap_memory temp_heap(boost::move(heap_buffer));

heap_default = boost::move(temp_heap);

heap_buffer = boost::move(heap_default);

}

//Initialize memory

user_buffer.reserve_named_objects(100);

heap_buffer.reserve_named_objects(100);

//User memory allocator must be always be initialized

//since it has no default constructor

MyUserList *userlist = user_buffer.construct<MyUserList>(L"MyUserList")

(user_buffer.get_segment_manager());

MyHeapList *heaplist = heap_buffer.construct<MyHeapList>(L"MyHeapList")

(heap_buffer.get_segment_manager());

//Alias heap list

MyStdList *stdlist = new MyStdList;

int i;

const int max = 100;

for(i = 0; i < max; ++i){

userlist->push_back(i);

heaplist->push_back(i);

stdlist->push_back(i);

}

if(!CheckEqual(userlist, stdlist, heaplist)) return 1;

userlist->erase(userlist->begin()++);

heaplist->erase(heaplist->begin()++);

stdlist->erase(stdlist->begin()++);

if(!CheckEqual(userlist, stdlist, heaplist)) return 1;

userlist->pop_back();

heaplist->pop_back();

stdlist->pop_back();

if(!CheckEqual(userlist, stdlist, heaplist)) return 1;

userlist->pop_front();

heaplist->pop_front();

stdlist->pop_front();

if(!CheckEqual(userlist, stdlist, heaplist)) return 1;

std::vector<int> aux_vect;

#if !BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)

aux_vect.assign(50, -1);

userlist->assign(aux_vect.begin(), aux_vect.end());

heaplist->assign(aux_vect.begin(), aux_vect.end());

stdlist->assign(aux_vect.begin(), aux_vect.end());

if(!CheckEqual(userlist, stdlist, heaplist)) return 1;

#endif

userlist->sort();

heaplist->sort();

stdlist->sort();

if(!CheckEqual(userlist, stdlist, heaplist)) return 1;

#if !BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)

aux_vect.assign(50, 0);

#endif

userlist->insert(userlist->begin(), aux_vect.begin(), aux_vect.end());

heaplist->insert(heaplist->begin(), aux_vect.begin(), aux_vect.end());

stdlist->insert(stdlist->begin(), aux_vect.begin(), aux_vect.end());

userlist->unique();

heaplist->unique();

stdlist->unique();

if(!CheckEqual(userlist, stdlist, heaplist)) return 1;

userlist->sort(std::greater<int>());

heaplist->sort(std::greater<int>());

stdlist->sort(std::greater<int>());

if(!CheckEqual(userlist, stdlist, heaplist)) return 1;

userlist->resize(userlist->size()/2);

heaplist->resize(heaplist->size()/2);

stdlist->resize(stdlist->size()/2);

if(!CheckEqual(userlist, stdlist, heaplist)) return 1;

userlist->remove(*userlist->begin());

heaplist->remove(*heaplist->begin());

stdlist->remove(*stdlist->begin());

if(!CheckEqual(userlist, stdlist, heaplist)) return 1;

for(i = 0; i < max; ++i){

userlist->push_back(i);

heaplist->push_back(i);

stdlist->push_back(i);

}

MyUserList otheruserlist(*userlist);

MyHeapList otherheaplist(*heaplist);

MyStdList otherstdlist(*stdlist);

userlist->splice(userlist->begin(), otheruserlist);

heaplist->splice(heaplist->begin(), otherheaplist);

stdlist->splice(stdlist->begin(), otherstdlist);

if(!CheckEqual(userlist, stdlist, heaplist)) return 1;

otheruserlist = *userlist;

otherheaplist = *heaplist;

otherstdlist = *stdlist;

userlist->sort(std::greater<int>());

heaplist->sort(std::greater<int>());

stdlist->sort(std::greater<int>());

otheruserlist.sort(std::greater<int>());

otherheaplist.sort(std::greater<int>());

otherstdlist.sort(std::greater<int>());

userlist->merge(otheruserlist, std::greater<int>());

heaplist->merge(otherheaplist, std::greater<int>());

stdlist->merge(otherstdlist, std::greater<int>());

if(!CheckEqual(userlist, stdlist, heaplist)) return 1;

user_buffer.destroy<MyUserList>(L"MyUserList");

delete stdlist;

//Fill heap buffer until is full

BOOST_TRY{

while(1){

heaplist->insert(heaplist->end(), 0);

}

}

BOOST_CATCH(boost::interprocess::bad_alloc &){} BOOST_CATCH_END

MyHeapList::size_type heap_list_size = heaplist->size();

//Copy heap buffer to another

const char *insert_beg = static_cast<char*>(heap_buffer.get_address());

const char *insert_end = insert_beg + heap_buffer.get_size();

std::vector<char> grow_copy (insert_beg, insert_end);

//Destroy old list

heap_buffer.destroy<MyHeapList>(L"MyHeapList");

//Resize copy buffer

grow_copy.resize(memsize*2);

//Open Interprocess machinery in the new managed external buffer

wmanaged_external_buffer user_buffer2(open_only, &grow_copy[0], memsize);

//Expand old Interprocess machinery to the new size

user_buffer2.grow(memsize);

//Get a pointer to the full list

userlist = user_buffer2.find<MyUserList>(L"MyHeapList").first;

if(!userlist){

return 1;

}

//Fill user buffer until is full

BOOST_TRY{

while(1){

userlist->insert(userlist->end(), 0);

}

}

BOOST_CATCH(boost::interprocess::bad_alloc &){} BOOST_CATCH_END

MyUserList::size_type user_list_size = userlist->size();

if(user_list_size <= heap_list_size){

return 1;

}

user_buffer2.destroy_ptr(userlist);

return 0;