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;
}
