diff options
Diffstat (limited to 'src/boost/libs/interprocess/test/named_construct_test.cpp')
| -rw-r--r-- | src/boost/libs/interprocess/test/named_construct_test.cpp | 196 |
1 files changed, 196 insertions, 0 deletions
diff --git a/src/boost/libs/interprocess/test/named_construct_test.cpp b/src/boost/libs/interprocess/test/named_construct_test.cpp new file mode 100644 index 00000000..834a993f --- /dev/null +++ b/src/boost/libs/interprocess/test/named_construct_test.cpp @@ -0,0 +1,196 @@ +////////////////////////////////////////////////////////////////////////////// +// +// (C) Copyright Ion Gaztanaga 2008-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. +// +////////////////////////////////////////////////////////////////////////////// +#include <boost/interprocess/detail/config_begin.hpp> +#include <boost/interprocess/detail/workaround.hpp> +#include <boost/interprocess/managed_shared_memory.hpp> +// intrusive/detail +#include <boost/intrusive/detail/minimal_pair_header.hpp> + +typedef std::pair<double, int> simple_pair; + +using namespace boost::interprocess; + +struct array_pair : public simple_pair +{ + array_pair(double d, int i) + : simple_pair(d, i) {} +}; + +struct array_it_pair : public array_pair +{ + array_it_pair(double d, int i) + : array_pair(d, i) {} +}; + +struct named_name_generator +{ + static const bool searchable = true; + + typedef simple_pair simple_type; + typedef array_pair array_type; + typedef array_it_pair array_it_type; + static const char *get_simple_name() + { return "MyType instance"; } + static const char *get_array_name() + { return "MyType array"; } + static const char *get_array_it_name() + { return "MyType array from it"; } +}; + +struct unique_name_generator +{ + static const bool searchable = true; + + typedef simple_pair simple_type; + typedef array_pair array_type; + typedef array_it_pair array_it_type; + static const ipcdetail::unique_instance_t *get_simple_name() + { return 0; } + static const ipcdetail::unique_instance_t *get_array_name() + { return 0; } + static const ipcdetail::unique_instance_t *get_array_it_name() + { return 0; } +}; + +struct anonymous_name_generator +{ + static const bool searchable = false; + + typedef simple_pair simple_type; + typedef array_pair array_type; + typedef array_it_pair array_it_type; + static const ipcdetail::anonymous_instance_t *get_simple_name() + { return 0; } + static const ipcdetail::anonymous_instance_t *get_array_name() + { return 0; } + static const ipcdetail::anonymous_instance_t *get_array_it_name() + { return 0; } +}; + + +template<class NameGenerator> +int construct_test() +{ + typedef typename NameGenerator::simple_type simple_type; + typedef typename NameGenerator::array_type array_type; + typedef typename NameGenerator::array_it_type array_it_type; + + remove_shared_memory_on_destroy remover("MySharedMemory"); + shared_memory_object::remove("MySharedMemory"); + { + //A special shared memory where we can + //construct objects associated with a name. + //First remove any old shared memory of the same name, create + //the shared memory segment and initialize needed resources + managed_shared_memory segment + //create segment name segment size + (create_only, "MySharedMemory", 65536); + + //Create an object of MyType initialized to {0.0, 0} + simple_type *s = segment.construct<simple_type> + (NameGenerator::get_simple_name())//name of the object + (1.0, 2); //ctor first argument + assert(s->first == 1.0 && s->second == 2); + if(!(s->first == 1.0 && s->second == 2)) + return 1; + + //Create an array of 10 elements of MyType initialized to {0.0, 0} + array_type *a = segment.construct<array_type> + (NameGenerator::get_array_name()) //name of the object + [10] //number of elements + (3.0, 4); //Same two ctor arguments for all objects + assert(a->first == 3.0 && a->second == 4); + if(!(a->first == 3.0 && a->second == 4)) + return 1; + + //Create an array of 3 elements of MyType initializing each one + //to a different value {0.0, 3}, {1.0, 4}, {2.0, 5}... + float float_initializer[3] = { 0.0, 1.0, 2.0 }; + int int_initializer[3] = { 3, 4, 5 }; + + array_it_type *a_it = segment.construct_it<array_it_type> + (NameGenerator::get_array_it_name()) //name of the object + [3] //number of elements + ( &float_initializer[0] //Iterator for the 1st ctor argument + , &int_initializer[0]); //Iterator for the 2nd ctor argument + { + const array_it_type *a_it_ptr = a_it; + for(unsigned int i = 0, max = 3; i != max; ++i, ++a_it_ptr){ + assert(a_it_ptr->first == float_initializer[i]); + if(a_it_ptr->first != float_initializer[i]){ + return 1; + } + assert(a_it_ptr->second == int_initializer[i]); + if(a_it_ptr->second != int_initializer[i]){ + return 1; + } + } + } + + if(NameGenerator::searchable){ + { + std::pair<simple_type*, managed_shared_memory::size_type> res; + //Find the object + res = segment.find<simple_type> (NameGenerator::get_simple_name()); + //Length should be 1 + assert(res.second == 1); + if(res.second != 1) + return 1; + assert(res.first == s); + if(res.first != s) + return 1; + } + { + std::pair<array_type*, managed_shared_memory::size_type> res; + + //Find the array + res = segment.find<array_type> (NameGenerator::get_array_name()); + //Length should be 10 + assert(res.second == 10); + if(res.second != 10) + return 1; + assert(res.first == a); + if(res.first != a) + return 1; + } + { + std::pair<array_it_type*, managed_shared_memory::size_type> res; + //Find the array constructed from iterators + res = segment.find<array_it_type> (NameGenerator::get_array_it_name()); + //Length should be 3 + assert(res.second == 3); + if(res.second != 3) + return 1; + assert(res.first == a_it); + if(res.first != a_it) + return 1; + } + } + //We're done, delete all the objects + segment.destroy_ptr<simple_type>(s); + segment.destroy_ptr<array_type>(a); + segment.destroy_ptr<array_it_type>(a_it); + } + return 0; +} + +int main () +{ + if(0 != construct_test<named_name_generator>()) + return 1; + if(0 != construct_test<unique_name_generator>()) + return 1; + if(0 != construct_test<anonymous_name_generator>()) + return 1; + return 0; +} + +//] +#include <boost/interprocess/detail/config_end.hpp> |