container/test/scoped_allocator_adaptor_test.cpp

1378 lines
60 KiB
C++

//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2011-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.
//
//////////////////////////////////////////////////////////////////////////////
#include <boost/container/detail/config_begin.hpp>
#include <boost/container/scoped_allocator_fwd.hpp>
// container/detail
#include <boost/container/detail/mpl.hpp>
// move
#include <boost/move/utility_core.hpp>
#include <boost/move/adl_move_swap.hpp>
//boost
#include <boost/tuple/tuple.hpp>
// std
#include <memory>
#include <cstddef>
#if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE)
#include <tuple>
#endif
//test
#include <boost/core/lightweight_test.hpp>
#include "allocator_argument_tester.hpp"
template<unsigned int Type>
struct tagged_integer
{};
struct mark_on_destructor
{
mark_on_destructor()
{
destroyed = false;
}
~mark_on_destructor()
{
destroyed = true;
}
static bool destroyed;
};
bool mark_on_destructor::destroyed = false;
#include <boost/container/scoped_allocator.hpp>
#include <boost/static_assert.hpp>
#include <boost/container/vector.hpp>
#include <boost/container/detail/pair.hpp>
int main()
{
using namespace boost::container;
typedef propagation_test_allocator<tagged_integer<0>, 0> OuterAlloc;
typedef propagation_test_allocator<tagged_integer<0>, 10> Outer10IdAlloc;
typedef propagation_test_allocator<tagged_integer<9>, 0> Rebound9OuterAlloc;
typedef propagation_test_allocator<tagged_integer<1>, 1> InnerAlloc1;
typedef propagation_test_allocator<tagged_integer<2>, 2> InnerAlloc2;
typedef propagation_test_allocator<tagged_integer<1>, 11> Inner11IdAlloc1;
typedef propagation_test_allocator<tagged_integer<0>, 0, false> OuterAllocFalseHasTrueTypes;
typedef propagation_test_allocator<tagged_integer<0>, 0, true> OuterAllocTrueHasTrueTypes;
typedef propagation_test_allocator<tagged_integer<1>, 1, false> InnerAlloc1FalseHasTrueTypes;
typedef propagation_test_allocator<tagged_integer<1>, 1, true> InnerAlloc1TrueHasTrueTypes;
typedef propagation_test_allocator<tagged_integer<2>, 2, false> InnerAlloc2FalseHasTrueTypes;
typedef propagation_test_allocator<tagged_integer<2>, 2, true> InnerAlloc2TrueHasTrueTypes;
//
typedef scoped_allocator_adaptor< OuterAlloc > Scoped0Inner;
typedef scoped_allocator_adaptor< OuterAlloc
, InnerAlloc1 > Scoped1Inner;
typedef scoped_allocator_adaptor< OuterAlloc
, InnerAlloc1
, InnerAlloc2 > Scoped2Inner;
typedef scoped_allocator_adaptor
< scoped_allocator_adaptor
<Outer10IdAlloc>
> ScopedScoped0Inner;
typedef scoped_allocator_adaptor
< scoped_allocator_adaptor
<Outer10IdAlloc, Inner11IdAlloc1>
, InnerAlloc1
> ScopedScoped1Inner;
typedef scoped_allocator_adaptor< Rebound9OuterAlloc > Rebound9Scoped0Inner;
typedef scoped_allocator_adaptor< Rebound9OuterAlloc
, InnerAlloc1 > Rebound9Scoped1Inner;
typedef scoped_allocator_adaptor< Rebound9OuterAlloc
, InnerAlloc1
, InnerAlloc2 > Rebound9Scoped2Inner;
//outer_allocator_type
BOOST_STATIC_ASSERT(( dtl::is_same< OuterAlloc
, Scoped0Inner::outer_allocator_type>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< OuterAlloc
, Scoped1Inner::outer_allocator_type>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< OuterAlloc
, Scoped2Inner::outer_allocator_type>::value ));
//value_type
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
, Scoped0Inner::value_type>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
, Scoped1Inner::value_type>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
, Scoped2Inner::value_type>::value ));
//size_type
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
, Scoped0Inner::size_type>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
, Scoped1Inner::size_type>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
, Scoped2Inner::size_type>::value ));
//difference_type
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
, Scoped0Inner::difference_type>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
, Scoped1Inner::difference_type>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
, Scoped2Inner::difference_type>::value ));
//pointer
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
, Scoped0Inner::pointer>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
, Scoped1Inner::pointer>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
, Scoped2Inner::pointer>::value ));
//const_pointer
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
, Scoped0Inner::const_pointer>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
, Scoped1Inner::const_pointer>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
, Scoped2Inner::const_pointer>::value ));
//void_pointer
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
, Scoped0Inner::void_pointer>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
, Scoped1Inner::void_pointer>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
, Scoped2Inner::void_pointer>::value ));
//const_void_pointer
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
, Scoped0Inner::const_void_pointer>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
, Scoped1Inner::const_void_pointer>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
, Scoped2Inner::const_void_pointer>::value ));
//rebind
BOOST_STATIC_ASSERT(( dtl::is_same<Scoped0Inner::rebind< tagged_integer<9> >::other
, Rebound9Scoped0Inner >::value ));
BOOST_STATIC_ASSERT(( dtl::is_same<Scoped1Inner::rebind< tagged_integer<9> >::other
, Rebound9Scoped1Inner >::value ));
BOOST_STATIC_ASSERT(( dtl::is_same<Scoped2Inner::rebind< tagged_integer<9> >::other
, Rebound9Scoped2Inner >::value ));
//inner_allocator_type
BOOST_STATIC_ASSERT(( dtl::is_same< Scoped0Inner
, Scoped0Inner::inner_allocator_type>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< scoped_allocator_adaptor<InnerAlloc1>
, Scoped1Inner::inner_allocator_type>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same< scoped_allocator_adaptor<InnerAlloc1, InnerAlloc2>
, Scoped2Inner::inner_allocator_type>::value ));
{
//Propagation test
typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes > Scoped0InnerF;
typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes > Scoped0InnerT;
typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes
, InnerAlloc1FalseHasTrueTypes > Scoped1InnerFF;
typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes
, InnerAlloc1TrueHasTrueTypes > Scoped1InnerFT;
typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes
, InnerAlloc1FalseHasTrueTypes > Scoped1InnerTF;
typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes
, InnerAlloc1TrueHasTrueTypes > Scoped1InnerTT;
typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes
, InnerAlloc1FalseHasTrueTypes
, InnerAlloc2FalseHasTrueTypes > Scoped2InnerFFF;
typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes
, InnerAlloc1FalseHasTrueTypes
, InnerAlloc2TrueHasTrueTypes > Scoped2InnerFFT;
typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes
, InnerAlloc1TrueHasTrueTypes
, InnerAlloc2FalseHasTrueTypes > Scoped2InnerFTF;
typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes
, InnerAlloc1TrueHasTrueTypes
, InnerAlloc2TrueHasTrueTypes > Scoped2InnerFTT;
typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes
, InnerAlloc1FalseHasTrueTypes
, InnerAlloc2FalseHasTrueTypes > Scoped2InnerTFF;
typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes
, InnerAlloc1FalseHasTrueTypes
, InnerAlloc2TrueHasTrueTypes > Scoped2InnerTFT;
typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes
, InnerAlloc1TrueHasTrueTypes
, InnerAlloc2FalseHasTrueTypes > Scoped2InnerTTF;
typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes
, InnerAlloc1TrueHasTrueTypes
, InnerAlloc2TrueHasTrueTypes > Scoped2InnerTTT;
//propagate_on_container_copy_assignment
//0 inner
BOOST_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_copy_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped0InnerT::propagate_on_container_copy_assignment::value ));
//1 inner
BOOST_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_copy_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped1InnerFT::propagate_on_container_copy_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped1InnerTF::propagate_on_container_copy_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped1InnerTT::propagate_on_container_copy_assignment::value ));
//2 inner
BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_copy_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerFFT::propagate_on_container_copy_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerFTF::propagate_on_container_copy_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerFTT::propagate_on_container_copy_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerTFF::propagate_on_container_copy_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerTFT::propagate_on_container_copy_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerTTF::propagate_on_container_copy_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerTTT::propagate_on_container_copy_assignment::value ));
//propagate_on_container_move_assignment
//0 inner
BOOST_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_move_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped0InnerT::propagate_on_container_move_assignment::value ));
//1 inner
BOOST_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_move_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped1InnerFT::propagate_on_container_move_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped1InnerTF::propagate_on_container_move_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped1InnerTT::propagate_on_container_move_assignment::value ));
//2 inner
BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_move_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerFFT::propagate_on_container_move_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerFTF::propagate_on_container_move_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerFTT::propagate_on_container_move_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerTFF::propagate_on_container_move_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerTFT::propagate_on_container_move_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerTTF::propagate_on_container_move_assignment::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerTTT::propagate_on_container_move_assignment::value ));
//propagate_on_container_swap
//0 inner
BOOST_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_swap::value ));
BOOST_STATIC_ASSERT(( Scoped0InnerT::propagate_on_container_swap::value ));
//1 inner
BOOST_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_swap::value ));
BOOST_STATIC_ASSERT(( Scoped1InnerFT::propagate_on_container_swap::value ));
BOOST_STATIC_ASSERT(( Scoped1InnerTF::propagate_on_container_swap::value ));
BOOST_STATIC_ASSERT(( Scoped1InnerTT::propagate_on_container_swap::value ));
//2 inner
BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_swap::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerFFT::propagate_on_container_swap::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerFTF::propagate_on_container_swap::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerFTT::propagate_on_container_swap::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerTFF::propagate_on_container_swap::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerTFT::propagate_on_container_swap::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerTTF::propagate_on_container_swap::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerTTT::propagate_on_container_swap::value ));
//is_always_equal
//0 inner
BOOST_STATIC_ASSERT(( !Scoped0InnerF::is_always_equal::value ));
BOOST_STATIC_ASSERT(( Scoped0InnerT::is_always_equal::value ));
//1 inner
BOOST_STATIC_ASSERT(( !Scoped1InnerFF::is_always_equal::value ));
BOOST_STATIC_ASSERT(( !Scoped1InnerFT::is_always_equal::value ));
BOOST_STATIC_ASSERT(( !Scoped1InnerTF::is_always_equal::value ));
BOOST_STATIC_ASSERT(( Scoped1InnerTT::is_always_equal::value ));
//2 inner
BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::is_always_equal::value ));
BOOST_STATIC_ASSERT(( !Scoped2InnerFFT::is_always_equal::value ));
BOOST_STATIC_ASSERT(( !Scoped2InnerFTF::is_always_equal::value ));
BOOST_STATIC_ASSERT(( !Scoped2InnerFTT::is_always_equal::value ));
BOOST_STATIC_ASSERT(( !Scoped2InnerTFF::is_always_equal::value ));
BOOST_STATIC_ASSERT(( !Scoped2InnerTFT::is_always_equal::value ));
BOOST_STATIC_ASSERT(( !Scoped2InnerTTF::is_always_equal::value ));
BOOST_STATIC_ASSERT(( Scoped2InnerTTT::is_always_equal::value ));
}
//Default constructor
{
Scoped0Inner s0i;
Scoped1Inner s1i;
//Swap
{
Scoped0Inner s0i2;
Scoped1Inner s1i2;
boost::adl_move_swap(s0i, s0i2);
boost::adl_move_swap(s1i, s1i2);
}
}
//Default constructor
{
Scoped0Inner s0i;
Scoped1Inner s1i;
}
//Copy constructor/assignment
{
Scoped0Inner s0i;
Scoped1Inner s1i;
Scoped2Inner s2i;
Scoped0Inner s0i_b(s0i);
Scoped1Inner s1i_b(s1i);
Scoped2Inner s2i_b(s2i);
BOOST_TEST(s0i == s0i_b);
BOOST_TEST(s1i == s1i_b);
BOOST_TEST(s2i == s2i_b);
s0i_b = s0i;
s1i_b = s1i;
s2i_b = s2i;
BOOST_TEST(s0i == s0i_b);
BOOST_TEST(s1i == s1i_b);
BOOST_TEST(s2i == s2i_b);
}
//Copy/move constructor/assignment
{
Scoped0Inner s0i;
Scoped1Inner s1i;
Scoped2Inner s2i;
Scoped0Inner s0i_b(::boost::move(s0i));
Scoped1Inner s1i_b(::boost::move(s1i));
Scoped2Inner s2i_b(::boost::move(s2i));
BOOST_TEST(s0i_b.outer_allocator().m_move_contructed);
BOOST_TEST(s1i_b.outer_allocator().m_move_contructed);
BOOST_TEST(s2i_b.outer_allocator().m_move_contructed);
s0i_b = ::boost::move(s0i);
s1i_b = ::boost::move(s1i);
s2i_b = ::boost::move(s2i);
BOOST_TEST(s0i_b.outer_allocator().m_move_assigned);
BOOST_TEST(s1i_b.outer_allocator().m_move_assigned);
BOOST_TEST(s2i_b.outer_allocator().m_move_assigned);
}
//inner_allocator()
{
Scoped0Inner s0i;
Scoped1Inner s1i;
Scoped2Inner s2i;
const Scoped0Inner const_s0i;
const Scoped1Inner const_s1i;
const Scoped2Inner const_s2i;
Scoped0Inner::inner_allocator_type &s0i_inner = s0i.inner_allocator();
(void)s0i_inner;
const Scoped0Inner::inner_allocator_type &const_s0i_inner = const_s0i.inner_allocator();
(void)const_s0i_inner;
Scoped1Inner::inner_allocator_type &s1i_inner = s1i.inner_allocator();
(void)s1i_inner;
const Scoped1Inner::inner_allocator_type &const_s1i_inner = const_s1i.inner_allocator();
(void)const_s1i_inner;
Scoped2Inner::inner_allocator_type &s2i_inner = s2i.inner_allocator();
(void)s2i_inner;
const Scoped2Inner::inner_allocator_type &const_s2i_inner = const_s2i.inner_allocator();
(void)const_s2i_inner;
}
//operator==/!=
{
const Scoped0Inner const_s0i;
const Rebound9Scoped0Inner const_rs0i;
BOOST_TEST(const_s0i == const_s0i);
BOOST_TEST(const_rs0i == const_s0i);
BOOST_TEST(const_s0i == const_s0i);
BOOST_TEST(const_s0i == const_rs0i);
const Scoped1Inner const_s1i;
const Rebound9Scoped1Inner const_rs1i;
BOOST_TEST(const_s1i == const_s1i);
BOOST_TEST(const_rs1i == const_s1i);
BOOST_TEST(const_s1i == const_s1i);
BOOST_TEST(const_s1i == const_rs1i);
const Scoped2Inner const_s2i;
const Rebound9Scoped2Inner const_rs2i;
BOOST_TEST(const_s2i == const_s2i);
BOOST_TEST(const_s2i == const_rs2i);
BOOST_TEST(const_s2i == const_s2i);
BOOST_TEST(const_s2i == const_rs2i);
}
//outer_allocator()
{
Scoped0Inner s0i;
Scoped1Inner s1i;
Scoped2Inner s2i;
const Scoped0Inner const_s0i;
const Scoped1Inner const_s1i;
const Scoped2Inner const_s2i;
Scoped0Inner::outer_allocator_type &s0i_inner = s0i.outer_allocator();
(void)s0i_inner;
const Scoped0Inner::outer_allocator_type &const_s0i_inner = const_s0i.outer_allocator();
(void)const_s0i_inner;
Scoped1Inner::outer_allocator_type &s1i_inner = s1i.outer_allocator();
(void)s1i_inner;
const Scoped1Inner::outer_allocator_type &const_s1i_inner = const_s1i.outer_allocator();
(void)const_s1i_inner;
Scoped2Inner::outer_allocator_type &s2i_inner = s2i.outer_allocator();
(void)s2i_inner;
const Scoped2Inner::outer_allocator_type &const_s2i_inner = const_s2i.outer_allocator();
(void)const_s2i_inner;
}
//max_size()
{
const Scoped0Inner const_s0i;
const Scoped1Inner const_s1i;
const Scoped2Inner const_s2i;
const OuterAlloc const_oa;
const InnerAlloc1 const_ia1;
const InnerAlloc2 const_ia2;
BOOST_TEST(const_s0i.max_size() == const_oa.max_size());
BOOST_TEST(const_s1i.max_size() == const_oa.max_size());
BOOST_TEST(const_s2i.max_size() == const_oa.max_size());
BOOST_TEST(const_s1i.inner_allocator().max_size() == const_ia1.max_size());
BOOST_TEST(const_s2i.inner_allocator().inner_allocator().max_size() == const_ia2.max_size());
}
//Copy and move operations
{
//Construction
{
Scoped0Inner s0i_a, s0i_b(s0i_a), s0i_c(::boost::move(s0i_b));
Scoped1Inner s1i_a, s1i_b(s1i_a), s1i_c(::boost::move(s1i_b));
Scoped2Inner s2i_a, s2i_b(s2i_a), s2i_c(::boost::move(s2i_b));
}
//Assignment
{
Scoped0Inner s0i_a, s0i_b;
s0i_a = s0i_b;
s0i_a = ::boost::move(s0i_b);
Scoped1Inner s1i_a, s1i_b;
s1i_a = s1i_b;
s1i_a = ::boost::move(s1i_b);
Scoped2Inner s2i_a, s2i_b;
s2i_a = s2i_b;
s2i_a = ::boost::move(s2i_b);
}
OuterAlloc oa;
InnerAlloc1 ia1;
InnerAlloc2 ia2;
Rebound9OuterAlloc roa;
Rebound9Scoped0Inner rs0i;
Rebound9Scoped1Inner rs1i;
Rebound9Scoped2Inner rs2i;
//Copy from outer
{
Scoped0Inner s0i(oa);
Scoped1Inner s1i(oa, ia1);
Scoped2Inner s2i(oa, ia1, ia2);
}
//Move from outer
{
Scoped0Inner s0i(::boost::move(oa));
Scoped1Inner s1i(::boost::move(oa), ia1);
Scoped2Inner s2i(::boost::move(oa), ia1, ia2);
}
//Copy from rebound outer
{
Scoped0Inner s0i(roa);
Scoped1Inner s1i(roa, ia1);
Scoped2Inner s2i(roa, ia1, ia2);
}
//Move from rebound outer
{
Scoped0Inner s0i(::boost::move(roa));
Scoped1Inner s1i(::boost::move(roa), ia1);
Scoped2Inner s2i(::boost::move(roa), ia1, ia2);
}
//Copy from rebound scoped
{
Scoped0Inner s0i(rs0i);
Scoped1Inner s1i(rs1i);
Scoped2Inner s2i(rs2i);
}
//Move from rebound scoped
{
Scoped0Inner s0i(::boost::move(rs0i));
Scoped1Inner s1i(::boost::move(rs1i));
Scoped2Inner s2i(::boost::move(rs2i));
}
}
{
vector<int, scoped_allocator_adaptor< propagation_test_allocator<int, 0> > > dummy;
dummy.push_back(0);
}
//destroy()
{
{
Scoped0Inner s0i;
mark_on_destructor mod;
s0i.destroy(&mod);
BOOST_TEST(mark_on_destructor::destroyed);
}
{
Scoped1Inner s1i;
mark_on_destructor mod;
s1i.destroy(&mod);
BOOST_TEST(mark_on_destructor::destroyed);
}
{
Scoped2Inner s2i;
mark_on_destructor mod;
s2i.destroy(&mod);
BOOST_TEST(mark_on_destructor::destroyed);
}
}
//construct
{
////////////////////////////////////////////////////////////
//First check scoped allocator with just OuterAlloc.
//In this case OuterAlloc (propagation_test_allocator with tag 0) should be
//used to construct types.
////////////////////////////////////////////////////////////
{
Scoped0Inner s0i;
//Check construction with 0 user arguments
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
MarkType dummy;
dummy.~MarkType();
s0i.construct(&dummy);
BOOST_TEST(dummy.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.value == 0 );
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
MarkType dummy;
dummy.~MarkType();
s0i.construct(&dummy);
BOOST_TEST(dummy.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.value == 0);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
MarkType dummy;
dummy.~MarkType();
s0i.construct(&dummy);
BOOST_TEST(dummy.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.value == 0);
dummy.~MarkType();
}
//Check construction with 1 user arguments
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
MarkType dummy;
dummy.~MarkType();
s0i.construct(&dummy, 1);
BOOST_TEST(dummy.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.value == 1);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
MarkType dummy;
dummy.~MarkType();
s0i.construct(&dummy, 2);
BOOST_TEST(dummy.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.value == 2);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
MarkType dummy;
dummy.~MarkType();
s0i.construct(&dummy, 3);
BOOST_TEST(dummy.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.value == 3);
dummy.~MarkType();
}
}
////////////////////////////////////////////////////////////
//Then check scoped allocator with OuterAlloc and InnerAlloc.
//In this case InnerAlloc (propagation_test_allocator with tag 1) should be
//used to construct types.
////////////////////////////////////////////////////////////
{
Scoped1Inner s1i;
//Check construction with 0 user arguments
{
typedef ::allocator_argument_tester<NotUsesAllocator, 1> MarkType;
MarkType dummy;
dummy.~MarkType();
s1i.construct(&dummy);
BOOST_TEST(dummy.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.value == 0);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 1> MarkType;
MarkType dummy;
dummy.~MarkType();
s1i.construct(&dummy);
BOOST_TEST(dummy.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.value == 0);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 1> MarkType;
MarkType dummy;
dummy.~MarkType();
s1i.construct(&dummy);
BOOST_TEST(dummy.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.value == 0);
dummy.~MarkType();
}
//Check construction with 1 user arguments
{
typedef ::allocator_argument_tester<NotUsesAllocator, 1> MarkType;
MarkType dummy;
dummy.~MarkType();
s1i.construct(&dummy, 1);
BOOST_TEST(dummy.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.value == 1);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 1> MarkType;
MarkType dummy;
dummy.~MarkType();
s1i.construct(&dummy, 2);
BOOST_TEST(dummy.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.value == 2);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 1> MarkType;
MarkType dummy;
dummy.~MarkType();
s1i.construct(&dummy, 3);
BOOST_TEST(dummy.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.value == 3);
dummy.~MarkType();
}
}
//////////////////////////////////////////////////////////////////////////////////
//Now test recursive OuterAllocator types (OuterAllocator is a scoped_allocator)
//////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
//First check scoped allocator with just OuterAlloc.
//In this case OuterAlloc (propagation_test_allocator with tag 0) should be
//used to construct types.
////////////////////////////////////////////////////////////
{
//Check outer_allocator_type is scoped
BOOST_STATIC_ASSERT(( is_scoped_allocator
<ScopedScoped0Inner::outer_allocator_type>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same
< outermost_allocator<ScopedScoped0Inner>::type
, Outer10IdAlloc
>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same
< ScopedScoped0Inner::outer_allocator_type
, scoped_allocator_adaptor<Outer10IdAlloc>
>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same
< scoped_allocator_adaptor<Outer10IdAlloc>::outer_allocator_type
, Outer10IdAlloc
>::value ));
ScopedScoped0Inner ssro0i;
Outer10IdAlloc & val = outermost_allocator<ScopedScoped0Inner>::get(ssro0i);
(void)val;
//Check construction with 0 user arguments
{
typedef ::allocator_argument_tester<NotUsesAllocator, 10> MarkType;
MarkType dummy;
dummy.~MarkType();
ssro0i.construct(&dummy);
BOOST_TEST(dummy.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.value == 0);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 10> MarkType;
MarkType dummy;
dummy.~MarkType();
ssro0i.construct(&dummy);
BOOST_TEST(dummy.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.value == 0);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 10> MarkType;
MarkType dummy;
dummy.~MarkType();
ssro0i.construct(&dummy);
BOOST_TEST(dummy.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.value == 0);
dummy.~MarkType();
}
//Check construction with 1 user arguments
{
typedef ::allocator_argument_tester<NotUsesAllocator, 10> MarkType;
MarkType dummy;
dummy.~MarkType();
ssro0i.construct(&dummy, 1);
BOOST_TEST(dummy.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.value == 1);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 10> MarkType;
MarkType dummy;
dummy.~MarkType();
ssro0i.construct(&dummy, 2);
BOOST_TEST(dummy.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.value == 2);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 10> MarkType;
MarkType dummy;
dummy.~MarkType();
ssro0i.construct(&dummy, 3);
BOOST_TEST(dummy.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.value == 3);
dummy.~MarkType();
}
}
////////////////////////////////////////////////////////////
//Then check scoped allocator with OuterAlloc and InnerAlloc.
//In this case inner_allocator_type is not convertible to
//::allocator_argument_tester<XXX, 10> so uses_allocator
//should be false on all tests.
////////////////////////////////////////////////////////////
{
//Check outer_allocator_type is scoped
BOOST_STATIC_ASSERT(( is_scoped_allocator
<ScopedScoped1Inner::outer_allocator_type>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same
< outermost_allocator<ScopedScoped1Inner>::type
, Outer10IdAlloc
>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same
< ScopedScoped1Inner::outer_allocator_type
, scoped_allocator_adaptor<Outer10IdAlloc, Inner11IdAlloc1>
>::value ));
BOOST_STATIC_ASSERT(( dtl::is_same
< scoped_allocator_adaptor<Outer10IdAlloc, Inner11IdAlloc1>::outer_allocator_type
, Outer10IdAlloc
>::value ));
BOOST_STATIC_ASSERT(( !
uses_allocator
< ::allocator_argument_tester<ConstructibleSuffix, 10>
, ScopedScoped1Inner::inner_allocator_type::outer_allocator_type
>::value ));
ScopedScoped1Inner ssro1i;
Outer10IdAlloc & val = outermost_allocator<ScopedScoped1Inner>::get(ssro1i);
(void)val;
//Check construction with 0 user arguments
{
typedef ::allocator_argument_tester<NotUsesAllocator, 10> MarkType;
MarkType dummy;
dummy.~MarkType();
ssro1i.construct(&dummy);
BOOST_TEST(dummy.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.value == 0);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 10> MarkType;
MarkType dummy;
dummy.~MarkType();
ssro1i.construct(&dummy);
BOOST_TEST(dummy.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.value == 0);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 10> MarkType;
MarkType dummy;
dummy.~MarkType();
ssro1i.construct(&dummy);
BOOST_TEST(dummy.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.value == 0);
dummy.~MarkType();
}
//Check construction with 1 user arguments
{
typedef ::allocator_argument_tester<NotUsesAllocator, 10> MarkType;
MarkType dummy;
dummy.~MarkType();
ssro1i.construct(&dummy, 1);
BOOST_TEST(dummy.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.value == 1);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 10> MarkType;
MarkType dummy;
dummy.~MarkType();
ssro1i.construct(&dummy, 2);
BOOST_TEST(dummy.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.value == 2);
dummy.~MarkType();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 10> MarkType;
MarkType dummy;
dummy.~MarkType();
ssro1i.construct(&dummy, 3);
BOOST_TEST(dummy.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.value == 3);
dummy.~MarkType();
}
}
////////////////////////////////////////////////////////////
//Now check propagation to pair
////////////////////////////////////////////////////////////
//First check scoped allocator with just OuterAlloc.
//In this case OuterAlloc (propagation_test_allocator with tag 0) should be
//used to construct types.
////////////////////////////////////////////////////////////
{
using dtl::pair;
typedef propagation_test_allocator< pair< tagged_integer<0>
, tagged_integer<0> >, 0> OuterPairAlloc;
//
typedef scoped_allocator_adaptor < OuterPairAlloc > ScopedPair0Inner;
ScopedPair0Inner s0i;
//Check construction with 0 user arguments
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy);
BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy);
BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy);
BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
#if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE)
//Check construction with 0 user arguments and Std tuple
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>());
BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>());
BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>());
BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>());
BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>());
BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>());
BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
#endif //BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE
//Check construction with 1 user arguments for each pair
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, 1, 1);
BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.first.value == 1);
BOOST_TEST(dummy.second.value == 1);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, 1, 1);
BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.first.value == 1);
BOOST_TEST(dummy.second.value == 1);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, 2, 2);
BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.first.value == 2);
BOOST_TEST(dummy.second.value == 2);
dummy.~MarkTypePair();
}
//Check construction with 1 user arguments for each pair and Boost tuple
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, boost::tuple<int>(1), boost::tuple<int>(1));
BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.first.value == 1);
BOOST_TEST(dummy.second.value == 1);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, boost::tuple<int>(1), boost::tuple<int>(1));
BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.first.value == 1);
BOOST_TEST(dummy.second.value == 1);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, boost::tuple<int>(2), boost::tuple<int>(2));
BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.first.value == 2);
BOOST_TEST(dummy.second.value == 2);
dummy.~MarkTypePair();
}
#if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE)
//Check construction with 1 user arguments for each pair and Boost tuple
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, std::tuple<int>(1), std::tuple<int>(1));
BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.first.value == 1);
BOOST_TEST(dummy.second.value == 1);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, std::tuple<int>(1), std::tuple<int>(1));
BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.first.value == 1);
BOOST_TEST(dummy.second.value == 1);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, std::tuple<int>(2), std::tuple<int>(2));
BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.first.value == 2);
BOOST_TEST(dummy.second.value == 2);
dummy.~MarkTypePair();
}
#endif //BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE
//Check construction with pair copy construction
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy, dummy2;
dummy.~MarkTypePair();
s0i.construct(&dummy, dummy2);
BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy, dummy2(1, 1);
dummy.~MarkTypePair();
s0i.construct(&dummy, dummy2);
BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.first.value == 1);
BOOST_TEST(dummy.second.value == 1);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy, dummy2(2, 2);
dummy.~MarkTypePair();
s0i.construct(&dummy, dummy2);
BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.first.value == 2);
BOOST_TEST(dummy.second.value == 2);
dummy.~MarkTypePair();
}
//Check construction with pair move construction
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy, dummy2(3, 3);
dummy2.first.construction_type = dummy2.second.construction_type = ConstructibleSuffix;
dummy.~MarkTypePair();
s0i.construct(&dummy, ::boost::move(dummy2));
BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.first.value == 3);
BOOST_TEST(dummy.second.value == 3);
BOOST_TEST(dummy2.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy2.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy2.first.value == 0);
BOOST_TEST(dummy2.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy, dummy2(1, 1);
dummy.~MarkTypePair();
s0i.construct(&dummy, ::boost::move(dummy2));
BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.first.value == 1);
BOOST_TEST(dummy.second.value == 1);
BOOST_TEST(dummy2.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy2.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy2.first.value == 0);
BOOST_TEST(dummy2.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy, dummy2(2, 2);
dummy.~MarkTypePair();
s0i.construct(&dummy, ::boost::move(dummy2));
BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.first.value == 2);
BOOST_TEST(dummy.second.value == 2);
BOOST_TEST(dummy2.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy2.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy2.first.value == 0);
BOOST_TEST(dummy2.second.value == 0);
dummy.~MarkTypePair();
}
//Check construction with related pair copy construction
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
pair<int, int> dummy2;
dummy.~MarkTypePair();
s0i.construct(&dummy, dummy2);
BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
pair<int, int> dummy2(1, 1);
dummy.~MarkTypePair();
s0i.construct(&dummy, dummy2);
BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.first.value == 1);
BOOST_TEST(dummy.second.value == 1);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
pair<int, int> dummy2(2, 2);
dummy.~MarkTypePair();
s0i.construct(&dummy, dummy2);
BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.first.value == 2);
BOOST_TEST(dummy.second.value == 2);
dummy.~MarkTypePair();
}
//Check construction with related pair move construction
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
pair<int, int> dummy2(3, 3);
dummy.~MarkTypePair();
s0i.construct(&dummy, ::boost::move(dummy2));
BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.first.value == 3);
BOOST_TEST(dummy.second.value == 3);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
pair<int, int> dummy2(1, 1);
dummy.~MarkTypePair();
s0i.construct(&dummy, ::boost::move(dummy2));
BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.first.value == 1);
BOOST_TEST(dummy.second.value == 1);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
pair<int, int> dummy2(2, 2);
dummy.~MarkTypePair();
s0i.construct(&dummy, ::boost::move(dummy2));
BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.first.value == 2);
BOOST_TEST(dummy.second.value == 2);
dummy.~MarkTypePair();
}
//Check construction with 0/1 arguments for each pair and Boost tuple
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, boost::tuple<>(), boost::tuple<int>(1));
BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 1);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, boost::tuple<int>(1), boost::tuple<>());
BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.first.value == 1);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, boost::tuple<>(), boost::tuple<int>(2));
BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 2);
dummy.~MarkTypePair();
}
#if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE)
//Check construction with 0/1 arguments for each pair and Boost tuple
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<int>(1));
BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 1);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, std::tuple<int>(1), std::tuple<>());
BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.first.value == 1);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<int>(2));
BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.first.value == 0);
BOOST_TEST(dummy.second.value == 2);
dummy.~MarkTypePair();
}
#endif //BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE
//Check construction with try_emplace_t 0/1 arguments for each pair
{
typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, try_emplace_t(), 5, 1);
BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
BOOST_TEST(dummy.first.value == 5);
BOOST_TEST(dummy.second.value == 1);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, try_emplace_t(), 6);
BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
BOOST_TEST(dummy.first.value == 6);
BOOST_TEST(dummy.second.value == 0);
dummy.~MarkTypePair();
}
{
typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
typedef pair<MarkType, MarkType> MarkTypePair;
MarkTypePair dummy;
dummy.~MarkTypePair();
s0i.construct(&dummy, try_emplace_t(), 7, 2);
BOOST_TEST(dummy.first.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
BOOST_TEST(dummy.first.value == 7);
BOOST_TEST(dummy.second.value == 2);
dummy.~MarkTypePair();
}
}
}
return ::boost::report_errors();
}
#include <boost/container/detail/config_end.hpp>