ceph/src/boost/libs/container/test/list_test.hpp

   1 ////////////////////////////////////////
   2 //
   3 // (C) Copyright Ion Gaztanaga 2006. Distributed under the Boost
   4 // Software License, Version 1.0. (See accompanying file
   5 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 //
   7 // See http://www.boost.org/libs/container for documentation.
   8 //
   9 ////////////////////////////////////////
  10
  11 #ifndef BOOST_CONTAINER_TEST_LIST_TEST_HEADER
  12 #define BOOST_CONTAINER_TEST_LIST_TEST_HEADER
  13
  14 #include <boost/container/detail/config_begin.hpp>
  15 #include <boost/container/detail/iterator.hpp>
  16 #include "check_equal_containers.hpp"
  17 #include "print_container.hpp"
  18 #include "input_from_forward_iterator.hpp"
  19 #include <boost/move/utility_core.hpp>
  20 #include <boost/move/iterator.hpp>
  21 #include <boost/move/make_unique.hpp>
  22
  23 #include <list>
  24 #include <functional>   //std::greater
  25
  26 namespace boost{
  27 namespace container {
  28 namespace test{
  29
  30 template<class V1, class V2>
  31 bool list_copyable_only(V1 &, V2 &, boost::container::container_detail::false_type)
  32 {
  33    return true;
  34 }
  35
  36 //Function to check if both sets are equal
  37 template<class V1, class V2>
  38 bool list_copyable_only(V1 &boostlist, V2 &stdlist, boost::container::container_detail::true_type)
  39 {
  40    typedef typename V1::value_type IntType;
  41    boostlist.insert(boostlist.end(), 50, IntType(1));
  42    stdlist.insert(stdlist.end(), 50, 1);
  43    if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
  44
  45    {
  46       IntType move_me(1);
  47       boostlist.insert(boostlist.begin(), 50, boost::move(move_me));
  48       stdlist.insert(stdlist.begin(), 50, 1);
  49       if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
  50    }
  51    {
  52       IntType move_me(2);
  53       boostlist.assign(boostlist.size()/2, boost::move(move_me));
  54       stdlist.assign(stdlist.size()/2, 2);
  55       if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
  56    }
  57    {
  58       IntType move_me(3);
  59       boostlist.assign(boostlist.size()*3-1, boost::move(move_me));
  60       stdlist.assign(stdlist.size()*3-1, 3);
  61       if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
  62    }
  63
  64    {
  65       IntType copy_me(3);
  66       const IntType ccopy_me(3);
  67       boostlist.push_front(copy_me);
  68       stdlist.push_front(int(3));
  69       boostlist.push_front(ccopy_me);
  70       stdlist.push_front(int(3));
  71       if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
  72    }
  73    {  //List(const List &)
  74       ::boost::movelib::unique_ptr<V1> const pv1 = ::boost::movelib::make_unique<V1>(boostlist);
  75       ::boost::movelib::unique_ptr<V2> const pv2 = ::boost::movelib::make_unique<V2>(stdlist);
  76
  77       V1 &v1 = *pv1;
  78       V2 &v2 = *pv2;
  79
  80       boostlist.clear();
  81       stdlist.clear();
  82       boostlist.assign(v1.begin(), v1.end());
  83       stdlist.assign(v2.begin(), v2.end());
  84       if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
  85    }
  86    {  //List(const List &, alloc)
  87       ::boost::movelib::unique_ptr<V1> const pv1 = ::boost::movelib::make_unique<V1>(boostlist, typename V1::allocator_type());
  88       ::boost::movelib::unique_ptr<V2> const pv2 = ::boost::movelib::make_unique<V2>(stdlist);
  89
  90       V1 &v1 = *pv1;
  91       V2 &v2 = *pv2;
  92
  93       boostlist.clear();
  94       stdlist.clear();
  95       boostlist.assign(v1.begin(), v1.end());
  96       stdlist.assign(v2.begin(), v2.end());
  97       if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
  98    }
  99
 100    return true;
 101 }
 102
 103 template<bool DoublyLinked>
 104 struct list_push_data_function
 105 {
 106    template<class MyBoostList, class MyStdList>
 107    static int execute(int max, MyBoostList &boostlist, MyStdList &stdlist)
 108    {
 109       typedef typename MyBoostList::value_type IntType;
 110       for(int i = 0; i < max; ++i){
 111          IntType move_me(i);
 112          boostlist.push_back(boost::move(move_me));
 113          stdlist.push_back(i);
 114          boostlist.push_front(IntType(i));
 115          stdlist.push_front(int(i));
 116       }
 117       if(!CheckEqualContainers(boostlist, stdlist))
 118          return 1;
 119       return 0;
 120    }
 121 };
 122
 123 template<>
 124 struct list_push_data_function<false>
 125 {
 126    template<class MyBoostList, class MyStdList>
 127    static int execute(int max, MyBoostList &boostlist, MyStdList &stdlist)
 128    {
 129       typedef typename MyBoostList::value_type IntType;
 130       for(int i = 0; i < max; ++i){
 131          IntType move_me(i);
 132          boostlist.push_front(boost::move(move_me));
 133          stdlist.push_front(i);
 134          boostlist.push_front(IntType(i));
 135          stdlist.push_front(int(i));
 136       }
 137       if(!CheckEqualContainers(boostlist, stdlist))
 138          return 1;
 139       return 0;
 140    }
 141 };
 142
 143 template<bool DoublyLinked>
 144 struct list_pop_back_function
 145 {
 146    template<class MyStdList, class MyBoostList>
 147    static int execute(MyBoostList &boostlist, MyStdList &stdlist)
 148    {
 149       boostlist.pop_back();
 150       stdlist.pop_back();
 151       if(!CheckEqualContainers(boostlist, stdlist))
 152          return 1;
 153       return 0;
 154    }
 155 };
 156
 157 template<>
 158 struct list_pop_back_function<false>
 159 {
 160    template<class MyStdList, class MyBoostList>
 161    static int execute(MyBoostList &boostlist, MyStdList &stdlist)
 162    {
 163       (void)boostlist; (void)stdlist;
 164       return 0;
 165    }
 166 };
 167
 168 template<class MyBoostList
 169         ,bool  DoublyLinked>
 170 int list_test (bool copied_allocators_equal = true)
 171 {
 172    typedef std::list<int> MyStdList;
 173    typedef typename MyBoostList::value_type IntType;
 174    const int max = 100;
 175    typedef list_push_data_function<DoublyLinked> push_data_t;
 176
 177    {  //List(n)
 178       ::boost::movelib::unique_ptr<MyBoostList> const pboostlist = ::boost::movelib::make_unique<MyBoostList>(100);
 179       ::boost::movelib::unique_ptr<MyStdList> const pstdlist = ::boost::movelib::make_unique<MyStdList>(100);
 180       if(!test::CheckEqualContainers(*pboostlist, *pstdlist)) return 1;
 181    }
 182    {  //List(n, alloc)
 183       ::boost::movelib::unique_ptr<MyBoostList> const pboostlist = ::boost::movelib::make_unique<MyBoostList>(100, typename MyBoostList::allocator_type());
 184       ::boost::movelib::unique_ptr<MyStdList> const pstdlist = ::boost::movelib::make_unique<MyStdList>(100);
 185       if(!test::CheckEqualContainers(*pboostlist, *pstdlist)) return 1;
 186    }
 187    {  //List(List &&)
 188       ::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100);
 189       ::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100);
 190       ::boost::movelib::unique_ptr<MyBoostList> const boostlistp2 = ::boost::movelib::make_unique<MyBoostList>(::boost::move(*boostlistp));
 191       if(!test::CheckEqualContainers(*boostlistp2, *stdlistp)) return 1;
 192    }
 193    {  //List(List &&, alloc)
 194       ::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100);
 195       ::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100);
 196       ::boost::movelib::unique_ptr<MyBoostList> const boostlistp2 = ::boost::movelib::make_unique<MyBoostList>
 197          (::boost::move(*boostlistp), typename MyBoostList::allocator_type());
 198       if(!test::CheckEqualContainers(*boostlistp2, *stdlistp)) return 1;
 199    }
 200    {  //List operator=(List &&)
 201       ::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100);
 202       ::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100);
 203       ::boost::movelib::unique_ptr<MyBoostList> const boostlistp2 = ::boost::movelib::make_unique<MyBoostList>();
 204       *boostlistp2 = ::boost::move(*boostlistp);
 205       if(!test::CheckEqualContainers(*boostlistp2, *stdlistp)) return 1;
 206    }
 207
 208    ::boost::movelib::unique_ptr<MyBoostList> const pboostlist = ::boost::movelib::make_unique<MyBoostList>();
 209    ::boost::movelib::unique_ptr<MyStdList>   const pstdlist   = ::boost::movelib::make_unique<MyStdList>();
 210
 211    MyBoostList &boostlist = *pboostlist;
 212    MyStdList  &stdlist    = *pstdlist;
 213
 214    if(push_data_t::execute(max, boostlist, stdlist)){
 215       return 1;
 216    }
 217
 218    boostlist.erase(boostlist.begin()++);
 219    stdlist.erase(stdlist.begin()++);
 220    if(!CheckEqualContainers(boostlist, stdlist)) return 1;
 221
 222    if(list_pop_back_function<DoublyLinked>::execute(boostlist, stdlist)){
 223       return 1;
 224    }
 225
 226    boostlist.pop_front();
 227    stdlist.pop_front();
 228    if(!CheckEqualContainers(boostlist, stdlist)) return 1;
 229
 230    {
 231       IntType aux_vect[50];
 232       for(int i = 0; i < 50; ++i){
 233          IntType move_me(-1);
 234          aux_vect[i] = boost::move(move_me);
 235       }
 236       int aux_vect2[50];
 237       for(int i = 0; i < 50; ++i){
 238          aux_vect2[i] = -1;
 239       }
 240       boostlist.assign(boost::make_move_iterator(&aux_vect[0])
 241                         ,boost::make_move_iterator(&aux_vect[50]));
 242       stdlist.assign(&aux_vect2[0], &aux_vect2[50]);
 243       if(!CheckEqualContainers(boostlist, stdlist)) return 1;
 244
 245       for(int i = 0; i < 50; ++i){
 246          IntType move_me(-1);
 247          aux_vect[i] = boost::move(move_me);
 248       }
 249
 250       for(int i = 0; i < 50; ++i){
 251          aux_vect2[i] = -1;
 252       }
 253       boostlist.assign(boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[0]))
 254                         ,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[50])));
 255       stdlist.assign(&aux_vect2[0], &aux_vect2[50]);
 256       if(!CheckEqualContainers(boostlist, stdlist)) return 1;
 257    }
 258
 259    if(copied_allocators_equal){
 260       boostlist.sort();
 261       stdlist.sort();
 262       if(!CheckEqualContainers(boostlist, stdlist)) return 1;
 263    }
 264
 265    boostlist.reverse();
 266    stdlist.reverse();
 267    if(!CheckEqualContainers(boostlist, stdlist)) return 1;
 268
 269    boostlist.reverse();
 270    stdlist.reverse();
 271    if(!CheckEqualContainers(boostlist, stdlist)) return 1;
 272
 273    {
 274       IntType aux_vect[50];
 275       for(int i = 0; i < 50; ++i){
 276          IntType move_me(-1);
 277          aux_vect[i] = boost::move(move_me);
 278       }
 279       int aux_vect2[50];
 280       for(int i = 0; i < 50; ++i){
 281          aux_vect2[i] = -1;
 282       }
 283       typename MyBoostList::iterator old_begin = boostlist.begin();
 284       typename MyBoostList::iterator it_insert =
 285          boostlist.insert(boostlist.begin()
 286                      ,boost::make_move_iterator(&aux_vect[0])
 287                      ,boost::make_move_iterator(&aux_vect[50]));
 288       if(it_insert != boostlist.begin() || boost::container::iterator_distance(it_insert, old_begin) != 50)
 289          return 1;
 290
 291       stdlist.insert(stdlist.begin(), &aux_vect2[0], &aux_vect2[50]);
 292       if(!CheckEqualContainers(boostlist, stdlist))
 293          return 1;
 294
 295       for(int i = 0; i < 50; ++i){
 296          IntType move_me(-1);
 297          aux_vect[i] = boost::move(move_me);
 298       }
 299
 300       for(int i = 0; i < 50; ++i){
 301          aux_vect2[i] = -1;
 302       }
 303
 304       old_begin = boostlist.begin();
 305       it_insert = boostlist.insert(boostlist.end()
 306                      ,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[0]))
 307                      ,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[50])));
 308       if(boost::container::iterator_distance(it_insert, boostlist.end()) != 50)
 309          return 1;
 310       stdlist.insert(stdlist.end(), &aux_vect2[0], &aux_vect2[50]);
 311       if(!CheckEqualContainers(boostlist, stdlist))
 312          return 1;
 313    }
 314
 315    boostlist.unique();
 316    stdlist.unique();
 317    if(!CheckEqualContainers(boostlist, stdlist))
 318       return 1;
 319
 320    if(copied_allocators_equal){
 321       boostlist.sort(std::greater<IntType>());
 322       stdlist.sort(std::greater<int>());
 323       if(!CheckEqualContainers(boostlist, stdlist))
 324          return 1;
 325    }
 326
 327    for(int i = 0; i < max; ++i){
 328       IntType new_int(i);
 329       boostlist.insert(boostlist.end(), boost::move(new_int));
 330       stdlist.insert(stdlist.end(), i);
 331       if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
 332    }
 333    if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
 334
 335    boostlist.resize(25);
 336    stdlist.resize(25);
 337    boostlist.resize(50);
 338    stdlist.resize(50);
 339    boostlist.resize(0);
 340    stdlist.resize(0);
 341    if(!CheckEqualContainers(boostlist, stdlist))
 342       return 1;
 343
 344    //some comparison operators
 345    if(!(boostlist == boostlist))
 346       return 1;
 347    if(boostlist != boostlist)
 348       return 1;
 349    if(boostlist < boostlist)
 350       return 1;
 351    if(boostlist > boostlist)
 352       return 1;
 353    if(!(boostlist <= boostlist))
 354       return 1;
 355    if(!(boostlist >= boostlist))
 356       return 1;
 357
 358    if(push_data_t::execute(max, boostlist, stdlist)){
 359       return 1;
 360    }
 361    {
 362       MyBoostList otherboostlist(boostlist.get_allocator());
 363       MyStdList otherstdlist;
 364
 365       int listsize = (int)boostlist.size();
 366
 367       if(push_data_t::execute(listsize, boostlist, stdlist)){
 368          return 1;
 369       }
 370
 371       if(copied_allocators_equal){
 372          boostlist.splice(boostlist.begin(), otherboostlist);
 373          stdlist.splice(stdlist.begin(), otherstdlist);
 374          if(!CheckEqualContainers(boostlist, stdlist))
 375             return 1;
 376       }
 377
 378       listsize = (int)boostlist.size();
 379
 380       if(push_data_t::execute(listsize, boostlist, stdlist)){
 381          return 1;
 382       }
 383
 384       if(push_data_t::execute(listsize, otherboostlist, otherstdlist)){
 385          return 1;
 386       }
 387
 388       if(copied_allocators_equal){
 389          boostlist.sort(std::greater<IntType>());
 390          stdlist.sort(std::greater<int>());
 391          if(!CheckEqualContainers(boostlist, stdlist))
 392             return 1;
 393
 394          otherboostlist.sort(std::greater<IntType>());
 395          otherstdlist.sort(std::greater<int>());
 396          if(!CheckEqualContainers(otherboostlist, otherstdlist))
 397             return 1;
 398
 399          boostlist.merge(otherboostlist, std::greater<IntType>());
 400          stdlist.merge(otherstdlist, std::greater<int>());
 401          if(!CheckEqualContainers(boostlist, stdlist))
 402             return 1;
 403       }
 404
 405       if(!list_copyable_only(boostlist, stdlist
 406                      ,container_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
 407          return 1;
 408       }
 409    }
 410    return 0;
 411 }
 412
 413 template<class List>
 414 bool test_list_methods_with_initializer_list_as_argument_for()
 415 {
 416 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 417    const std::initializer_list<int> il = {5, 10, 15};
 418    const List expected_list(il.begin(), il.end());
 419    {
 420       List sl = il;
 421       if(sl != expected_list)
 422          return false;
 423    }
 424
 425    {
 426       List sl = {1, 2};
 427       sl = il;
 428       if(sl != expected_list)
 429          return false;
 430    }
 431    {
 432       List sl({ 1, 2 }, typename List::allocator_type());
 433       sl = il;
 434       if (sl != expected_list)
 435          return false;
 436    }
 437    {
 438       List sl = {4, 5};
 439       sl.assign(il);
 440       if(sl != expected_list)
 441          return false;
 442    }
 443
 444    {
 445       List sl = {15};
 446       sl.insert(sl.cbegin(), {5, 10});
 447       if(sl != expected_list)
 448          return false;
 449    }
 450
 451    {
 452        List sl = {5};
 453        sl.insert_after(sl.cbegin(), {10, 15});
 454        if(sl != expected_list)
 455           return false;
 456    }
 457    return true;
 458 #endif
 459    return true;
 460 }
 461
 462
 463 }  //namespace test{
 464 }  //namespace container {
 465 }  //namespace boost{
 466
 467 #include <boost/container/detail/config_end.hpp>
 468
 469 #endif