470 lines
14 KiB
C++
470 lines
14 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_LIST_TEST_HEADER
|
|
#define BOOST_CONTAINER_TEST_LIST_TEST_HEADER
|
|
|
|
#include <boost/container/detail/config_begin.hpp>
|
|
#include <boost/container/detail/iterator.hpp>
|
|
#include "check_equal_containers.hpp"
|
|
#include "print_container.hpp"
|
|
#include "input_from_forward_iterator.hpp"
|
|
#include <boost/move/utility_core.hpp>
|
|
#include <boost/move/iterator.hpp>
|
|
#include <boost/move/make_unique.hpp>
|
|
|
|
#include <list>
|
|
#include <functional> //std::greater
|
|
|
|
namespace boost{
|
|
namespace container {
|
|
namespace test{
|
|
|
|
template<class V1, class V2>
|
|
bool list_copyable_only(V1 &, V2 &, boost::container::dtl::false_type)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//Function to check if both sets are equal
|
|
template<class V1, class V2>
|
|
bool list_copyable_only(V1 &boostlist, V2 &stdlist, boost::container::dtl::true_type)
|
|
{
|
|
typedef typename V1::value_type IntType;
|
|
boostlist.insert(boostlist.end(), 50, IntType(1));
|
|
stdlist.insert(stdlist.end(), 50, 1);
|
|
if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
|
|
|
|
{
|
|
IntType move_me(1);
|
|
boostlist.insert(boostlist.begin(), 50, boost::move(move_me));
|
|
stdlist.insert(stdlist.begin(), 50, 1);
|
|
if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
|
|
}
|
|
{
|
|
IntType move_me(2);
|
|
boostlist.assign(boostlist.size()/2, boost::move(move_me));
|
|
stdlist.assign(stdlist.size()/2, 2);
|
|
if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
|
|
}
|
|
{
|
|
IntType move_me(3);
|
|
boostlist.assign(boostlist.size()*3-1, boost::move(move_me));
|
|
stdlist.assign(stdlist.size()*3-1, 3);
|
|
if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
|
|
}
|
|
|
|
{
|
|
IntType copy_me(3);
|
|
const IntType ccopy_me(3);
|
|
boostlist.push_front(copy_me);
|
|
stdlist.push_front(int(3));
|
|
boostlist.push_front(ccopy_me);
|
|
stdlist.push_front(int(3));
|
|
if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
|
|
}
|
|
{ //List(const List &)
|
|
::boost::movelib::unique_ptr<V1> const pv1 = ::boost::movelib::make_unique<V1>(boostlist);
|
|
::boost::movelib::unique_ptr<V2> const pv2 = ::boost::movelib::make_unique<V2>(stdlist);
|
|
|
|
V1 &v1 = *pv1;
|
|
V2 &v2 = *pv2;
|
|
|
|
boostlist.clear();
|
|
stdlist.clear();
|
|
boostlist.assign(v1.begin(), v1.end());
|
|
stdlist.assign(v2.begin(), v2.end());
|
|
if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
|
|
}
|
|
{ //List(const List &, alloc)
|
|
::boost::movelib::unique_ptr<V1> const pv1 = ::boost::movelib::make_unique<V1>(boostlist, typename V1::allocator_type());
|
|
::boost::movelib::unique_ptr<V2> const pv2 = ::boost::movelib::make_unique<V2>(stdlist);
|
|
|
|
V1 &v1 = *pv1;
|
|
V2 &v2 = *pv2;
|
|
|
|
boostlist.clear();
|
|
stdlist.clear();
|
|
boostlist.assign(v1.begin(), v1.end());
|
|
stdlist.assign(v2.begin(), v2.end());
|
|
if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template<bool DoublyLinked>
|
|
struct list_push_data_function
|
|
{
|
|
template<class MyBoostList, class MyStdList>
|
|
static int execute(int max, MyBoostList &boostlist, MyStdList &stdlist)
|
|
{
|
|
typedef typename MyBoostList::value_type IntType;
|
|
for(int i = 0; i < max; ++i){
|
|
IntType move_me(i);
|
|
boostlist.push_back(boost::move(move_me));
|
|
stdlist.push_back(i);
|
|
boostlist.push_front(IntType(i));
|
|
stdlist.push_front(int(i));
|
|
}
|
|
if(!CheckEqualContainers(boostlist, stdlist))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct list_push_data_function<false>
|
|
{
|
|
template<class MyBoostList, class MyStdList>
|
|
static int execute(int max, MyBoostList &boostlist, MyStdList &stdlist)
|
|
{
|
|
typedef typename MyBoostList::value_type IntType;
|
|
for(int i = 0; i < max; ++i){
|
|
IntType move_me(i);
|
|
boostlist.push_front(boost::move(move_me));
|
|
stdlist.push_front(i);
|
|
boostlist.push_front(IntType(i));
|
|
stdlist.push_front(int(i));
|
|
}
|
|
if(!CheckEqualContainers(boostlist, stdlist))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
template<bool DoublyLinked>
|
|
struct list_pop_back_function
|
|
{
|
|
template<class MyStdList, class MyBoostList>
|
|
static int execute(MyBoostList &boostlist, MyStdList &stdlist)
|
|
{
|
|
boostlist.pop_back();
|
|
stdlist.pop_back();
|
|
if(!CheckEqualContainers(boostlist, stdlist))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct list_pop_back_function<false>
|
|
{
|
|
template<class MyStdList, class MyBoostList>
|
|
static int execute(MyBoostList &boostlist, MyStdList &stdlist)
|
|
{
|
|
(void)boostlist; (void)stdlist;
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
template<class MyBoostList
|
|
,bool DoublyLinked>
|
|
int list_test (bool copied_allocators_equal = true)
|
|
{
|
|
typedef std::list<int> MyStdList;
|
|
typedef typename MyBoostList::value_type IntType;
|
|
const int max = 100;
|
|
typedef list_push_data_function<DoublyLinked> push_data_t;
|
|
|
|
{ //List(n)
|
|
::boost::movelib::unique_ptr<MyBoostList> const pboostlist = ::boost::movelib::make_unique<MyBoostList>(100);
|
|
::boost::movelib::unique_ptr<MyStdList> const pstdlist = ::boost::movelib::make_unique<MyStdList>(100);
|
|
if(!test::CheckEqualContainers(*pboostlist, *pstdlist)) return 1;
|
|
}
|
|
{ //List(n, alloc)
|
|
::boost::movelib::unique_ptr<MyBoostList> const pboostlist = ::boost::movelib::make_unique<MyBoostList>(100, typename MyBoostList::allocator_type());
|
|
::boost::movelib::unique_ptr<MyStdList> const pstdlist = ::boost::movelib::make_unique<MyStdList>(100);
|
|
if(!test::CheckEqualContainers(*pboostlist, *pstdlist)) return 1;
|
|
}
|
|
{ //List(List &&)
|
|
::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100);
|
|
::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100);
|
|
::boost::movelib::unique_ptr<MyBoostList> const boostlistp2 = ::boost::movelib::make_unique<MyBoostList>(::boost::move(*boostlistp));
|
|
if(!test::CheckEqualContainers(*boostlistp2, *stdlistp)) return 1;
|
|
}
|
|
{ //List(List &&, alloc)
|
|
::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100);
|
|
::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100);
|
|
::boost::movelib::unique_ptr<MyBoostList> const boostlistp2 = ::boost::movelib::make_unique<MyBoostList>
|
|
(::boost::move(*boostlistp), typename MyBoostList::allocator_type());
|
|
if(!test::CheckEqualContainers(*boostlistp2, *stdlistp)) return 1;
|
|
}
|
|
{ //List operator=(List &&)
|
|
::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100);
|
|
::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100);
|
|
::boost::movelib::unique_ptr<MyBoostList> const boostlistp2 = ::boost::movelib::make_unique<MyBoostList>();
|
|
*boostlistp2 = ::boost::move(*boostlistp);
|
|
if(!test::CheckEqualContainers(*boostlistp2, *stdlistp)) return 1;
|
|
}
|
|
|
|
::boost::movelib::unique_ptr<MyBoostList> const pboostlist = ::boost::movelib::make_unique<MyBoostList>();
|
|
::boost::movelib::unique_ptr<MyStdList> const pstdlist = ::boost::movelib::make_unique<MyStdList>();
|
|
|
|
MyBoostList &boostlist = *pboostlist;
|
|
MyStdList &stdlist = *pstdlist;
|
|
|
|
if(push_data_t::execute(max, boostlist, stdlist)){
|
|
return 1;
|
|
}
|
|
|
|
boostlist.erase(boostlist.begin()++);
|
|
stdlist.erase(stdlist.begin()++);
|
|
if(!CheckEqualContainers(boostlist, stdlist)) return 1;
|
|
|
|
if(list_pop_back_function<DoublyLinked>::execute(boostlist, stdlist)){
|
|
return 1;
|
|
}
|
|
|
|
boostlist.pop_front();
|
|
stdlist.pop_front();
|
|
if(!CheckEqualContainers(boostlist, stdlist)) return 1;
|
|
|
|
{
|
|
IntType aux_vect[50];
|
|
for(int i = 0; i < 50; ++i){
|
|
IntType move_me(-1);
|
|
aux_vect[i] = boost::move(move_me);
|
|
}
|
|
int aux_vect2[50];
|
|
for(int i = 0; i < 50; ++i){
|
|
aux_vect2[i] = -1;
|
|
}
|
|
boostlist.assign(boost::make_move_iterator(&aux_vect[0])
|
|
,boost::make_move_iterator(&aux_vect[50]));
|
|
stdlist.assign(&aux_vect2[0], &aux_vect2[50]);
|
|
if(!CheckEqualContainers(boostlist, stdlist)) return 1;
|
|
|
|
for(int i = 0; i < 50; ++i){
|
|
IntType move_me(-1);
|
|
aux_vect[i] = boost::move(move_me);
|
|
}
|
|
|
|
for(int i = 0; i < 50; ++i){
|
|
aux_vect2[i] = -1;
|
|
}
|
|
boostlist.assign(boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[0]))
|
|
,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[50])));
|
|
stdlist.assign(&aux_vect2[0], &aux_vect2[50]);
|
|
if(!CheckEqualContainers(boostlist, stdlist)) return 1;
|
|
}
|
|
|
|
if(copied_allocators_equal){
|
|
boostlist.sort();
|
|
stdlist.sort();
|
|
if(!CheckEqualContainers(boostlist, stdlist)) return 1;
|
|
}
|
|
|
|
boostlist.reverse();
|
|
stdlist.reverse();
|
|
if(!CheckEqualContainers(boostlist, stdlist)) return 1;
|
|
|
|
boostlist.reverse();
|
|
stdlist.reverse();
|
|
if(!CheckEqualContainers(boostlist, stdlist)) return 1;
|
|
|
|
{
|
|
IntType aux_vect[50];
|
|
for(int i = 0; i < 50; ++i){
|
|
IntType move_me(-1);
|
|
aux_vect[i] = boost::move(move_me);
|
|
}
|
|
int aux_vect2[50];
|
|
for(int i = 0; i < 50; ++i){
|
|
aux_vect2[i] = -1;
|
|
}
|
|
typename MyBoostList::iterator old_begin = boostlist.begin();
|
|
typename MyBoostList::iterator it_insert =
|
|
boostlist.insert(boostlist.begin()
|
|
,boost::make_move_iterator(&aux_vect[0])
|
|
,boost::make_move_iterator(&aux_vect[50]));
|
|
if(it_insert != boostlist.begin() || boost::container::iterator_distance(it_insert, old_begin) != 50)
|
|
return 1;
|
|
|
|
stdlist.insert(stdlist.begin(), &aux_vect2[0], &aux_vect2[50]);
|
|
if(!CheckEqualContainers(boostlist, stdlist))
|
|
return 1;
|
|
|
|
for(int i = 0; i < 50; ++i){
|
|
IntType move_me(-1);
|
|
aux_vect[i] = boost::move(move_me);
|
|
}
|
|
|
|
for(int i = 0; i < 50; ++i){
|
|
aux_vect2[i] = -1;
|
|
}
|
|
|
|
old_begin = boostlist.begin();
|
|
it_insert = boostlist.insert(boostlist.end()
|
|
,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[0]))
|
|
,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[50])));
|
|
if(boost::container::iterator_distance(it_insert, boostlist.end()) != 50)
|
|
return 1;
|
|
stdlist.insert(stdlist.end(), &aux_vect2[0], &aux_vect2[50]);
|
|
if(!CheckEqualContainers(boostlist, stdlist))
|
|
return 1;
|
|
}
|
|
|
|
boostlist.unique();
|
|
stdlist.unique();
|
|
if(!CheckEqualContainers(boostlist, stdlist))
|
|
return 1;
|
|
|
|
if(copied_allocators_equal){
|
|
boostlist.sort(std::greater<IntType>());
|
|
stdlist.sort(std::greater<int>());
|
|
if(!CheckEqualContainers(boostlist, stdlist))
|
|
return 1;
|
|
}
|
|
|
|
for(int i = 0; i < max; ++i){
|
|
IntType new_int(i);
|
|
boostlist.insert(boostlist.end(), boost::move(new_int));
|
|
stdlist.insert(stdlist.end(), i);
|
|
if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
|
|
}
|
|
if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
|
|
|
|
boostlist.resize(25);
|
|
stdlist.resize(25);
|
|
boostlist.resize(50);
|
|
stdlist.resize(50);
|
|
boostlist.resize(0);
|
|
stdlist.resize(0);
|
|
if(!CheckEqualContainers(boostlist, stdlist))
|
|
return 1;
|
|
|
|
//some comparison operators
|
|
if(!(boostlist == boostlist))
|
|
return 1;
|
|
if(boostlist != boostlist)
|
|
return 1;
|
|
if(boostlist < boostlist)
|
|
return 1;
|
|
if(boostlist > boostlist)
|
|
return 1;
|
|
if(!(boostlist <= boostlist))
|
|
return 1;
|
|
if(!(boostlist >= boostlist))
|
|
return 1;
|
|
|
|
if(push_data_t::execute(max, boostlist, stdlist)){
|
|
return 1;
|
|
}
|
|
{
|
|
MyBoostList otherboostlist(boostlist.get_allocator());
|
|
MyStdList otherstdlist;
|
|
|
|
int listsize = (int)boostlist.size();
|
|
|
|
if(push_data_t::execute(listsize, boostlist, stdlist)){
|
|
return 1;
|
|
}
|
|
|
|
if(copied_allocators_equal){
|
|
boostlist.splice(boostlist.begin(), otherboostlist);
|
|
stdlist.splice(stdlist.begin(), otherstdlist);
|
|
if(!CheckEqualContainers(boostlist, stdlist))
|
|
return 1;
|
|
}
|
|
|
|
listsize = (int)boostlist.size();
|
|
|
|
if(push_data_t::execute(listsize, boostlist, stdlist)){
|
|
return 1;
|
|
}
|
|
|
|
if(push_data_t::execute(listsize, otherboostlist, otherstdlist)){
|
|
return 1;
|
|
}
|
|
|
|
if(copied_allocators_equal){
|
|
boostlist.sort(std::greater<IntType>());
|
|
stdlist.sort(std::greater<int>());
|
|
if(!CheckEqualContainers(boostlist, stdlist))
|
|
return 1;
|
|
|
|
otherboostlist.sort(std::greater<IntType>());
|
|
otherstdlist.sort(std::greater<int>());
|
|
if(!CheckEqualContainers(otherboostlist, otherstdlist))
|
|
return 1;
|
|
|
|
boostlist.merge(otherboostlist, std::greater<IntType>());
|
|
stdlist.merge(otherstdlist, std::greater<int>());
|
|
if(!CheckEqualContainers(boostlist, stdlist))
|
|
return 1;
|
|
}
|
|
|
|
if(!list_copyable_only(boostlist, stdlist
|
|
,dtl::bool_<boost::container::test::is_copyable<IntType>::value>())){
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
template<class List>
|
|
bool test_list_methods_with_initializer_list_as_argument_for()
|
|
{
|
|
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
|
|
const std::initializer_list<int> il = {5, 10, 15};
|
|
const List expected_list(il.begin(), il.end());
|
|
{
|
|
List sl = il;
|
|
if(sl != expected_list)
|
|
return false;
|
|
}
|
|
|
|
{
|
|
List sl = {1, 2};
|
|
sl = il;
|
|
if(sl != expected_list)
|
|
return false;
|
|
}
|
|
{
|
|
List sl({ 1, 2 }, typename List::allocator_type());
|
|
sl = il;
|
|
if (sl != expected_list)
|
|
return false;
|
|
}
|
|
{
|
|
List sl = {4, 5};
|
|
sl.assign(il);
|
|
if(sl != expected_list)
|
|
return false;
|
|
}
|
|
|
|
{
|
|
List sl = {15};
|
|
sl.insert(sl.cbegin(), {5, 10});
|
|
if(sl != expected_list)
|
|
return false;
|
|
}
|
|
|
|
{
|
|
List sl = {5};
|
|
sl.insert_after(sl.cbegin(), {10, 15});
|
|
if(sl != expected_list)
|
|
return false;
|
|
}
|
|
return true;
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
|
|
} //namespace test{
|
|
} //namespace container {
|
|
} //namespace boost{
|
|
|
|
#include <boost/container/detail/config_end.hpp>
|
|
|
|
#endif
|