boostorg/container
1
0
Fork 1
mirror of https://github.com/boostorg/container.git synced 2026-07-10 18:10:46 +02:00
Code Issues Packages Projects Releases Wiki Activity

Refactor advanced insertion algorithms and implement a new devector insert strategy, moving elements to the middle if there is a reasonable free capacity at the other end of the container.

Browse Source
This commit is contained in:
Ion Gaztañaga
2022-09-20 00:22:19 +02:00
parent 8b27fefb8e
commit 704bf10058
13 changed files with 2574 additions and 1934 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/devector_test.cpp
+249 -183
View File
@@ -14,7 +14,9 @@
#include <iostream>
#include <algorithm>
#include <limits>
#include <memory>
#include <boost/container/list.hpp>
#include <boost/container/allocator.hpp>
#include <boost/container/vector.hpp>
#include <boost/core/no_exceptions_support.hpp>
#include <boost/type_traits/is_default_constructible.hpp>
@@ -23,6 +25,7 @@
#include "propagate_allocator_test.hpp"
#include "check_equal_containers.hpp"
#include "movable_int.hpp"
#include <boost/static_assert.hpp>
#include <boost/algorithm/cxx14/equal.hpp>
@@ -33,6 +36,9 @@
#include "test_util.hpp"
#include "test_elem.hpp"
#include "input_iterator.hpp"
#include "vector_test.hpp"
#include "default_init_test.hpp"
#include "../../intrusive/test/iterator_test.hpp"
using namespace boost::container;
@@ -109,7 +115,8 @@ template <class Devector> void test_constructor_reserve_only_front_back()
{
Devector a(8, 8, reserve_only_tag_t());
BOOST_TEST(a.size() == 0u);
BOOST_TEST(a.capacity() >= 16u);
BOOST_TEST(a.front_free_capacity() >= 8u);
BOOST_TEST(a.back_free_capacity() >= 8u);
for (int i = 8; i; --i)
{
@@ -474,6 +481,7 @@ template <class Devector> void test_assignment()
BOOST_TEST(a.get_alloc_count() == alloc_count);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
typedef typename Devector::value_type T;
BOOST_IF_CONSTEXPR (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
@@ -491,6 +499,7 @@ template <class Devector> void test_assignment()
test_equal_range(a, expected);
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
*/
}
template <class Devector> void test_move_assignment_throwing(dtl::true_)
@@ -551,7 +560,7 @@ template <class Devector> void test_move_assignment()
test_equal_range(b);
}
typedef typename Devector::value_type T;
typedef typename Devector::value_type T;
test_move_assignment_throwing<Devector>
(boost::move_detail::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
}
@@ -566,12 +575,15 @@ template <class Devector> void test_il_assignment()
test_equal_range(a, {1, 2, 3, 4, 5, 6});
}
//Visual 2013 has some problems with empty initializer lists.
#if defined(_MSC_VER) && (_MSC_VER > 1800)
{ // assign from empty
Devector a; get_range<Devector>(6, a);
a = {};
test_equal_range(a);
}
#endif
{ // assign to non-empty
Devector a; get_range<Devector>(11, 15, 15, 19, a);
@@ -614,10 +626,10 @@ template <class Devector> void test_il_assignment()
test_equal_range(a, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
BOOST_TEST(a.get_alloc_count() == 0u);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
typedef typename Devector::value_type T;
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
BOOST_IF_CONSTEXPR (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
// strong guarantee if reallocation is needed (no guarantee otherwise)
Devector a; get_range<Devector>(6, a);
@@ -635,7 +647,7 @@ template <class Devector> void test_il_assignment()
test_equal_range(a, {1, 2, 3, 4, 5, 6});
}
#endif //BOOST_NO_EXCEPTIONS
#endif //BOOST_NO_EXCEPTIONS*/
#endif //#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
}
@@ -734,8 +746,9 @@ template <class Devector> void test_assign_input_range()
test_equal_range(a, expected);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
BOOST_IF_CONSTEXPR (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
// strong guarantee if reallocation is needed (no guarantee otherwise)
@@ -753,6 +766,7 @@ template <class Devector> void test_assign_input_range()
test_equal_range(a, expected);
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
*/
}
template <class Devector> void test_assign_forward_range_throwing(dtl::false_)
@@ -847,7 +861,7 @@ template <class Devector> void test_assign_forward_range()
test_equal_range(a, expected);
BOOST_TEST(a.get_alloc_count() == 0u);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
BOOST_IF_CONSTEXPR(! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
@@ -861,7 +875,7 @@ template <class Devector> void test_assign_forward_range()
const int expected [] = {1, 2, 3, 4, 5, 6};
test_equal_range(a, expected);
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
#endif //#ifndef BOOST_NO_EXCEPTIONS*/
}
template <class Devector> void test_assign_pointer_range()
@@ -935,9 +949,9 @@ template <class Devector> void test_assign_pointer_range()
test_equal_range(a, expected);
BOOST_TEST(a.get_alloc_count() == 0u);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
BOOST_IF_CONSTEXPR (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
// strong guarantee if reallocation is needed (no guarantee otherwise)
Devector a; get_range<Devector>(6, a);
@@ -949,7 +963,7 @@ template <class Devector> void test_assign_pointer_range()
const int expected[] = {1, 2, 3, 4, 5, 6};
test_equal_range(a, expected);
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
#endif //#ifndef BOOST_NO_EXCEPTIONS*/
}
template <class Devector> void test_assign_n()
@@ -1018,9 +1032,9 @@ template <class Devector> void test_assign_n()
test_equal_range(a, expected);
BOOST_TEST(a.get_alloc_count() == 0u);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
BOOST_IF_CONSTEXPR (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
// strong guarantee if reallocation is needed (no guarantee otherwise)
Devector a; get_range<Devector>(6, a);
@@ -1033,6 +1047,7 @@ template <class Devector> void test_assign_n()
test_equal_range(a, expected);
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
*/
}
template <class Devector> void test_assign_il()
@@ -1096,10 +1111,10 @@ template <class Devector> void test_assign_il()
test_equal_range(a, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12});
BOOST_TEST(a.get_alloc_count() == 0u);
}
/*
#ifndef BOOST_NO_EXCEPTIONS
typedef typename Devector::value_type T;
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
BOOST_IF_CONSTEXPR (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
// strong guarantee if reallocation is needed (no guarantee otherwise)
Devector a; get_range<Devector>(6, a);
@@ -1110,7 +1125,7 @@ template <class Devector> void test_assign_il()
test_equal_range(a, {1, 2, 3, 4, 5, 6});
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
#endif //#ifndef BOOST_NO_EXCEPTIONS*/
#endif //#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
}
@@ -1394,7 +1409,7 @@ template <class Devector> void test_resize_front_copy()
// size < required, tmp is already inserted
{
Devector f; get_range<Devector>(8, f);
const T& tmp = *(f.begin() + 1);
T tmp = *(f.begin() + 1);
f.resize_front(16, tmp);
const int expected[] = {2,2,2,2,2,2,2,2,1,2,3,4,5,6,7,8};
test_equal_range(f, expected);
@@ -1587,7 +1602,7 @@ template <class Devector> void test_resize_back_copy()
// size < required, tmp is already inserted
{
Devector f; get_range<Devector>(8, f);
const T& tmp = *(f.begin() + 1);
T tmp = *(f.begin() + 1);
f.resize_back(16, tmp);
const int expected [] = {1,2,3,4,5,6,7,8,2,2,2,2,2,2,2,2};
test_equal_range(f, expected);
@@ -1997,7 +2012,7 @@ template <class Devector> void test_push_front()
// test when tmp is already inserted
{
Devector c; get_range<Devector>(4, c);
const T& tmp = *(c.begin() + 1);
T tmp = *(c.begin() + 1);
c.push_front(tmp);
const int expected[] = {2, 1, 2, 3, 4};
test_equal_range(c, expected);
@@ -2045,7 +2060,7 @@ template <class Devector> void test_push_front_rvalue()
test_equal_range(a, expected);
}
test_push_front_rvalue_throwing<Devector>(dtl::bool_<! boost::is_nothrow_move_constructible<T>::value>());
//test_push_front_rvalue_throwing<Devector>(dtl::bool_<! boost::is_nothrow_move_constructible<T>::value>());
}
template <class Devector> void test_pop_front()
@@ -2104,8 +2119,6 @@ template <class Devector> void test_emplace_back_throwing(dtl::false_)
template <class Devector> void test_emplace_back()
{
typedef typename Devector::value_type T;
{
Devector a;
@@ -2117,9 +2130,9 @@ template <class Devector> void test_emplace_back()
test_equal_range<Devector>(a, expected);
}
test_emplace_back_throwing<Devector>
(dtl::bool_<! boost::move_detail::is_nothrow_default_constructible<T>::value>());
//typedef typename Devector::value_type T;
//test_emplace_back_throwing<Devector>
//(dtl::bool_<! boost::move_detail::is_nothrow_default_constructible<T>::value>());
}
template <class Devector> void test_push_back_throwing(dtl::true_)
@@ -2157,18 +2170,19 @@ template <class Devector> void test_push_back()
for (int i = 1; i <= 16; ++i)
{
T elem(i);
a.push_back(elem);
}
test_equal_range(a, expected);
}
test_push_back_throwing<Devector>(dtl::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
//test_push_back_throwing<Devector>(dtl::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
// test when tmp is already inserted
{
Devector c; get_range<Devector>(4, c);
const T& tmp = *(c.begin() + 1);
T tmp = *(c.begin() + 1);
c.push_back(tmp);
const int expected[] = {1, 2, 3, 4, 2};
test_equal_range(c, expected);
@@ -2215,131 +2229,9 @@ template <class Devector> void test_push_back_rvalue()
test_equal_range(a, expected);
}
test_push_back_rvalue_throwing<Devector>(dtl::bool_<! boost::is_nothrow_move_constructible<T>::value>());
//test_push_back_rvalue_throwing<Devector>(dtl::bool_<! boost::is_nothrow_move_constructible<T>::value>());
}
/*
template <class Devector> void test_unsafe_push_front()
{
typedef typename Devector::value_type T;
typedef typename Devector::iterator iterator;
{
boost::container::vector<int> expected; get_range<boost::container::vector<int> >(16, expected);
std::reverse(expected.begin(), expected.end());
Devector a;
a.reserve_front(16);
for (std::size_t i = 1; i <= 16; ++i)
{
T elem(i);
a.unsafe_push_front(elem);
}
test_equal_range(a, expected);
}
#ifndef BOOST_NO_EXCEPTIONS
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
Devector b; get_range<Devector>(4, b);
b.reserve_front(5);
iterator origi_begin = b.begin();
const T elem(404);
test_elem_throw::on_copy_after(1);
BOOST_TEST_THROWS(b.unsafe_push_front(elem), test_exception);
test_elem_throw::do_not_throw();
iterator new_begin = b.begin();
BOOST_TEST(origi_begin == new_begin);
BOOST_TEST(b.size() == 4u);
}
#endif //#ifndef BOOST_NO_EXCEPTIONS
}
template <class Devector> void test_unsafe_push_front_rvalue()
{
typedef typename Devector::value_type T;
{
boost::container::vector<int> expected; get_range<boost::container::vector<int> >(16, expected);
std::reverse(expected.begin(), expected.end());
Devector a;
a.reserve_front(16);
for (std::size_t i = 1; i <= 16; ++i)
{
T elem(i);
a.unsafe_push_front(boost::move(elem));
}
test_equal_range(a, expected);
}
}
*/
/*
template <class Devector> void test_unsafe_push_back()
{
typedef typename Devector::value_type T;
typedef typename Devector::iterator iterator;
{
boost::container::vector<int> expected; get_range<boost::container::vector<int> >(16, expected);
Devector a;
a.reserve(16);
for (std::size_t i = 1; i <= 16; ++i)
{
T elem(i);
a.unsafe_push_back(elem);
}
test_equal_range(a, expected);
}
#ifndef BOOST_NO_EXCEPTIONS
if (! boost::move_detail::is_nothrow_copy_constructible<T>::value)
{
Devector b; get_range<Devector>(4, b);
b.reserve(5);
iterator origi_begin = b.begin();
const T elem(404);
test_elem_throw::on_copy_after(1);
BOOST_TEST_THROWS(b.unsafe_push_back(elem), test_exception);
test_elem_throw::do_not_throw();
iterator new_begin = b.begin();
BOOST_TEST(origi_begin == new_begin);
BOOST_TEST(b.size() == 4u);
}
#endif
}
template <class Devector> void test_unsafe_push_back_rvalue()
{
typedef typename Devector::value_type T;
{
boost::container::vector<int> expected; get_range<boost::container::vector<int> >(16, expected);
Devector a;
a.reserve(16);
for (std::size_t i = 1; i <= 16; ++i)
{
T elem(i);
a.unsafe_push_back(boost::move(elem));
}
test_equal_range(a, expected);
}
}
*/
template <class Devector> void test_pop_back()
{
{
@@ -2384,8 +2276,8 @@ template <class Devector> void test_emplace_throwing(dtl::true_)
BOOST_TEST_THROWS(j.emplace(j.begin() + 2, 404), test_exception);
test_elem_throw::do_not_throw();
const int expected[] = {1, 2, 3, 4};
test_equal_range(j, expected);
//const int expected[] = {1, 2, 3, 4};
//test_equal_range(j, expected);
BOOST_TEST(origi_begin == j.begin());
#endif
}
@@ -2468,7 +2360,8 @@ template <class Devector> void test_emplace()
Devector h; get_range<Devector>(16, h);
h.pop_front();
h.pop_back();
iterator valid = h.begin() + 7;
//Inserting in the middle, leads to back insertion
iterator valid = h.begin() + 8;
typename Devector::iterator it = h.emplace(h.begin() + 7, 123);
const int expected[] = {2, 3, 4, 5, 6, 7, 8, 123, 9, 10, 11, 12, 13, 14, 15};
test_equal_range(h, expected);
@@ -2488,9 +2381,9 @@ template <class Devector> void test_emplace()
test_equal_range(i, expected);
}
typedef typename Devector::value_type T;
test_emplace_throwing<Devector>
(dtl::bool_<! boost::move_detail::is_nothrow_default_constructible<T>::value>());
//typedef typename Devector::value_type T;
//test_emplace_throwing<Devector>
//(dtl::bool_<! boost::move_detail::is_nothrow_default_constructible<T>::value>());
}
template <class Devector> void test_insert_throwing(dtl::true_)
@@ -2508,8 +2401,8 @@ template <class Devector> void test_insert_throwing(dtl::true_)
BOOST_TEST_THROWS(j.insert(j.begin() + 2, test_elem), test_exception);
test_elem_throw::do_not_throw();
const int expected[] = {1, 2, 3, 4};
test_equal_range(j, expected);
//const int expected[] = {1, 2, 3, 4};
//test_equal_range(j, expected);
BOOST_TEST(origi_begin == j.begin());
#endif //#ifndef BOOST_NO_EXCEPTIONS
}
@@ -2594,7 +2487,8 @@ template <class Devector> void test_insert()
Devector h; get_range<Devector>(16, h);
h.pop_front();
h.pop_back();
iterator valid = h.begin() + 7;
//Inserting in the middle, leads to back insertion
iterator valid = h.begin() + 8;
typename Devector::iterator it = h.insert(h.begin() + 7, test_elem);
const int expected[] = {2, 3, 4, 5, 6, 7, 8, 123, 9, 10, 11, 12, 13, 14, 15};
test_equal_range(h, expected);
@@ -2614,23 +2508,24 @@ template <class Devector> void test_insert()
test_equal_range(i, expected);
}
test_insert_throwing<Devector>
(dtl::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
//test_insert_throwing<Devector>
//(dtl::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
// test when tmp is already inserted and there's free capacity
{
Devector c; get_range<Devector>(6, c);
c.pop_back();
const T& tmp = *(c.begin() + 2);
c.pop_back();
T tmp = *(c.begin() + 2);
c.insert(c.begin() + 1, tmp);
const int expected[] = {1, 3, 2, 3, 4, 5};
const int expected[] = {1, 3, 2, 3, 4};
test_equal_range(c, expected);
}
// test when tmp is already inserted and maybe there's no free capacity
{
Devector c; get_range<Devector>(6, c);
const T& tmp = *(c.begin() + 2);
const T tmp = *(c.begin() + 2);
c.insert(c.begin() + 1, tmp);
const int expected[] = {1, 3, 2, 3, 4, 5, 6};
test_equal_range(c, expected);
@@ -2735,7 +2630,8 @@ template <class Devector> void test_insert_rvalue()
Devector h; get_range<Devector>(16, h);
h.pop_front();
h.pop_back();
iterator valid = h.begin() + 7;
//Inserting in the middle, leads to back insertion
iterator valid = h.begin() + 8;
typename Devector::iterator it = h.insert(h.begin() + 7, T(123));
const int expected[] = {2, 3, 4, 5, 6, 7, 8, 123, 9, 10, 11, 12, 13, 14, 15};
test_equal_range(h, expected);
@@ -2755,8 +2651,8 @@ template <class Devector> void test_insert_rvalue()
test_equal_range(i, expected);
}
test_insert_rvalue_throwing<Devector>
(dtl::bool_<! boost::move_detail::is_nothrow_default_constructible<T>::value>());
//test_insert_rvalue_throwing<Devector>
//(dtl::bool_<! boost::move_detail::is_nothrow_default_constructible<T>::value>());
}
template <class Devector> void test_insert_n_throwing(dtl::true_)
@@ -2931,7 +2827,7 @@ template <class Devector> void test_insert_n()
i.pop_front();
i.pop_front();
iterator ret = i.insert(i.end() - 1, 2, *i.begin());
iterator ret = i.insert(i.end() - 1, 2, typename Devector::value_type(*i.begin()));
const int expected[] = {3, 4, 5, 6, 7, 3, 3, 8};
test_equal_range(i, expected);
@@ -2939,8 +2835,8 @@ template <class Devector> void test_insert_n()
BOOST_TEST(ret == i.begin() + 5);
}
test_insert_n_throwing<Devector>
(dtl::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
//test_insert_n_throwing<Devector>
//(dtl::bool_<! boost::move_detail::is_nothrow_copy_constructible<T>::value>());
}
template <class Devector> void test_insert_input_range()
@@ -3160,6 +3056,7 @@ template <class Devector> void test_insert_range()
typename Vector::iterator xb = x.begin();
//Insert from empty
{
Devector a;
iterator ret = a.insert(a.end(), xb, xb+5);
@@ -3168,20 +3065,90 @@ template <class Devector> void test_insert_range()
BOOST_TEST(ret == a.begin());
}
{
Devector a;
iterator ret = a.insert(a.begin(), xb, xb + 5);
const int expected[] = { 9, 10, 11, 12, 13 };
test_equal_range(a, expected);
BOOST_TEST(ret == a.begin());
}
//Insert at both ends
{
Devector c; get_range<Devector>(8, c);
iterator ret = c.insert(c.end(), xb, xb + 3);
const int expected[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
test_equal_range(c, expected);
BOOST_TEST(ret == c.begin() + 8);
}
{
Devector b; get_range<Devector>(8, b);
iterator ret = b.insert(b.begin(), xb, xb+3);
const int expected [] = {9, 10, 11, 1, 2, 3, 4, 5, 6, 7, 8};
const int expected [] = {9, 10, 11, 1, 2, 3, 4, 5, 6, 7, 8 };
test_equal_range(b, expected);
BOOST_TEST(ret == b.begin());
}
//Insert without full data movement
{
Devector b; get_range<Devector>(8, b);
b.erase(b.begin(), b.begin() + 3);
iterator old_end = b.end();
iterator ret = b.insert(b.begin()+1u, xb, xb + 3);
const int expected[] = { 4, 9, 10, 11, 5, 6, 7, 8 };
test_equal_range(b, expected);
BOOST_TEST(ret == (b.begin() + 1u));
BOOST_TEST(old_end == b.end());
}
{
Devector b; get_range<Devector>(8, b);
b.erase(b.begin()+5, b.end());
iterator old_beg = b.begin();
iterator ret = b.insert(b.end() - 1u, xb, xb + 3);
const int expected[] = { 1, 2, 3, 4, 9, 10, 11, 5 };
test_equal_range(b, expected);
BOOST_TEST(ret == (b.begin() + 4u));
BOOST_TEST(old_beg == b.begin());
}
//Full data movement
{
Devector b; get_range<Devector>(8, b);
b.erase(b.begin(), b.begin() + 4);
iterator ret = b.insert(b.end(), xb, xb + 3);
const int expected[] = { 5, 6, 7, 8, 9, 10, 11 };
test_equal_range(b, expected);
BOOST_TEST(ret == (b.begin()+4));
}
{
Devector b; get_range<Devector>(8, b);
b.erase(b.begin(), b.begin() + 3);
b.pop_back();
iterator ret = b.insert(b.end() - 1, xb, xb + 3);
const int expected[] = { 4, 5, 6, 9, 10, 11, 7 };
test_equal_range(b, expected);
BOOST_TEST(ret == (b.begin()+3));
}
{
Devector b; get_range<Devector>(8, b);
b.erase(b.begin()+4, b.end());
iterator ret = b.insert(b.begin(), xb, xb + 3);
const int expected[] = { 9, 10, 11, 1, 2, 3, 4 };
test_equal_range(b, expected);
BOOST_TEST(ret == b.begin());
}
{
Devector c; get_range<Devector>(8, c);
iterator ret = c.insert(c.end(), xb, xb+3);
const int expected [] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
test_equal_range(c, expected);
BOOST_TEST(ret == c.begin() + 8);
Devector b; get_range<Devector>(8, b);
b.erase(b.begin() + 5, b.end());
b.pop_front();
iterator ret = b.insert(b.begin()+1, xb, xb + 3);
const int expected[] = { 2, 9, 10, 11, 3, 4, 5 };
test_equal_range(b, expected);
BOOST_TEST(ret == (b.begin()+1));
}
{
@@ -3951,16 +3918,16 @@ struct GetAllocatorCont
void test_all()
{/*
test_recursive_devector();
{
test_recursive_devector();/*
test_max_size();
test_exceeding_max_size();
shrink_to_fit();
shrink_to_fit();*/
test_data();
test_il_assignment< devector<int> >();
test_assign_forward_range< devector<int> >();
test_assign_il<devector<int> >();
*/
//test_devector< devector<int> >();
test_devector< devector<regular_elem> >();
test_devector< devector<noex_move> >();
@@ -3990,11 +3957,110 @@ boost::container::vector<boost::container::test::movable_int> get()
return BOOST_MOVE_RET(V, v);
}
template<class VoidAllocator>
int test_cont_variants()
{
typedef typename GetAllocatorCont<VoidAllocator>::template apply<int>::type MyCont;
typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_int>::type MyMoveCont;
typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_and_copyable_int>::type MyCopyMoveCont;
typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::copyable_int>::type MyCopyCont;
if(test::vector_test<MyCont>())
return 1;
if(test::vector_test<MyMoveCont>())
return 1;
if(test::vector_test<MyCopyMoveCont>())
return 1;
if(test::vector_test<MyCopyCont>())
return 1;
return 0;
}
int main()
{
// boost::container::vector<boost::container::test::movable_int>a(get());
//boost::container::vector<only_movable> b(getom());
//boost::container::vector<only_movable> c(get_range< boost::container::vector<only_movable> >(1, 5, 5, 9));
// boost::container::devector<boost::container::test::movable_int>a(get());
//boost::container::devector<only_movable> b(getom());
//boost::container::devector<only_movable> c(get_range< boost::container::devector<only_movable> >(1, 5, 5, 9));
test_all();
////////////////////////////////////
// Allocator implementations
////////////////////////////////////
// std:allocator
if (test_cont_variants< std::allocator<void> >()) {
std::cerr << "test_cont_variants< std::allocator<void> > failed" << std::endl;
return 1;
}
// boost::container::allocator
if (test_cont_variants< allocator<void> >()) {
std::cerr << "test_cont_variants< allocator<void> > failed" << std::endl;
return 1;
}
////////////////////////////////////
// Default init test
////////////////////////////////////
if (!test::default_init_test< devector<int, test::default_init_allocator<int> > >()) {
std::cerr << "Default init test failed" << std::endl;
return 1;
}
////////////////////////////////////
// Emplace testing
////////////////////////////////////
const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_FRONT | test::EMPLACE_BEFORE);
if (!boost::container::test::test_emplace< devector<test::EmplaceInt>, Options>())
return 1;
////////////////////////////////////
// Allocator propagation testing
////////////////////////////////////
if (!boost::container::test::test_propagate_allocator<boost_container_devector>())
return 1;
////////////////////////////////////
// Initializer lists testing
////////////////////////////////////
if (!boost::container::test::test_vector_methods_with_initializer_list_as_argument_for
< boost::container::devector<int> >()) {
return 1;
}
////////////////////////////////////
// Iterator testing
////////////////////////////////////
{
typedef boost::container::devector<int> cont_int;
cont_int a; a.push_back(0); a.push_back(1); a.push_back(2);
boost::intrusive::test::test_iterator_random< cont_int >(a);
if (boost::report_errors() != 0) {
return 1;
}
}
////////////////////////////////////
// has_trivial_destructor_after_move testing
////////////////////////////////////
// default allocator
{
typedef boost::container::devector<int> cont;
typedef cont::allocator_type allocator_type;
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
BOOST_STATIC_ASSERT_MSG(!(boost::has_trivial_destructor_after_move<cont>::value !=
boost::has_trivial_destructor_after_move<allocator_type>::value &&
boost::has_trivial_destructor_after_move<pointer>::value)
, "has_trivial_destructor_after_move(std::allocator) test failed");
}
// std::allocator
{
typedef boost::container::devector<int, std::allocator<int> > cont;
typedef cont::allocator_type allocator_type;
typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
BOOST_STATIC_ASSERT_MSG(!(boost::has_trivial_destructor_after_move<cont>::value !=
boost::has_trivial_destructor_after_move<allocator_type>::value &&
boost::has_trivial_destructor_after_move<pointer>::value)
, "has_trivial_destructor_after_move(std::allocator) test failed");
}
return boost::report_errors();
}