Squashed 'third_party/boostorg/container/' content from commit 1ad6431
Change-Id: I7d095db3455264c03446268e5675b926bebedb0a
git-subtree-dir: third_party/boostorg/container
git-subtree-split: 1ad64316a432a7f021b4956acf88abc6aaa8a77e
diff --git a/test/vector_test.hpp b/test/vector_test.hpp
new file mode 100644
index 0000000..016da1a
--- /dev/null
+++ b/test/vector_test.hpp
@@ -0,0 +1,563 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_VECTOR_TEST_HEADER
+#define BOOST_CONTAINER_TEST_VECTOR_TEST_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+
+#include <vector>
+#include <iostream>
+#include <list>
+
+#include <boost/move/utility_core.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/move/iterator.hpp>
+#include <boost/move/make_unique.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+#include <boost/static_assert.hpp>
+
+#include "print_container.hpp"
+#include "check_equal_containers.hpp"
+#include "movable_int.hpp"
+#include "emplace_test.hpp"
+#include "input_from_forward_iterator.hpp"
+#include "insert_test.hpp"
+#include "container_common_tests.hpp"
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class Vector>
+struct vector_hash_function_capacity
+{
+ typedef typename Vector::size_type size_type;
+ template <typename U, size_type (U::*)() const> struct Check;
+ template <typename U> static char func(Check<U, &U::capacity> *);
+ template <typename U> static int func(...);
+
+ public:
+ static const bool value = sizeof(func<Vector>(0)) == sizeof(char);
+};
+
+template<class V1, class V2>
+bool vector_vector_hash_function_capacity_only(V1&, V2&, boost::container::dtl::false_type)
+{
+ return true;
+}
+
+template<class MyBoostVector, class MyStdVector>
+bool vector_vector_hash_function_capacity_only(MyBoostVector&boostvector, MyStdVector&stdvector, boost::container::dtl::true_type)
+{
+ //deque has no reserve
+ boostvector.reserve(boostvector.size()*2);
+ stdvector.reserve(stdvector.size()*2);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+
+ std::size_t cap = boostvector.capacity();
+ boostvector.reserve(cap*2);
+ stdvector.reserve(cap*2);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+ boostvector.resize(0);
+ stdvector.resize(0);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+
+ boostvector.resize(cap*2);
+ stdvector.resize(cap*2);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+
+ boostvector.resize(cap*2);
+ stdvector.resize(cap*2);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+
+ return true;
+}
+
+
+template<class V1, class V2>
+bool vector_copyable_only(V1&, V2&, boost::container::dtl::false_type)
+{
+ return true;
+}
+
+//Function to check if both sets are equal
+template<class MyBoostVector, class MyStdVector>
+bool vector_copyable_only(MyBoostVector &boostvector, MyStdVector &stdvector, boost::container::dtl::true_type)
+{
+ typedef typename MyBoostVector::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;
+ }
+ { //Vector(const Vector &)
+ ::boost::movelib::unique_ptr<MyBoostVector> const pv1 =
+ ::boost::movelib::make_unique<MyBoostVector>(boostvector);
+ ::boost::movelib::unique_ptr<MyStdVector> const pv2 =
+ ::boost::movelib::make_unique<MyStdVector>(stdvector);
+
+ MyBoostVector &v1 = *pv1;
+ MyStdVector &v2 = *pv2;
+
+ boostvector.clear();
+ stdvector.clear();
+ boostvector.assign(v1.begin(), v1.end());
+ stdvector.assign(v2.begin(), v2.end());
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ }
+ { //Vector(const Vector &, alloc)
+ ::boost::movelib::unique_ptr<MyBoostVector> const pv1 =
+ ::boost::movelib::make_unique<MyBoostVector>(boostvector, typename MyBoostVector::allocator_type());
+ ::boost::movelib::unique_ptr<MyStdVector> const pv2 =
+ ::boost::movelib::make_unique<MyStdVector>(stdvector);
+
+ MyBoostVector &v1 = *pv1;
+ MyStdVector &v2 = *pv2;
+
+ boostvector.clear();
+ stdvector.clear();
+ boostvector.assign(v1.begin(), v1.end());
+ stdvector.assign(v2.begin(), v2.end());
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ }
+ { //Vector(n, T)
+ ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+ ::boost::movelib::make_unique<MyStdVector>(100, int(5));
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+ ::boost::movelib::make_unique<MyBoostVector>(100, IntType(5));
+ if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
+ }
+ { //Vector(n, T, alloc)
+ ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+ ::boost::movelib::make_unique<MyStdVector>(100, int(5));
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+ ::boost::movelib::make_unique<MyBoostVector>(100, IntType(5), typename MyBoostVector::allocator_type());
+ if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
+ }
+ { //Vector(It, It)
+ ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+ ::boost::movelib::make_unique<MyStdVector>(100);
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+ ::boost::movelib::make_unique<MyBoostVector>(100);
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
+ ::boost::movelib::make_unique<MyBoostVector>(boostvectorp->begin(), boostvectorp->end());
+ if(!test::CheckEqualContainers(*boostvectorp2, *stdvectorp)) return 1;
+ }
+ { //Vector(It, It, alloc)
+ ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+ ::boost::movelib::make_unique<MyStdVector>(100);
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+ ::boost::movelib::make_unique<MyBoostVector>(100);
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
+ ::boost::movelib::make_unique<MyBoostVector>(boostvectorp->begin(), boostvectorp->end(), typename MyBoostVector::allocator_type());
+ if(!test::CheckEqualContainers(*boostvectorp2, *stdvectorp)) return 1;
+ }
+ { //resize(n, T)
+ ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+ ::boost::movelib::make_unique<MyStdVector>();
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+ ::boost::movelib::make_unique<MyBoostVector>();
+ stdvectorp->resize(100, int(9));
+ boostvectorp->resize(100, IntType(9));
+ if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
+ }
+ //operator=
+ {
+ //Copy constructor test
+ MyBoostVector bcopy((const MyBoostVector&) boostvector);
+ MyStdVector scopy((const MyStdVector&) stdvector);
+ MyBoostVector bcopy2(boostvector);
+ MyStdVector scopy2(stdvector);
+
+ if(!test::CheckEqualContainers(bcopy, scopy)) return false;
+ if(!test::CheckEqualContainers(bcopy2, scopy2)) return false;
+
+ //Assignment from a smaller vector
+ bcopy2.erase(bcopy2.begin() + bcopy2.size()/2, bcopy2.end());
+ scopy2.erase(scopy2.begin() + scopy2.size()/2, scopy2.end());
+ bcopy = bcopy2;
+ scopy = scopy2;
+ if(!test::CheckEqualContainers(bcopy, scopy)) return false;
+
+ //Assignment from a bigger vector with capacity
+ bcopy2 = boostvector;
+ scopy2 = stdvector;
+ if(!test::CheckEqualContainers(bcopy2, scopy2)) return false;
+
+ //Assignment from bigger vector with no capacity
+ bcopy2.erase(bcopy2.begin() + bcopy2.size()/2, bcopy2.end());
+ scopy2.erase(scopy2.begin() + scopy2.size()/2, scopy2.end());
+ bcopy2.shrink_to_fit();
+ MyStdVector(scopy2).swap(scopy2);
+
+ bcopy2 = boostvector;
+ scopy2 = stdvector;
+ if(!test::CheckEqualContainers(bcopy, scopy)) return false;
+
+ //Assignment with equal capacity
+ bcopy2 = boostvector;
+ scopy2 = stdvector;
+ if(!test::CheckEqualContainers(bcopy2, scopy2)) return false;
+ }
+
+ return true;
+}
+
+template<class MyBoostVector>
+int vector_test()
+{
+ typedef std::vector<int> MyStdVector;
+ typedef typename MyBoostVector::value_type IntType;
+ const int max = 100;
+
+ if(!test_range_insertion<MyBoostVector>()){
+ return 1;
+ }
+ { //Vector(n)
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+ ::boost::movelib::make_unique<MyBoostVector>(100);
+ ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+ ::boost::movelib::make_unique<MyStdVector>(100);
+ if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
+ }
+ { //Vector(n, alloc)
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+ ::boost::movelib::make_unique<MyBoostVector>(100, typename MyBoostVector::allocator_type());
+ ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+ ::boost::movelib::make_unique<MyStdVector>(100);
+ if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
+ }
+ { //Vector(Vector &&)
+ ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+ ::boost::movelib::make_unique<MyStdVector>(100);
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+ ::boost::movelib::make_unique<MyBoostVector>(100);
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
+ ::boost::movelib::make_unique<MyBoostVector>(::boost::move(*boostvectorp));
+ if(!test::CheckEqualContainers(*boostvectorp2, *stdvectorp)) return 1;
+ }
+ { //Vector(Vector &&, alloc)
+ ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+ ::boost::movelib::make_unique<MyStdVector>(100);
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+ ::boost::movelib::make_unique<MyBoostVector>(100);
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
+ ::boost::movelib::make_unique<MyBoostVector>
+ (::boost::move(*boostvectorp), typename MyBoostVector::allocator_type());
+ if(!test::CheckEqualContainers(*boostvectorp2, *stdvectorp)) return 1;
+ }
+ { //Vector operator=(Vector &&)
+ ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+ ::boost::movelib::make_unique<MyStdVector>(100);
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+ ::boost::movelib::make_unique<MyBoostVector>(100);
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
+ ::boost::movelib::make_unique<MyBoostVector>();
+ *boostvectorp2 = ::boost::move(*boostvectorp);
+ if(!test::CheckEqualContainers(*boostvectorp2, *stdvectorp)) return 1;
+ }
+ {
+ ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp = ::boost::movelib::make_unique<MyBoostVector>();
+ ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp = ::boost::movelib::make_unique<MyStdVector>();
+
+ MyBoostVector & boostvector = *boostvectorp;
+ MyStdVector & stdvector = *stdvectorp;
+
+ boostvector.resize(100);
+ stdvector.resize(100);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ boostvector.resize(200);
+ stdvector.resize(200);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ boostvector.resize(0);
+ stdvector.resize(0);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ for(int i = 0; i < max; ++i){
+ IntType new_int(i);
+ boostvector.insert(boostvector.end(), boost::move(new_int));
+ stdvector.insert(stdvector.end(), i);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ }
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ typename MyBoostVector::iterator boostit(boostvector.begin());
+ typename MyStdVector::iterator stdit(stdvector.begin());
+ typename MyBoostVector::const_iterator cboostit = boostit;
+ (void)cboostit;
+ ++boostit; ++stdit;
+ boostvector.erase(boostit);
+ stdvector.erase(stdit);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ boostvector.erase(boostvector.begin());
+ stdvector.erase(stdvector.begin());
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ {
+ //Initialize values
+ IntType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType new_int(-1);
+ BOOST_STATIC_ASSERT((boost::container::test::is_copyable<boost::container::test::movable_int>::value == false));
+ aux_vect[i] = boost::move(new_int);
+ }
+ int aux_vect2[50];
+ for(int i = 0; i < 50; ++i){
+ aux_vect2[i] = -1;
+ }
+ typename MyBoostVector::iterator insert_it =
+ boostvector.insert(boostvector.end()
+ ,boost::make_move_iterator(&aux_vect[0])
+ ,boost::make_move_iterator(aux_vect + 50));
+ if(std::size_t(boost::container::iterator_distance(insert_it, boostvector.end())) != 50) return 1;
+ stdvector.insert(stdvector.end(), aux_vect2, aux_vect2 + 50);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ for(int i = 0, j = static_cast<int>(boostvector.size()); i < j; ++i){
+ boostvector.erase(boostvector.begin());
+ stdvector.erase(stdvector.begin());
+ }
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ }
+ {
+ boostvector.resize(100);
+ stdvector.resize(100);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ IntType aux_vect[50];
+ for(int i = 0; i < 50; ++i){
+ IntType new_int(-i);
+ aux_vect[i] = boost::move(new_int);
+ }
+ int aux_vect2[50];
+ for(int i = 0; i < 50; ++i){
+ aux_vect2[i] = -i;
+ }
+ typename MyBoostVector::size_type old_size = boostvector.size();
+ typename MyBoostVector::iterator insert_it =
+ boostvector.insert(boostvector.begin() + old_size/2
+ ,boost::make_move_iterator(&aux_vect[0])
+ ,boost::make_move_iterator(aux_vect + 50));
+ if(boostvector.begin() + old_size/2 != insert_it) return 1;
+ stdvector.insert(stdvector.begin() + old_size/2, aux_vect2, aux_vect2 + 50);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ for(int i = 0; i < 50; ++i){
+ IntType new_int(-i);
+ aux_vect[i] = boost::move(new_int);
+ }
+
+ for(int i = 0; i < 50; ++i){
+ aux_vect2[i] = -i;
+ }
+ old_size = boostvector.size();
+ //Now try with input iterators instead
+ insert_it = boostvector.insert(boostvector.begin() + old_size/2
+ ,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(boostvector.begin() + old_size/2 != insert_it) return 1;
+ stdvector.insert(stdvector.begin() + old_size/2, aux_vect2, aux_vect2 + 50);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ }
+
+ boostvector.shrink_to_fit();
+ MyStdVector(stdvector).swap(stdvector);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ boostvector.shrink_to_fit();
+ MyStdVector(stdvector).swap(stdvector);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ { //push_back with not enough capacity
+ IntType push_back_this(1);
+ boostvector.push_back(boost::move(push_back_this));
+ stdvector.push_back(int(1));
+ boostvector.push_back(IntType(1));
+ stdvector.push_back(int(1));
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ }
+
+ { //test back()
+ const IntType test_this(1);
+ if(test_this != boostvector.back()) return 1;
+ }
+ { //pop_back with enough capacity
+ boostvector.pop_back();
+ boostvector.pop_back();
+ stdvector.pop_back();
+ stdvector.pop_back();
+
+ IntType push_back_this(1);
+ boostvector.push_back(boost::move(push_back_this));
+ stdvector.push_back(int(1));
+ boostvector.push_back(IntType(1));
+ stdvector.push_back(int(1));
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ }
+
+ if(!vector_copyable_only(boostvector, stdvector
+ ,dtl::bool_<boost::container::test::is_copyable<IntType>::value>())){
+ return 1;
+ }
+
+ boostvector.erase(boostvector.begin());
+ stdvector.erase(stdvector.begin());
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ for(int i = 0; i < max; ++i){
+ IntType insert_this(i);
+ boostvector.insert(boostvector.begin(), boost::move(insert_this));
+ stdvector.insert(stdvector.begin(), i);
+ boostvector.insert(boostvector.begin(), IntType(i));
+ stdvector.insert(stdvector.begin(), int(i));
+ }
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ //some comparison operators
+ if(!(boostvector == boostvector))
+ return 1;
+ if(boostvector != boostvector)
+ return 1;
+ if(boostvector < boostvector)
+ return 1;
+ if(boostvector > boostvector)
+ return 1;
+ if(!(boostvector <= boostvector))
+ return 1;
+ if(!(boostvector >= boostvector))
+ return 1;
+
+ //Test insertion from list
+ {
+ std::list<int> l(50, int(1));
+ typename MyBoostVector::iterator it_insert =
+ boostvector.insert(boostvector.begin(), l.begin(), l.end());
+ if(boostvector.begin() != it_insert) return 1;
+ stdvector.insert(stdvector.begin(), l.begin(), l.end());
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ boostvector.assign(l.begin(), l.end());
+ stdvector.assign(l.begin(), l.end());
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+ boostvector.clear();
+ stdvector.clear();
+ boostvector.assign(make_input_from_forward_iterator(l.begin()), make_input_from_forward_iterator(l.end()));
+ stdvector.assign(l.begin(), l.end());
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+ }
+
+ if(!vector_vector_hash_function_capacity_only(boostvector, stdvector, dtl::bool_<vector_hash_function_capacity<MyBoostVector>::value>()))
+ return 1;
+
+ boostvector.clear();
+ stdvector.clear();
+ boostvector.shrink_to_fit();
+ MyStdVector(stdvector).swap(stdvector);
+ if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+
+ boostvector.resize(100);
+ if(!test_nth_index_of(boostvector))
+ return 1;
+
+ }
+ std::cout << std::endl << "Test OK!" << std::endl;
+ return 0;
+}
+
+template<typename VectorContainerType>
+bool test_vector_methods_with_initializer_list_as_argument_for()
+{
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+ typedef typename VectorContainerType::allocator_type allocator_type;
+ {
+ const VectorContainerType testedVector = {1, 2, 3};
+ const std::vector<int> expectedVector = {1, 2, 3};
+ if(!test::CheckEqualContainers(testedVector, expectedVector)) return false;
+ }
+ {
+ const VectorContainerType testedVector( { 1, 2, 3 }, allocator_type() );
+ const std::vector<int> expectedVector = {1, 2, 3};
+ if(!test::CheckEqualContainers(testedVector, expectedVector)) return false;
+ }
+ {
+ VectorContainerType testedVector = {1, 2, 3};
+ testedVector = {11, 12, 13};
+
+ const std::vector<int> expectedVector = {11, 12, 13};
+ if(!test::CheckEqualContainers(testedVector, expectedVector)) return false;
+ }
+
+ {
+ VectorContainerType testedVector = {1, 2, 3};
+ testedVector.assign({5, 6, 7});
+
+ const std::vector<int> expectedVector = {5, 6, 7};
+ if(!test::CheckEqualContainers(testedVector, expectedVector)) return false;
+ }
+
+ {
+ VectorContainerType testedVector = {1, 2, 3};
+ testedVector.insert(testedVector.cend(), {5, 6, 7});
+
+ const std::vector<int> expectedVector = {1, 2, 3, 5, 6, 7};
+ if(!test::CheckEqualContainers(testedVector, expectedVector)) return false;
+ }
+ return true;
+#else
+ return true;
+#endif
+}
+
+} //namespace test{
+} //namespace container {
+} //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //BOOST_CONTAINER_TEST_VECTOR_TEST_HEADER