Adding upstream version 14.2.21.upstream/14.2.21upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 594 insertions, 0 deletions

diff --git a/src/boost/libs/interprocess/test/set_test.hpp b/src/boost/libs/interprocess/test/set_test.hpp
new file mode 100644
index 00000000..44b0b66e
--- /dev/null
+++ b/src/boost/libs/interprocess/test/set_test.hpp
@@ -0,0 +1,594 @@
+////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2012. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/interprocess for documentation.
+//
+////////////////////////////////////////
+
+#ifndef BOOST_INTERPROCESS_TEST_SET_TEST_HEADER
+#define BOOST_INTERPROCESS_TEST_SET_TEST_HEADER
+
+#include <boost/interprocess/detail/config_begin.hpp>
+#include "check_equal_containers.hpp"
+#include "print_container.hpp"
+#include <boost/move/utility_core.hpp>
+#include "get_process_id_name.hpp"
+
+#include <functional>
+
+namespace boost{
+namespace interprocess{
+namespace test{
+
+template<class ManagedSharedMemory
+        ,class MyShmSet
+        ,class MyStdSet
+        ,class MyShmMultiSet
+        ,class MyStdMultiSet>
+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;
+}
+
+template<class ManagedSharedMemory
+        ,class MyShmSet
+        ,class MyStdSet
+        ,class MyShmMultiSet
+        ,class MyStdMultiSet>
+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);
+      delete stdset;
+      delete stdmultiset;
+      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;
+}
+
+}  //namespace test{
+}  //namespace interprocess{
+}  //namespace boost{
+
+#include <boost/interprocess/detail/config_end.hpp>
+
+#endif