container/test/map_test.hpp

1265 lines
44 KiB
C++

////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2006. 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_MAP_TEST_HEADER
#define BOOST_CONTAINER_TEST_MAP_TEST_HEADER
#include <boost/container/detail/config_begin.hpp>
#include "check_equal_containers.hpp"
#include "print_container.hpp"
#include "movable_int.hpp"
#include <boost/container/detail/pair.hpp>
#include <boost/move/iterator.hpp>
#include <boost/move/utility_core.hpp>
#include <boost/move/make_unique.hpp>
#include <boost/intrusive/detail/minimal_pair_header.hpp> //pair
#include <string>
#include <iostream>
#include <boost/intrusive/detail/mpl.hpp>
namespace boost { namespace container { namespace test {
BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED(has_member_rebalance, rebalance)
}}}
const int MaxElem = 50;
template<class T1, class T2, class T3, class T4>
bool operator ==(std::pair<T1, T2> &p1, std::pair<T1, T2> &p2)
{
return p1.first == p2.first && p1.second == p2.second;
}
namespace boost{
namespace container {
namespace test{
template<class C>
void map_test_rebalanceable(C &, boost::container::dtl::false_type)
{}
template<class C>
void map_test_rebalanceable(C &c, boost::container::dtl::true_type)
{
c.rebalance();
}
template<class MyBoostMap
,class MyStdMap
,class MyBoostMultiMap
,class MyStdMultiMap>
int map_test_copyable(boost::container::dtl::false_type)
{ return 0; }
template<class MyBoostMap
,class MyStdMap
,class MyBoostMultiMap
,class MyStdMultiMap>
int map_test_copyable(boost::container::dtl::true_type)
{
typedef typename MyBoostMap::key_type IntType;
typedef dtl::pair<IntType, IntType> IntPairType;
typedef typename MyStdMap::value_type StdPairType;
::boost::movelib::unique_ptr<MyBoostMap> const pboostmap = ::boost::movelib::make_unique<MyBoostMap>();
::boost::movelib::unique_ptr<MyStdMap> const pstdmap = ::boost::movelib::make_unique<MyStdMap>();
::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap = ::boost::movelib::make_unique<MyBoostMultiMap>();
::boost::movelib::unique_ptr<MyStdMultiMap> const pstdmultimap = ::boost::movelib::make_unique<MyStdMultiMap>();
MyBoostMap &boostmap = *pboostmap;
MyStdMap &stdmap = *pstdmap;
MyBoostMultiMap &boostmultimap = *pboostmultimap;
MyStdMultiMap &stdmultimap = *pstdmultimap;
//Just to test move aware catch conversions
boostmap.insert(boostmap.cbegin(), boostmap.cend());
boostmultimap.insert(boostmultimap.cbegin(), boostmultimap.cend());
boostmap.insert(boostmap.begin(), boostmap.end());
boostmultimap.insert(boostmultimap.begin(), boostmultimap.end());
int i;
for(i = 0; i < MaxElem; ++i){
{
IntType i1(i), i2(i);
IntPairType intpair1(boost::move(i1), boost::move(i2));
boostmap.insert(boost::move(intpair1));
stdmap.insert(StdPairType(i, i));
}
{
IntType i1(i), i2(i);
IntPairType intpair2(boost::move(i1), boost::move(i2));
boostmultimap.insert(boost::move(intpair2));
stdmultimap.insert(StdPairType(i, i));
}
}
if(!CheckEqualContainers(boostmap, stdmap)) return 1;
if(!CheckEqualContainers(boostmultimap, stdmultimap)) return 1;
{
//Now, test copy constructor
MyBoostMap boostmapcopy(boostmap);
MyStdMap stdmapcopy(stdmap);
MyBoostMultiMap boostmmapcopy(boostmultimap);
MyStdMultiMap stdmmapcopy(stdmultimap);
if(!CheckEqualContainers(boostmapcopy, stdmapcopy))
return 1;
if(!CheckEqualContainers(boostmmapcopy, stdmmapcopy))
return 1;
//And now assignment
boostmapcopy = boostmap;
stdmapcopy = stdmap;
boostmmapcopy = boostmultimap;
stdmmapcopy = stdmultimap;
if(!CheckEqualContainers(boostmapcopy, stdmapcopy))
return 1;
if(!CheckEqualContainers(boostmmapcopy, stdmmapcopy))
return 1;
}
return 0;
}
template<class MyBoostMap
,class MyStdMap
,class MyBoostMultiMap
,class MyStdMultiMap>
int map_test_range()
{
typedef typename MyBoostMap::key_type IntType;
typedef dtl::pair<IntType, IntType> IntPairType;
typedef typename MyStdMap::value_type StdValueType;
typedef typename MyStdMap::key_type StdKeyType;
typedef typename MyStdMap::mapped_type StdMappedType;
//Test construction from a range
{
IntPairType aux_vect[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i/2);
IntType i2(i/2);
new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
}
StdValueType aux_vect2[MaxElem];
for(int i = 0; i < MaxElem; ++i){
new(&aux_vect2[i])StdValueType(StdKeyType(i/2), StdMappedType(i/2));
}
IntPairType aux_vect3[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i/2);
IntType i2(i/2);
new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
}
::boost::movelib::unique_ptr<MyBoostMap> const pboostmap = ::boost::movelib::make_unique<MyBoostMap>
( boost::make_move_iterator(&aux_vect[0])
, boost::make_move_iterator(&aux_vect[0] + MaxElem), typename MyBoostMap::key_compare());
::boost::movelib::unique_ptr<MyStdMap> const pstdmap = ::boost::movelib::make_unique<MyStdMap>
(&aux_vect2[0], &aux_vect2[0] + MaxElem, typename MyStdMap::key_compare());
if(!CheckEqualContainers(*pboostmap, *pstdmap)) return 1;
::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap = ::boost::movelib::make_unique<MyBoostMultiMap>
( boost::make_move_iterator(&aux_vect3[0])
, boost::make_move_iterator(&aux_vect3[0] + MaxElem), typename MyBoostMap::key_compare());
::boost::movelib::unique_ptr<MyStdMultiMap> const pstdmultimap = ::boost::movelib::make_unique<MyStdMultiMap>
(&aux_vect2[0], &aux_vect2[0] + MaxElem, typename MyStdMap::key_compare());
if(!CheckEqualContainers(*pboostmultimap, *pstdmultimap)) return 1;
}
{
IntPairType aux_vect[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i/2);
IntType i2(i/2);
new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
}
StdValueType aux_vect2[MaxElem];
for(int i = 0; i < MaxElem; ++i){
new(&aux_vect2[i])StdValueType(StdKeyType(i/2), StdMappedType(i/2));
}
IntPairType aux_vect3[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i/2);
IntType i2(i/2);
new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
}
::boost::movelib::unique_ptr<MyBoostMap> const pboostmap = ::boost::movelib::make_unique<MyBoostMap>
( boost::make_move_iterator(&aux_vect[0])
, boost::make_move_iterator(&aux_vect[0] + MaxElem), typename MyBoostMap::allocator_type());
::boost::movelib::unique_ptr<MyStdMap> const pstdmap = ::boost::movelib::make_unique<MyStdMap>
(&aux_vect2[0], &aux_vect2[0] + MaxElem, typename MyStdMap::key_compare());
if(!CheckEqualContainers(*pboostmap, *pstdmap)) return 1;
::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap = ::boost::movelib::make_unique<MyBoostMultiMap>
( boost::make_move_iterator(&aux_vect3[0])
, boost::make_move_iterator(&aux_vect3[0] + MaxElem), typename MyBoostMap::allocator_type());
::boost::movelib::unique_ptr<MyStdMultiMap> const pstdmultimap = ::boost::movelib::make_unique<MyStdMultiMap>
(&aux_vect2[0], &aux_vect2[0] + MaxElem, typename MyStdMap::key_compare());
if(!CheckEqualContainers(*pboostmultimap, *pstdmultimap)) return 1;
}
return 0;
}
template<class MyBoostMap
,class MyStdMap
,class MyBoostMultiMap
,class MyStdMultiMap>
int map_test_step(MyBoostMap &, MyStdMap &, MyBoostMultiMap &, MyStdMultiMap &)
{
typedef typename MyBoostMap::key_type IntType;
typedef dtl::pair<IntType, IntType> IntPairType;
{
//This is really nasty, but we have no other simple choice
IntPairType aux_vect[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i/2);
IntType i2(i/2);
new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
}
typedef typename MyStdMap::value_type StdValueType;
typedef typename MyStdMap::key_type StdKeyType;
typedef typename MyStdMap::mapped_type StdMappedType;
StdValueType aux_vect2[MaxElem];
for(int i = 0; i < MaxElem; ++i){
new(&aux_vect2[i])StdValueType(StdKeyType(i/2), StdMappedType(i/2));
}
IntPairType aux_vect3[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i/2);
IntType i2(i/2);
new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
}
::boost::movelib::unique_ptr<MyBoostMap> const pboostmap2 = ::boost::movelib::make_unique<MyBoostMap>
( boost::make_move_iterator(&aux_vect[0])
, boost::make_move_iterator(&aux_vect[0] + MaxElem));
::boost::movelib::unique_ptr<MyStdMap> const pstdmap2 = ::boost::movelib::make_unique<MyStdMap>
(&aux_vect2[0], &aux_vect2[0] + MaxElem);
::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap2 = ::boost::movelib::make_unique<MyBoostMultiMap>
( boost::make_move_iterator(&aux_vect3[0])
, boost::make_move_iterator(&aux_vect3[0] + MaxElem));
::boost::movelib::unique_ptr<MyStdMultiMap> const pstdmultimap2 = ::boost::movelib::make_unique<MyStdMultiMap>
(&aux_vect2[0], &aux_vect2[0] + MaxElem);
MyBoostMap &boostmap2 = *pboostmap2;
MyStdMap &stdmap2 = *pstdmap2;
MyBoostMultiMap &boostmultimap2 = *pboostmultimap2;
MyStdMultiMap &stdmultimap2 = *pstdmultimap2;
if(!CheckEqualContainers(boostmap2, stdmap2)) return 1;
if(!CheckEqualContainers(boostmultimap2, stdmultimap2)) return 1;
//ordered range insertion
//This is really nasty, but we have no other simple choice
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(i);
new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
}
for(int i = 0; i < MaxElem; ++i){
new(&aux_vect2[i])StdValueType(StdKeyType(i), StdMappedType(i));
}
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(i);
new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
}
if(!CheckEqualContainers(boostmap2, stdmap2)) return 1;
if(!CheckEqualContainers(boostmultimap2, stdmultimap2)) return 1;
//some comparison operators
if(!(boostmap2 == boostmap2))
return 1;
if(boostmap2 != boostmap2)
return 1;
if(boostmap2 < boostmap2)
return 1;
if(boostmap2 > boostmap2)
return 1;
if(!(boostmap2 <= boostmap2))
return 1;
if(!(boostmap2 >= boostmap2))
return 1;
::boost::movelib::unique_ptr<MyBoostMap> const pboostmap3 = ::boost::movelib::make_unique<MyBoostMap>
( boost::make_move_iterator(&aux_vect[0])
, boost::make_move_iterator(&aux_vect[0] + MaxElem));
::boost::movelib::unique_ptr<MyStdMap> const pstdmap3 = ::boost::movelib::make_unique<MyStdMap>
(&aux_vect2[0], &aux_vect2[0] + MaxElem);
::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap3 = ::boost::movelib::make_unique<MyBoostMultiMap>
( boost::make_move_iterator(&aux_vect3[0])
, boost::make_move_iterator(&aux_vect3[0] + MaxElem));
::boost::movelib::unique_ptr<MyStdMultiMap> const pstdmultimap3 = ::boost::movelib::make_unique<MyStdMultiMap>
(&aux_vect2[0], &aux_vect2[0] + MaxElem);
MyBoostMap &boostmap3 = *pboostmap3;
MyStdMap &stdmap3 = *pstdmap3;
MyBoostMultiMap &boostmultimap3 = *pboostmultimap3;
MyStdMultiMap &stdmultimap3 = *pstdmultimap3;
if(!CheckEqualContainers(boostmap3, stdmap3)){
std::cout << "Error in construct<MyBoostMap>(MyBoostMap3)" << std::endl;
return 1;
}
if(!CheckEqualContainers(boostmultimap3, stdmultimap3)){
std::cout << "Error in construct<MyBoostMultiMap>(MyBoostMultiMap3)" << std::endl;
return 1;
}
{
IntType i0(0);
boostmap2.erase(i0);
boostmultimap2.erase(i0);
stdmap2.erase(0);
stdmultimap2.erase(0);
}
{
IntType i0(0);
IntType i1(1);
boostmap2[::boost::move(i0)] = ::boost::move(i1);
}
{
IntType i1(1);
boostmap2[IntType(0)] = ::boost::move(i1);
}
stdmap2[0] = 1;
if(!CheckEqualContainers(boostmap2, stdmap2)) return 1;
}
return 0;
}
template<class MyBoostMap
, class MyStdMap
, class MyBoostMultiMap
, class MyStdMultiMap>
int map_test_insert(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
{
typedef typename MyBoostMap::key_type IntType;
typedef dtl::pair<IntType, IntType> IntPairType;
typedef typename MyStdMap::value_type StdPairType;
{
//This is really nasty, but we have no other simple choice
IntPairType aux_vect[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(i);
new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
}
IntPairType aux_vect3[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(i);
new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
}
for(int i = 0; i < MaxElem; ++i){
boostmap.insert(boost::move(aux_vect[i]));
stdmap.insert(StdPairType(i, i));
boostmultimap.insert(boost::move(aux_vect3[i]));
stdmultimap.insert(StdPairType(i, i));
}
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
typename MyBoostMap::iterator it = boostmap.begin();
typename MyBoostMap::const_iterator cit = it;
(void)cit;
boostmap.erase(boostmap.begin());
stdmap.erase(stdmap.begin());
boostmultimap.erase(boostmultimap.begin());
stdmultimap.erase(stdmultimap.begin());
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
boostmap.erase(boostmap.begin());
stdmap.erase(stdmap.begin());
boostmultimap.erase(boostmultimap.begin());
stdmultimap.erase(stdmultimap.begin());
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
//Swapping test
MyBoostMap tmpboostemap2;
MyStdMap tmpstdmap2;
MyBoostMultiMap tmpboostemultimap2;
MyStdMultiMap tmpstdmultimap2;
boostmap.swap(tmpboostemap2);
stdmap.swap(tmpstdmap2);
boostmultimap.swap(tmpboostemultimap2);
stdmultimap.swap(tmpstdmultimap2);
boostmap.swap(tmpboostemap2);
stdmap.swap(tmpstdmap2);
boostmultimap.swap(tmpboostemultimap2);
stdmultimap.swap(tmpstdmultimap2);
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
}
return 0;
}
template<class MyBoostMap
, class MyStdMap
, class MyBoostMultiMap
, class MyStdMultiMap>
int map_test_erase(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
{
typedef typename MyBoostMap::key_type IntType;
typedef dtl::pair<IntType, IntType> IntPairType;
typedef typename MyStdMap::value_type StdPairType;
//Insertion from other container
//Initialize values
{
//This is really nasty, but we have no other simple choice
IntPairType aux_vect[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(-1);
IntType i2(-1);
new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
}
IntPairType aux_vect3[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(-1);
IntType i2(-1);
new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
}
boostmap.insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0] + MaxElem));
boostmultimap.insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0] + MaxElem));
for(int i = 0; i != MaxElem; ++i){
StdPairType stdpairtype(-1, -1);
stdmap.insert(stdpairtype);
stdmultimap.insert(stdpairtype);
}
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
for(int i = 0, j = static_cast<int>(boostmap.size()); i < j; ++i){
IntType k(i);
boostmap.erase(k);
stdmap.erase(i);
boostmultimap.erase(k);
stdmultimap.erase(i);
}
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
}
{
IntPairType aux_vect[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(-1);
IntType i2(-1);
new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
}
IntPairType aux_vect3[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(-1);
IntType i2(-1);
new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
}
IntPairType aux_vect4[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(-1);
IntType i2(-1);
new(&aux_vect4[i])IntPairType(boost::move(i1), boost::move(i2));
}
IntPairType aux_vect5[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(-1);
IntType i2(-1);
new(&aux_vect5[i])IntPairType(boost::move(i1), boost::move(i2));
}
boostmap.insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0] + MaxElem));
boostmap.insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0] + MaxElem));
boostmultimap.insert(boost::make_move_iterator(&aux_vect4[0]), boost::make_move_iterator(aux_vect4 + MaxElem));
boostmultimap.insert(boost::make_move_iterator(&aux_vect5[0]), boost::make_move_iterator(aux_vect5 + MaxElem));
for(int i = 0; i != MaxElem; ++i){
StdPairType stdpairtype(-1, -1);
stdmap.insert(stdpairtype);
stdmultimap.insert(stdpairtype);
stdmap.insert(stdpairtype);
stdmultimap.insert(stdpairtype);
}
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
boostmap.erase(boostmap.begin()->first);
stdmap.erase(stdmap.begin()->first);
boostmultimap.erase(boostmultimap.begin()->first);
stdmultimap.erase(stdmultimap.begin()->first);
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
}
return 0;
}
template<class MyBoostMap
, class MyStdMap
, class MyBoostMultiMap
, class MyStdMultiMap>
int map_test_insert2(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
{
typedef typename MyBoostMap::key_type IntType;
typedef dtl::pair<IntType, IntType> IntPairType;
typedef typename MyStdMap::value_type StdPairType;
//This is really nasty, but we have no other simple choice
IntPairType aux_vect[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(i);
new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
}
IntPairType aux_vect3[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(i);
new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
}
for(int i = 0; i < MaxElem; ++i){
boostmap.insert(boost::move(aux_vect[i]));
stdmap.insert(StdPairType(i, i));
boostmultimap.insert(boost::move(aux_vect3[i]));
stdmultimap.insert(StdPairType(i, i));
}
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
for(int i = 0; i < MaxElem; ++i){
IntPairType intpair;
{
IntType i1(i);
IntType i2(i);
new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
}
boostmap.insert(boostmap.begin(), boost::move(intpair));
stdmap.insert(stdmap.begin(), StdPairType(i, i));
//PrintContainers(boostmap, stdmap);
{
IntType i1(i);
IntType i2(i);
new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
}
boostmultimap.insert(boostmultimap.begin(), boost::move(intpair));
stdmultimap.insert(stdmultimap.begin(), StdPairType(i, i));
//PrintContainers(boostmultimap, stdmultimap);
if(!CheckEqualPairContainers(boostmap, stdmap))
return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
return 1;
{
IntType i1(i);
IntType i2(i);
new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
}
boostmap.insert(boostmap.end(), boost::move(intpair));
stdmap.insert(stdmap.end(), StdPairType(i, i));
{
IntType i1(i);
IntType i2(i);
new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
}
boostmultimap.insert(boostmultimap.end(), boost::move(intpair));
stdmultimap.insert(stdmultimap.end(), StdPairType(i, i));
if(!CheckEqualPairContainers(boostmap, stdmap))
return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
return 1;
{
IntType i1(i);
IntType i2(i);
new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
}
IntType k(i);
boostmap.insert(boostmap.lower_bound(k), boost::move(intpair));
stdmap.insert(stdmap.lower_bound(i), StdPairType(i, i));
//PrintContainers(boostmap, stdmap);
{
IntType i1(i);
IntType i2(i);
new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
}
{
IntType i1(i);
boostmultimap.insert(boostmultimap.lower_bound(boost::move(i1)), boost::move(intpair));
stdmultimap.insert(stdmultimap.lower_bound(i), StdPairType(i, i));
}
//PrintContainers(boostmultimap, stdmultimap);
if(!CheckEqualPairContainers(boostmap, stdmap))
return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
return 1;
{ //Check equal_range
std::pair<typename MyBoostMultiMap::iterator, typename MyBoostMultiMap::iterator> bret =
boostmultimap.equal_range(boostmultimap.begin()->first);
std::pair<typename MyStdMultiMap::iterator, typename MyStdMultiMap::iterator> sret =
stdmultimap.equal_range(stdmultimap.begin()->first);
if( boost::container::iterator_distance(bret.first, bret.second) !=
boost::container::iterator_distance(sret.first, sret.second) ){
return 1;
}
}
{
IntType i1(i);
boostmap.insert(boostmap.upper_bound(boost::move(i1)), boost::move(intpair));
stdmap.insert(stdmap.upper_bound(i), StdPairType(i, i));
}
//PrintContainers(boostmap, stdmap);
{
IntType i1(i);
IntType i2(i);
new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
}
{
IntType i1(i);
boostmultimap.insert(boostmultimap.upper_bound(boost::move(i1)), boost::move(intpair));
stdmultimap.insert(stdmultimap.upper_bound(i), StdPairType(i, i));
}
//PrintContainers(boostmultimap, stdmultimap);
if(!CheckEqualPairContainers(boostmap, stdmap))
return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
return 1;
map_test_rebalanceable(boostmap
, dtl::bool_<has_member_rebalance<MyBoostMap>::value>());
if(!CheckEqualContainers(boostmap, stdmap)){
std::cout << "Error in boostmap.rebalance()" << std::endl;
return 1;
}
map_test_rebalanceable(boostmultimap
, dtl::bool_<has_member_rebalance<MyBoostMap>::value>());
if(!CheckEqualContainers(boostmultimap, stdmultimap)){
std::cout << "Error in boostmultimap.rebalance()" << std::endl;
return 1;
}
}
return 0;
}
template<class MyBoostMap
, class MyStdMap
, class MyBoostMultiMap
, class MyStdMultiMap>
int map_test_search(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
{
typedef typename MyBoostMap::key_type IntType;
typedef dtl::pair<IntType, IntType> IntPairType;
//Compare count/contains with std containers
for(int i = 0; i < MaxElem; ++i){
IntType k(i);
if(boostmap.count(k) != stdmap.count(i)){
return -1;
}
if(boostmap.contains(k) != (stdmap.find(i) != stdmap.end())){
return -1;
}
if(boostmultimap.count(k) != stdmultimap.count(i)){
return -1;
}
if(boostmultimap.contains(k) != (stdmultimap.find(i) != stdmultimap.end())){
return -1;
}
}
{
//Now do count exercise
boostmap.erase(boostmap.begin(), boostmap.end());
boostmultimap.erase(boostmultimap.begin(), boostmultimap.end());
boostmap.clear();
boostmultimap.clear();
for(int j = 0; j < 3; ++j)
for(int i = 0; i < 100; ++i){
IntPairType intpair;
{
IntType i1(i), i2(i);
new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
}
boostmap.insert(boost::move(intpair));
{
IntType i1(i), i2(i);
new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
}
boostmultimap.insert(boost::move(intpair));
IntType k(i);
if(boostmap.count(k) != typename MyBoostMultiMap::size_type(1))
return 1;
if(boostmultimap.count(k) != typename MyBoostMultiMap::size_type(j+1))
return 1;
}
}
return 0;
}
template<class MyBoostMap
, class MyStdMap
, class MyBoostMultiMap
, class MyStdMultiMap>
int map_test_indexing(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
{
typedef typename MyBoostMap::key_type IntType;
typedef dtl::pair<IntType, IntType> IntPairType;
{ //operator[] test
boostmap.clear();
boostmultimap.clear();
stdmap.clear();
stdmultimap.clear();
IntPairType aux_vect[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(i);
new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
}
for(int i = 0; i < MaxElem; ++i){
boostmap[boost::move(aux_vect[i].first)] = boost::move(aux_vect[i].second);
stdmap[i] = i;
}
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
}
return 0;
}
template< class MyBoostMap, class StdMap, class MaybeMove>
int map_test_insert_or_assign_impl()
{
typedef typename MyBoostMap::key_type IntType;
typedef dtl::pair<IntType, IntType> IntPairType;
typedef typename MyBoostMap::iterator Biterator;
typedef std::pair<Biterator, bool> Bpair;
MaybeMove maybe_move;
{ //insert_or_assign test
MyBoostMap boostmap;
StdMap stdmap;
IntPairType aux_vect[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(MaxElem-i);
new(&aux_vect[i])IntPairType(maybe_move(i1), maybe_move(i2));
}
IntPairType aux_vect2[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(i);
new(&aux_vect2[i])IntPairType(maybe_move(i1), maybe_move(i2));
}
for(int i = 0; i < MaxElem; ++i){
Bpair r = boostmap.insert_or_assign(maybe_move(aux_vect[i].first), maybe_move(aux_vect[i].second));
stdmap[i] = MaxElem-i;
if(!r.second)
return 1;
const IntType key(i);
if(r.first->first != key)
return 1;
const IntType mapped(MaxElem-i);
if(r.first->second != mapped)
return 1;
}
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
for(int i = 0; i < MaxElem; ++i){
Bpair r = boostmap.insert_or_assign(maybe_move(aux_vect2[i].first), maybe_move(aux_vect2[i].second));
stdmap[i] = i;
if(r.second)
return 1;
const IntType key(i);
if(r.first->first != key)
return 1;
const IntType mapped(i);
if(r.first->second != mapped)
return 1;
}
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
}
{ //insert_or_assign test with hint
MyBoostMap boostmap;
StdMap stdmap;
IntPairType aux_vect[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(MaxElem-i);
new(&aux_vect[i])IntPairType(maybe_move(i1), maybe_move(i2));
}
IntPairType aux_vect2[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(i);
new(&aux_vect2[i])IntPairType(maybe_move(i1), maybe_move(i2));
}
for(int i = 0; i < MaxElem; ++i){
Biterator r = boostmap.insert_or_assign(boostmap.end(), maybe_move(aux_vect[i].first), maybe_move(aux_vect[i].second));
stdmap[i] = MaxElem-i;
const IntType key(i);
if(r->first != key)
return 1;
const IntType mapped(MaxElem-i);
if(r->second != mapped)
return 1;
}
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
for(int i = 0; i < MaxElem; ++i){
Biterator r = boostmap.insert_or_assign(boostmap.end(), maybe_move(aux_vect2[i].first), maybe_move(aux_vect2[i].second));
stdmap[i] = i;
const IntType key(i);
if(r->first != key)
return 1;
const IntType mapped(i);
if(r->second != mapped)
return 1;
}
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
}
return 0;
}
template< class MyBoostMap, class StdMap>
int map_test_insert_or_assign(dtl::bool_<false> )//noncopyable
{
return map_test_insert_or_assign_impl<MyBoostMap, StdMap, move_op>();
}
template< class MyBoostMap, class StdMap>
int map_test_insert_or_assign(dtl::bool_<true> )//copyable
{
int r = map_test_insert_or_assign_impl<MyBoostMap, StdMap, const_ref_op>();
if (r)
r = map_test_insert_or_assign_impl<MyBoostMap, StdMap, move_op>();
return r;
}
template< class MyBoostMap
, class MyStdMap
, class MyBoostMultiMap
, class MyStdMultiMap>
int map_test_try_emplace(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
{
typedef typename MyBoostMap::key_type IntType;
typedef dtl::pair<IntType, IntType> IntPairType;
{ //try_emplace
boostmap.clear();
boostmultimap.clear();
stdmap.clear();
stdmultimap.clear();
IntPairType aux_vect[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(i);
new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
}
IntPairType aux_vect2[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(MaxElem-i);
new(&aux_vect2[i])IntPairType(boost::move(i1), boost::move(i2));
}
typedef typename MyBoostMap::iterator iterator;
for(int i = 0; i < MaxElem; ++i){
iterator it;
if(i&1){
std::pair<typename MyBoostMap::iterator, bool> ret =
boostmap.try_emplace(boost::move(aux_vect[i].first), boost::move(aux_vect[i].second));
if(!ret.second)
return 1;
it = ret.first;
}
else{
it = boostmap.try_emplace
(boostmap.upper_bound(aux_vect[i].first), boost::move(aux_vect[i].first), boost::move(aux_vect[i].second));
}
if(boostmap.end() == it || it->first != aux_vect2[i].first || it->second != aux_vect2[i].first){
return 1;
}
stdmap[i] = i;
}
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
for(int i = 0; i < MaxElem; ++i){
iterator it;
iterator itex = boostmap.find(aux_vect2[i].first);
if(itex == boostmap.end())
return 1;
if(i&1){
std::pair<typename MyBoostMap::iterator, bool> ret =
boostmap.try_emplace(boost::move(aux_vect2[i].first), boost::move(aux_vect2[i].second));
if(ret.second)
return 1;
it = ret.first;
}
else{
it = boostmap.try_emplace
(boostmap.upper_bound(aux_vect2[i].first), boost::move(aux_vect2[i].first), boost::move(aux_vect2[i].second));
}
const IntType test_int(i);
if(boostmap.end() == it || it != itex || it->second != test_int){
return 1;
}
}
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
}
return 0;
}
template< class MyBoostMap
, class MyStdMap
, class MyBoostMultiMap
, class MyStdMultiMap>
int map_test_merge(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
{
typedef typename MyBoostMap::key_type IntType;
typedef dtl::pair<IntType, IntType> IntPairType;
typedef typename MyStdMap::value_type StdPairType;
{ //merge
::boost::movelib::unique_ptr<MyBoostMap> const pboostmap2 = ::boost::movelib::make_unique<MyBoostMap>();
::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap2 = ::boost::movelib::make_unique<MyBoostMultiMap>();
MyBoostMap &boostmap2 = *pboostmap2;
MyBoostMultiMap &boostmultimap2 = *pboostmultimap2;
boostmap.clear();
boostmap2.clear();
boostmultimap.clear();
boostmultimap2.clear();
stdmap.clear();
stdmultimap.clear();
{
IntPairType aux_vect[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(i);
new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
}
IntPairType aux_vect2[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(MaxElem/2+i);
IntType i2(MaxElem-i);
new(&aux_vect2[i])IntPairType(boost::move(i1), boost::move(i2));
}
IntPairType aux_vect3[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(MaxElem*2/2+i);
IntType i2(MaxElem*2+i);
new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
}
boostmap.insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0] + MaxElem));
boostmap2.insert(boost::make_move_iterator(&aux_vect2[0]), boost::make_move_iterator(&aux_vect2[0] + MaxElem));
boostmultimap2.insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0] + MaxElem));
}
for(int i = 0; i < MaxElem; ++i){
stdmap.insert(StdPairType(i, i));
}
for(int i = 0; i < MaxElem; ++i){
stdmap.insert(StdPairType(MaxElem/2+i, MaxElem-i));
}
boostmap.merge(boost::move(boostmap2));
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
for(int i = 0; i < MaxElem; ++i){
stdmap.insert(StdPairType(MaxElem*2/2+i, MaxElem*2+i));
}
boostmap.merge(boost::move(boostmultimap2));
if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
boostmap.clear();
boostmap2.clear();
boostmultimap.clear();
boostmultimap2.clear();
stdmap.clear();
stdmultimap.clear();
{
IntPairType aux_vect[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(i);
IntType i2(i);
new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
}
IntPairType aux_vect2[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(MaxElem/2+i);
IntType i2(MaxElem-i);
new(&aux_vect2[i])IntPairType(boost::move(i1), boost::move(i2));
}
IntPairType aux_vect3[MaxElem];
for(int i = 0; i < MaxElem; ++i){
IntType i1(MaxElem*2/2+i);
IntType i2(MaxElem*2+i);
new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
}
boostmultimap.insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0] + MaxElem));
boostmultimap2.insert(boost::make_move_iterator(&aux_vect2[0]), boost::make_move_iterator(&aux_vect2[0] + MaxElem));
boostmap2.insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0] + MaxElem));
}
for(int i = 0; i < MaxElem; ++i){
stdmultimap.insert(StdPairType(i, i));
}
for(int i = 0; i < MaxElem; ++i){
stdmultimap.insert(StdPairType(MaxElem/2+i, MaxElem-i));
}
boostmultimap.merge(boostmultimap2);
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
for(int i = 0; i < MaxElem; ++i){
stdmultimap.insert(StdPairType(MaxElem*2/2+i, MaxElem*2+i));
}
boostmultimap.merge(boostmap2);
if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
}
return 0;
}
template<class MyBoostMap
,class MyStdMap
,class MyBoostMultiMap
,class MyStdMultiMap>
int map_test()
{
typedef typename MyBoostMap::key_type IntType;
if(map_test_range<MyBoostMap, MyStdMap, MyBoostMultiMap, MyStdMultiMap>())
return 1;
::boost::movelib::unique_ptr<MyBoostMap> const pboostmap = ::boost::movelib::make_unique<MyBoostMap>();
::boost::movelib::unique_ptr<MyStdMap> const pstdmap = ::boost::movelib::make_unique<MyStdMap>();
::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap = ::boost::movelib::make_unique<MyBoostMultiMap>();
::boost::movelib::unique_ptr<MyStdMultiMap> const pstdmultimap = ::boost::movelib::make_unique<MyStdMultiMap>();
MyBoostMap &boostmap = *pboostmap;
MyStdMap &stdmap = *pstdmap;
MyBoostMultiMap &boostmultimap = *pboostmultimap;
MyStdMultiMap &stdmultimap = *pstdmultimap;
typedef dtl::bool_<boost::container::test::is_copyable<IntType>::value> copyable_t;
if (map_test_step(boostmap, stdmap, boostmultimap, stdmultimap))
return 1;
if (map_test_insert(boostmap, stdmap, boostmultimap, stdmultimap))
return 1;
if (map_test_erase(boostmap, stdmap, boostmultimap, stdmultimap))
return 1;
if (map_test_insert2(boostmap, stdmap, boostmultimap, stdmultimap))
return 1;
if (map_test_search(boostmap, stdmap, boostmultimap, stdmultimap))
return 1;
if (map_test_indexing(boostmap, stdmap, boostmultimap, stdmultimap))
return 1;
if (map_test_try_emplace(boostmap, stdmap, boostmultimap, stdmultimap))
return 1;
if (map_test_merge(boostmap, stdmap, boostmultimap, stdmultimap))
return 1;
if (map_test_insert_or_assign<MyBoostMap, MyStdMap>(copyable_t()))
return 1;
if(map_test_copyable<MyBoostMap, MyStdMap, MyBoostMultiMap, MyStdMultiMap>(copyable_t()))
return 1;
return 0;
}
template<typename MapType>
bool test_map_support_for_initialization_list_for()
{
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
const std::initializer_list<std::pair<typename MapType::value_type::first_type, typename MapType::mapped_type>> il
= { std::make_pair(1, 2), std::make_pair(3, 4) };
const MapType expected_map(il.begin(), il.end());
{
const MapType sil = il;
if (sil != expected_map)
return false;
MapType sila(il, typename MapType::allocator_type());
if (sila != expected_map)
return false;
MapType silca(il, typename MapType::key_compare(), typename MapType::allocator_type());
if (silca != expected_map)
return false;
const MapType sil_ordered(ordered_unique_range, il);
if (sil_ordered != expected_map)
return false;
MapType sil_assign = { std::make_pair(99, 100) };
sil_assign = il;
if (sil_assign != expected_map)
return false;
}
{
MapType sil;
sil.insert(il);
if (sil != expected_map)
return false;
}
return true;
#endif
return true;
}
template<typename MapType, typename MultimapType>
bool instantiate_constructors()
{
{
typedef typename MapType::value_type value_type;
typename MapType::key_compare comp;
typename MapType::allocator_type a;
value_type value;
{
MapType s0;
MapType s1(comp);
MapType s2(a);
MapType s3(comp, a);
}
{
MapType s0(&value, &value);
MapType s1(&value, &value ,comp);
MapType s2(&value, &value ,a);
MapType s3(&value, &value ,comp, a);
}
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
{
std::initializer_list<value_type> il;
MapType s0(il);
MapType s1(il, comp);
MapType s2(il, a);
MapType s3(il, comp, a);
}
{
std::initializer_list<value_type> il;
MapType s0(ordered_unique_range, il);
MapType s1(ordered_unique_range, il, comp);
MapType s3(ordered_unique_range, il, comp, a);
}
#endif
{
MapType s0(ordered_unique_range, &value, &value);
MapType s1(ordered_unique_range, &value, &value ,comp);
MapType s2(ordered_unique_range, &value, &value ,comp, a);
}
}
{
typedef typename MultimapType::value_type value_type;
typename MultimapType::key_compare comp;
typename MultimapType::allocator_type a;
value_type value;
{
MultimapType s0;
MultimapType s1(comp);
MultimapType s2(a);
MultimapType s3(comp, a);
}
{
MultimapType s0(&value, &value);
MultimapType s1(&value, &value ,comp);
MultimapType s2(&value, &value ,a);
MultimapType s3(&value, &value ,comp, a);
}
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
{
std::initializer_list<value_type> il;
MultimapType s0(il);
MultimapType s1(il, comp);
MultimapType s2(il, a);
MultimapType s3(il, comp, a);
}
{
std::initializer_list<value_type> il;
MultimapType s0(ordered_range, il);
MultimapType s1(ordered_range, il, comp);
MultimapType s3(ordered_range, il, comp, a);
}
#endif
{
MultimapType s0(ordered_range, &value, &value);
MultimapType s1(ordered_range, &value, &value ,comp);
MultimapType s2(ordered_range, &value, &value ,comp, a);
}
}
return true;
}
} //namespace test{
} //namespace container {
} //namespace boost{
#include <boost/container/detail/config_end.hpp>
#endif //#ifndef BOOST_CONTAINER_TEST_MAP_TEST_HEADER