ceph/src/boost/libs/circular_buffer/test/base_test.cpp

   1 // Test of the base circular buffer container.
   2
   3 // Copyright (c) 2003-2008 Jan Gaspar
   4 // Copyright (c) 2013 Antony Polukhin
   5
   6 // Use, modification, and distribution is subject to the Boost Software
   7 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   8 // http://www.boost.org/LICENSE_1_0.txt)
   9
  10 #include "test.hpp"
  11
  12 #define CB_CONTAINER circular_buffer
  13
  14 #include "common.ipp"
  15
  16 void iterator_constructor_and_assign_test() {
  17
  18     circular_buffer<MyInteger> cb(4, 3);
  19     circular_buffer<MyInteger>::iterator it = cb.begin();
  20     circular_buffer<MyInteger>::const_iterator cit2 = cb.cbegin();
  21     circular_buffer<MyInteger>::iterator itCopy;
  22     itCopy = it;
  23     it = it;
  24     circular_buffer<MyInteger>::const_iterator cit;
  25     cit = it;
  26     circular_buffer<MyInteger>::const_iterator end1 = cb.end();
  27     circular_buffer<MyInteger>::const_iterator end2 = end1;
  28     circular_buffer<MyInteger>::const_iterator end3 = cb.cend();
  29
  30     BOOST_TEST(itCopy == it);
  31     BOOST_TEST(cit == it);
  32     BOOST_TEST(end1 == end2);
  33     BOOST_TEST(it != end1);
  34     BOOST_TEST(cit != end2);
  35     BOOST_TEST(cit2 == it);
  36     BOOST_TEST(end3 == end1);
  37 }
  38
  39 void iterator_reference_test() {
  40
  41     circular_buffer<Dummy> cb(3, Dummy());
  42     circular_buffer<Dummy>::iterator it = cb.begin();
  43     circular_buffer<Dummy>::const_iterator cit = cb.begin() + 1;
  44
  45     BOOST_TEST((*it).m_n == Dummy::eVar);
  46     BOOST_TEST((*it).fnc() == Dummy::eFnc);
  47     BOOST_TEST((*cit).const_fnc() == Dummy::eConst);
  48     BOOST_TEST((*it).virtual_fnc() == Dummy::eVirtual);
  49     BOOST_TEST(it->m_n == Dummy::eVar);
  50     BOOST_TEST(it->fnc() == Dummy::eFnc);
  51     BOOST_TEST(cit->const_fnc() == Dummy::eConst);
  52     BOOST_TEST(it->virtual_fnc() == Dummy::eVirtual);
  53 }
  54
  55 void iterator_difference_test() {
  56
  57     circular_buffer<MyInteger> cb(5, 1);
  58     cb.push_back(2);
  59     circular_buffer<MyInteger>::iterator it1 = cb.begin() + 2;
  60     circular_buffer<MyInteger>::iterator it2 = cb.begin() + 3;
  61     circular_buffer<MyInteger>::const_iterator begin = cb.begin();
  62     circular_buffer<MyInteger>::iterator end = cb.end();
  63
  64     BOOST_TEST(begin - begin == 0);
  65     BOOST_TEST(end - cb.begin() == 5);
  66     BOOST_TEST(end - end == 0);
  67     BOOST_TEST(begin - cb.end() == -5);
  68     BOOST_TEST(it1 - cb.begin() == 2);
  69     BOOST_TEST(it1 - begin == 2);
  70     BOOST_TEST(end - it1 == 3);
  71     BOOST_TEST(it2 - it1 == 1);
  72     BOOST_TEST(it1 - it2 == -1);
  73     BOOST_TEST(it2 - it2 == 0);
  74 }
  75
  76 void iterator_increment_test() {
  77
  78     circular_buffer<MyInteger> cb(10, 1);
  79     cb.push_back(2);
  80     circular_buffer<MyInteger>::iterator it1 = cb.begin();
  81     circular_buffer<MyInteger>::iterator it2 = cb.begin() + 5;
  82     circular_buffer<MyInteger>::iterator it3 = cb.begin() + 9;
  83     it1++;
  84     it2++;
  85     ++it3;
  86
  87     BOOST_TEST(it1 == cb.begin() + 1);
  88     BOOST_TEST(it2 == cb.begin() + 6);
  89     BOOST_TEST(it3 == cb.end());
  90 }
  91
  92 void iterator_decrement_test() {
  93
  94     circular_buffer<MyInteger> cb(10, 1);
  95     cb.push_back(2);
  96     circular_buffer<MyInteger>::iterator it1= cb.end();
  97     circular_buffer<MyInteger>::iterator it2= cb.end() - 5;
  98     circular_buffer<MyInteger>::iterator it3= cb.end() - 9;
  99     --it1;
 100     it2--;
 101     --it3;
 102
 103     BOOST_TEST(it1 == cb.end() - 1);
 104     BOOST_TEST(it2 == cb.end() - 6);
 105     BOOST_TEST(it3 == cb.begin());
 106 }
 107
 108 void iterator_addition_test() {
 109
 110     circular_buffer<MyInteger> cb(10, 1);
 111     cb.push_back(2);
 112     cb.push_back(2);
 113     circular_buffer<MyInteger>::iterator it1 = cb.begin() + 2;
 114     circular_buffer<MyInteger>::iterator it2 = cb.end();
 115     circular_buffer<MyInteger>::iterator it3 = cb.begin() + 5;
 116     circular_buffer<MyInteger>::iterator it4 = cb.begin() + 9;
 117     it1 += 3;
 118     it2 += 0;
 119     it3 += 5;
 120     it4 += -2;
 121
 122     BOOST_TEST(it1 == 5 + cb.begin());
 123     BOOST_TEST(it2 == cb.end());
 124     BOOST_TEST(it3 == cb.end());
 125     BOOST_TEST(it4 + 3 == cb.end());
 126     BOOST_TEST((-3) + it4 == cb.begin() + 4);
 127     BOOST_TEST(cb.begin() + 0 == cb.begin());
 128 }
 129
 130 void iterator_subtraction_test() {
 131
 132     circular_buffer<MyInteger> cb(10, 1);
 133     cb.push_back(2);
 134     cb.push_back(2);
 135     cb.push_back(2);
 136     circular_buffer<MyInteger>::iterator it1 = cb.begin();
 137     circular_buffer<MyInteger>::iterator it2 = cb.end();
 138     circular_buffer<MyInteger>::iterator it3 = cb.end() - 5;
 139     circular_buffer<MyInteger>::iterator it4 = cb.begin() + 7;
 140     it1 -= -2;
 141     it2 -= 0;
 142     it3 -= 5;
 143
 144     BOOST_TEST(it1 == cb.begin() + 2);
 145     BOOST_TEST(it2 == cb.end());
 146     BOOST_TEST(it3 == cb.begin());
 147     BOOST_TEST(it4 - 7 == cb.begin());
 148     BOOST_TEST(it4 - (-3) == cb.end());
 149     BOOST_TEST(cb.begin() - 0 == cb.begin());
 150 }
 151
 152 void iterator_element_access_test() {
 153
 154     circular_buffer<MyInteger> cb(10);
 155     cb.push_back(1);
 156     cb.push_back(2);
 157     cb.push_back(3);
 158     cb.push_back(4);
 159     cb.push_back(5);
 160     cb.push_back(6);
 161     circular_buffer<MyInteger>::iterator it = cb.begin() + 1;
 162
 163     BOOST_TEST(it[0] == 2);
 164     BOOST_TEST(it[-1] == 1);
 165     BOOST_TEST(it[2] == 4);
 166 }
 167
 168 void iterator_comparison_test() {
 169
 170     circular_buffer<MyInteger> cb(5, 1);
 171     cb.push_back(2);
 172     circular_buffer<MyInteger>::iterator it = cb.begin() + 2;
 173     circular_buffer<MyInteger>::const_iterator begin = cb.begin();
 174     circular_buffer<MyInteger>::iterator end = cb.end();
 175
 176     BOOST_TEST(begin == begin);
 177     BOOST_TEST(end > cb.begin());
 178     BOOST_TEST(begin < end);
 179     BOOST_TEST(end > begin);
 180     BOOST_TEST(end == end);
 181     BOOST_TEST(begin < cb.end());
 182     BOOST_TEST(!(begin + 1 > cb.end()));
 183     BOOST_TEST(it > cb.begin());
 184     BOOST_TEST(end > it);
 185     BOOST_TEST(begin >= begin);
 186     BOOST_TEST(end >= cb.begin());
 187     BOOST_TEST(end <= end);
 188     BOOST_TEST(begin <= cb.end());
 189     BOOST_TEST(it >= cb.begin());
 190     BOOST_TEST(end >= it);
 191     BOOST_TEST(!(begin + 4 < begin + 4));
 192     BOOST_TEST(begin + 4 < begin + 5);
 193     BOOST_TEST(!(begin + 5 < begin + 4));
 194     BOOST_TEST(it < end - 1);
 195     BOOST_TEST(!(end - 1 < it));
 196 }
 197
 198 void iterator_invalidation_test() {
 199
 200 #if BOOST_CB_ENABLE_DEBUG
 201
 202     circular_buffer<MyInteger>::iterator it1;
 203     circular_buffer<MyInteger>::const_iterator it2;
 204     circular_buffer<MyInteger>::iterator it3;
 205     circular_buffer<MyInteger>::const_iterator it4;
 206     circular_buffer<MyInteger>::const_iterator it5;
 207     circular_buffer<MyInteger>::const_iterator it6;
 208
 209     BOOST_TEST(it1.is_valid(0));
 210     BOOST_TEST(it2.is_valid(0));
 211     BOOST_TEST(it3.is_valid(0));
 212     BOOST_TEST(it4.is_valid(0));
 213     BOOST_TEST(it5.is_valid(0));
 214     BOOST_TEST(it6.is_valid(0));
 215
 216     {
 217         circular_buffer<MyInteger> cb(5, 0);
 218         const circular_buffer<MyInteger> ccb(5, 0);
 219
 220         it1 = cb.begin();
 221         it2 = ccb.begin();
 222         it3 = cb.end();
 223         it4 = it1;
 224         it5 = it2;
 225         it6 = it1;
 226
 227         BOOST_TEST(it1.is_valid(&cb));
 228         BOOST_TEST(it2.is_valid(&ccb));
 229         BOOST_TEST(it3.is_valid(&cb));
 230         BOOST_TEST(it4.is_valid(&cb));
 231         BOOST_TEST(it5.is_valid(&ccb));
 232         BOOST_TEST(it6.is_valid(&cb));
 233     }
 234
 235     BOOST_TEST(it1.is_valid(0));
 236     BOOST_TEST(it2.is_valid(0));
 237     BOOST_TEST(it3.is_valid(0));
 238     BOOST_TEST(it4.is_valid(0));
 239     BOOST_TEST(it5.is_valid(0));
 240     BOOST_TEST(it6.is_valid(0));
 241
 242     circular_buffer<MyInteger> cb(10, 0);
 243     it1 = cb.end();
 244     cb.clear();
 245     BOOST_TEST(it1.is_valid(&cb));
 246     cb.push_back(1);
 247     cb.push_back(2);
 248     cb.push_back(3);
 249     int i = 0;
 250     for (it2 = cb.begin(); it2 != it1; it2++, i++);
 251     BOOST_TEST(i == 3);
 252
 253     circular_buffer<MyInteger> cb1(10, 0);
 254     circular_buffer<MyInteger> cb2(20, 0);
 255     it1 = cb1.end();
 256     it2 = cb2.begin();
 257     BOOST_TEST(it1.is_valid(&cb1));
 258     BOOST_TEST(it2.is_valid(&cb2));
 259
 260     cb1.swap(cb2);
 261     BOOST_TEST(!it1.is_valid(&cb1));
 262     BOOST_TEST(!it2.is_valid(&cb2));
 263
 264     it1 = cb1.begin() + 3;
 265     it2 = cb1.begin();
 266     cb1.push_back(1);
 267     BOOST_TEST(it1.is_valid(&cb1));
 268     BOOST_TEST(!it2.is_valid(&cb1));
 269     BOOST_TEST(*it2.m_it == 1);
 270
 271     circular_buffer<MyInteger> cb3(5);
 272     cb3.push_back(1);
 273     cb3.push_back(2);
 274     cb3.push_back(3);
 275     cb3.push_back(4);
 276     cb3.push_back(5);
 277     it1 = cb3.begin() + 2;
 278     it2 = cb3.begin();
 279     cb3.insert(cb3.begin() + 3, 6);
 280     BOOST_TEST(it1.is_valid(&cb3));
 281     BOOST_TEST(!it2.is_valid(&cb3));
 282     BOOST_TEST(*it2.m_it == 5);
 283
 284     it1 = cb3.begin() + 3;
 285     it2 = cb3.end() - 1;
 286     cb3.push_front(7);
 287     BOOST_TEST(it1.is_valid(&cb3));
 288     BOOST_TEST(!it2.is_valid(&cb3));
 289     BOOST_TEST(*it2.m_it == 7);
 290
 291     circular_buffer<MyInteger> cb4(5);
 292     cb4.push_back(1);
 293     cb4.push_back(2);
 294     cb4.push_back(3);
 295     cb4.push_back(4);
 296     cb4.push_back(5);
 297     it1 = cb4.begin() + 3;
 298     it2 = cb4.begin();
 299     cb4.rinsert(cb4.begin() + 2, 6);
 300     BOOST_TEST(it1.is_valid(&cb4));
 301     BOOST_TEST(!it2.is_valid(&cb4));
 302     BOOST_TEST(*it2.m_it == 2);
 303
 304     it1 = cb1.begin() + 5;
 305     it2 = cb1.end() - 1;
 306     cb1.pop_back();
 307     BOOST_TEST(it1.is_valid(&cb1));
 308     BOOST_TEST(!it2.is_valid(&cb1));
 309
 310     it1 = cb1.begin() + 5;
 311     it2 = cb1.begin();
 312     cb1.pop_front();
 313     BOOST_TEST(it1.is_valid(&cb1));
 314     BOOST_TEST(!it2.is_valid(&cb1));
 315
 316     circular_buffer<MyInteger> cb5(20, 0);
 317     it1 = cb5.begin() + 5;
 318     it2 = it3 = cb5.begin() + 15;
 319     cb5.erase(cb5.begin() + 10);
 320     BOOST_TEST(it1.is_valid(&cb5));
 321     BOOST_TEST(!it2.is_valid(&cb5));
 322     BOOST_TEST(!it3.is_valid(&cb5));
 323
 324     it1 = cb5.begin() + 1;
 325     it2 = it3 = cb5.begin() + 8;
 326     cb5.erase(cb5.begin() + 3, cb5.begin() + 7);
 327     BOOST_TEST(it1.is_valid(&cb5));
 328     BOOST_TEST(!it2.is_valid(&cb5));
 329     BOOST_TEST(!it3.is_valid(&cb5));
 330
 331     circular_buffer<MyInteger> cb6(20, 0);
 332     it4 = it1 = cb6.begin() + 5;
 333     it2 = cb6.begin() + 15;
 334     cb6.rerase(cb6.begin() + 10);
 335     BOOST_TEST(!it1.is_valid(&cb6));
 336     BOOST_TEST(!it4.is_valid(&cb6));
 337     BOOST_TEST(it2.is_valid(&cb6));
 338
 339     it4 = it1 = cb6.begin() + 1;
 340     it2 = cb6.begin() + 8;
 341     cb6.rerase(cb6.begin() + 3, cb6.begin() + 7);
 342     BOOST_TEST(!it1.is_valid(&cb6));
 343     BOOST_TEST(!it4.is_valid(&cb6));
 344     BOOST_TEST(it2.is_valid(&cb6));
 345
 346     circular_buffer<MyInteger> cb7(10, 1);
 347     cb7.push_back(2);
 348     cb7.push_back(3);
 349     cb7.push_back(4);
 350     it1 = cb7.end();
 351     it2 = cb7.begin();
 352     it3 = cb7.begin() + 6;
 353     cb7.linearize();
 354     BOOST_TEST(it1.is_valid(&cb7));
 355     BOOST_TEST(!it2.is_valid(&cb7));
 356     BOOST_TEST(!it3.is_valid(&cb7));
 357     it1 = cb7.end();
 358     it2 = cb7.begin();
 359     it3 = cb7.begin() + 6;
 360     cb7.linearize();
 361     BOOST_TEST(it1.is_valid(&cb7));
 362     BOOST_TEST(it2.is_valid(&cb7));
 363     BOOST_TEST(it3.is_valid(&cb7));
 364
 365     cb7.push_back(5);
 366     cb7.push_back(6);
 367     it1 = cb7.end();
 368     it2 = cb7.begin();
 369     it3 = cb7.begin() + 6;
 370     cb7.set_capacity(10);
 371     BOOST_TEST(it1.is_valid(&cb7));
 372     BOOST_TEST(it2.is_valid(&cb7));
 373     BOOST_TEST(it3.is_valid(&cb7));
 374     cb7.set_capacity(20);
 375     BOOST_TEST(it1.is_valid(&cb7));
 376     BOOST_TEST(!it2.is_valid(&cb7));
 377     BOOST_TEST(!it3.is_valid(&cb7));
 378     cb7.push_back(7);
 379     it1 = cb7.end();
 380     it2 = cb7.begin();
 381     it3 = cb7.begin() + 6;
 382     cb7.set_capacity(10);
 383     BOOST_TEST(it1.is_valid(&cb7));
 384     BOOST_TEST(!it2.is_valid(&cb7));
 385     BOOST_TEST(!it3.is_valid(&cb7));
 386
 387     cb7.push_back(8);
 388     cb7.push_back(9);
 389     it1 = cb7.end();
 390     it2 = cb7.begin();
 391     it3 = cb7.begin() + 6;
 392     cb7.rset_capacity(10);
 393     BOOST_TEST(it1.is_valid(&cb7));
 394     BOOST_TEST(it2.is_valid(&cb7));
 395     BOOST_TEST(it3.is_valid(&cb7));
 396     cb7.rset_capacity(20);
 397     BOOST_TEST(it1.is_valid(&cb7));
 398     BOOST_TEST(!it2.is_valid(&cb7));
 399     BOOST_TEST(!it3.is_valid(&cb7));
 400     cb7.push_back(10);
 401     it1 = cb7.end();
 402     it2 = cb7.begin();
 403     it3 = cb7.begin() + 6;
 404     cb7.rset_capacity(10);
 405     BOOST_TEST(it1.is_valid(&cb7));
 406     BOOST_TEST(!it2.is_valid(&cb7));
 407     BOOST_TEST(!it3.is_valid(&cb7));
 408
 409     circular_buffer<MyInteger> cb8(10, 1);
 410     cb8.push_back(2);
 411     cb8.push_back(3);
 412     it1 = cb8.end();
 413     it2 = cb8.begin();
 414     it3 = cb8.begin() + 6;
 415     cb8.resize(10);
 416     BOOST_TEST(it1.is_valid(&cb8));
 417     BOOST_TEST(it2.is_valid(&cb8));
 418     BOOST_TEST(it3.is_valid(&cb8));
 419     cb8.resize(20);
 420     BOOST_TEST(it1.is_valid(&cb8));
 421     BOOST_TEST(!it2.is_valid(&cb8));
 422     BOOST_TEST(!it3.is_valid(&cb8));
 423     cb8.push_back(4);
 424     it1 = cb8.end();
 425     it2 = cb8.begin();
 426     it3 = cb8.begin() + 6;
 427     it4 = cb8.begin() + 12;
 428     cb8.resize(10);
 429     BOOST_TEST(it1.is_valid(&cb8));
 430     BOOST_TEST(it2.is_valid(&cb8));
 431     BOOST_TEST(it3.is_valid(&cb8));
 432     BOOST_TEST(!it4.is_valid(&cb8));
 433
 434     cb8.set_capacity(10);
 435     cb8.push_back(5);
 436     cb8.push_back(6);
 437     it1 = cb8.end();
 438     it2 = cb8.begin();
 439     it3 = cb8.begin() + 6;
 440     cb8.rresize(10);
 441     BOOST_TEST(it1.is_valid(&cb8));
 442     BOOST_TEST(it2.is_valid(&cb8));
 443     BOOST_TEST(it3.is_valid(&cb8));
 444     cb8.rresize(20);
 445     BOOST_TEST(it1.is_valid(&cb8));
 446     BOOST_TEST(!it2.is_valid(&cb8));
 447     BOOST_TEST(!it3.is_valid(&cb8));
 448     cb8.push_back(7);
 449     it1 = cb8.end();
 450     it2 = cb8.begin();
 451     it3 = cb8.begin() + 6;
 452     it4 = cb8.begin() + 12;
 453     cb8.rresize(10);
 454     BOOST_TEST(it1.is_valid(&cb8));
 455     BOOST_TEST(!it2.is_valid(&cb8));
 456     BOOST_TEST(!it3.is_valid(&cb8));
 457     BOOST_TEST(it4.is_valid(&cb8));
 458
 459     circular_buffer<MyInteger> cb9(15, 1);
 460     it1 = cb9.end();
 461     it2 = cb9.begin();
 462     it3 = cb9.begin() + 6;
 463     it4 = cb9.begin() + 12;
 464     cb9 = cb8;
 465     BOOST_TEST(it1.is_valid(&cb9));
 466     BOOST_TEST(!it2.is_valid(&cb9));
 467     BOOST_TEST(!it3.is_valid(&cb9));
 468     BOOST_TEST(!it4.is_valid(&cb9));
 469
 470     circular_buffer<MyInteger> cb10(10, 1);
 471     it1 = cb10.end();
 472     it2 = cb10.begin();
 473     it3 = cb10.begin() + 3;
 474     it4 = cb10.begin() + 7;
 475     cb10.assign(5, 2);
 476     BOOST_TEST(it1.is_valid(&cb10));
 477     BOOST_TEST(!it2.is_valid(&cb10));
 478     BOOST_TEST(!it3.is_valid(&cb10));
 479     BOOST_TEST(!it4.is_valid(&cb10));
 480
 481     circular_buffer<MyInteger> cb11(10, 1);
 482     it1 = cb11.end();
 483     it2 = cb11.begin();
 484     it3 = cb11.begin() + 3;
 485     it4 = cb11.begin() + 7;
 486     cb11.assign(15, 5, 2);
 487     BOOST_TEST(it1.is_valid(&cb11));
 488     BOOST_TEST(!it2.is_valid(&cb11));
 489     BOOST_TEST(!it3.is_valid(&cb11));
 490     BOOST_TEST(!it4.is_valid(&cb11));
 491
 492     circular_buffer<MyInteger> cb12(10, 1);
 493     it1 = cb12.end();
 494     it2 = cb12.begin();
 495     it3 = cb12.begin() + 3;
 496     it4 = cb12.begin() + 7;
 497     cb12.assign(cb11.begin(), cb11.end());
 498     BOOST_TEST(it1.is_valid(&cb12));
 499     BOOST_TEST(!it2.is_valid(&cb12));
 500     BOOST_TEST(!it3.is_valid(&cb12));
 501     BOOST_TEST(!it4.is_valid(&cb12));
 502
 503     circular_buffer<MyInteger> cb13(10, 1);
 504     it1 = cb13.end();
 505     it2 = cb13.begin();
 506     it3 = cb13.begin() + 3;
 507     it4 = cb13.begin() + 7;
 508     cb13.assign(15, cb11.begin(), cb11.end());
 509     BOOST_TEST(it1.is_valid(&cb13));
 510     BOOST_TEST(!it2.is_valid(&cb13));
 511     BOOST_TEST(!it3.is_valid(&cb13));
 512     BOOST_TEST(!it4.is_valid(&cb13));
 513
 514     circular_buffer<MyInteger> cb14(10);
 515     cb14.push_back(1);
 516     cb14.push_back(2);
 517     cb14.push_back(3);
 518     cb14.push_back(4);
 519     cb14.push_back(5);
 520     cb14.push_back(6);
 521     cb14.push_back(7);
 522     it1 = cb14.end();
 523     it2 = cb14.begin() + 2;
 524     it3 = cb14.begin() + 1;
 525     it4 = cb14.begin() + 5;
 526     cb14.rotate(it2);
 527     BOOST_TEST(it1.is_valid(&cb14));
 528     BOOST_TEST(it2.is_valid(&cb14));
 529     BOOST_TEST(!it3.is_valid(&cb14));
 530     BOOST_TEST(it4.is_valid(&cb14));
 531
 532     circular_buffer<MyInteger> cb15(7);
 533     cb15.push_back(1);
 534     cb15.push_back(2);
 535     cb15.push_back(3);
 536     cb15.push_back(4);
 537     cb15.push_back(5);
 538     cb15.push_back(6);
 539     cb15.push_back(7);
 540     cb15.push_back(8);
 541     cb15.push_back(9);
 542     it1 = cb15.end();
 543     it2 = cb15.begin() + 2;
 544     it3 = cb15.begin() + 1;
 545     it4 = cb15.begin() + 5;
 546     cb15.rotate(it3);
 547     BOOST_TEST(it1.is_valid(&cb15));
 548     BOOST_TEST(it2.is_valid(&cb15));
 549     BOOST_TEST(it3.is_valid(&cb15));
 550     BOOST_TEST(it4.is_valid(&cb15));
 551
 552     circular_buffer<MyInteger> cb16(10);
 553     cb16.push_back(1);
 554     cb16.push_back(2);
 555     cb16.push_back(3);
 556     cb16.push_back(4);
 557     cb16.push_back(5);
 558     cb16.push_back(6);
 559     cb16.push_back(7);
 560     it1 = cb16.end();
 561     it2 = cb16.begin() + 6;
 562     it3 = cb16.begin();
 563     it4 = cb16.begin() + 5;
 564     cb16.rotate(it4);
 565     BOOST_TEST(it1.is_valid(&cb16));
 566     BOOST_TEST(!it2.is_valid(&cb16));
 567     BOOST_TEST(it3.is_valid(&cb16));
 568     BOOST_TEST(!it4.is_valid(&cb16));
 569
 570 #endif // #if BOOST_CB_ENABLE_DEBUG
 571 }
 572
 573 // basic exception safety test (it is useful to use any memory-leak detection tool)
 574 void exception_safety_test() {
 575
 576 #if !defined(BOOST_NO_EXCEPTIONS)
 577
 578     circular_buffer<MyInteger> cb1(3, 5);
 579     MyInteger::set_exception_trigger(3);
 580     BOOST_TEST_THROWS(cb1.set_capacity(5), std::exception);
 581     BOOST_TEST(cb1.capacity() == 3);
 582     MyInteger::set_exception_trigger(3);
 583     BOOST_TEST_THROWS(cb1.rset_capacity(5), std::exception);
 584     BOOST_TEST(cb1.capacity() == 3);
 585     generic_test(cb1);
 586
 587     MyInteger::set_exception_trigger(3);
 588     BOOST_TEST_THROWS(circular_buffer<MyInteger> cb2(5, 10), std::exception);
 589
 590     circular_buffer<MyInteger> cb3(5, 10);
 591     MyInteger::set_exception_trigger(3);
 592     BOOST_TEST_THROWS(circular_buffer<MyInteger> cb4(cb3), std::exception);
 593
 594     vector<MyInteger> v(5, MyInteger(10));
 595     MyInteger::set_exception_trigger(3);
 596     BOOST_TEST_THROWS(circular_buffer<MyInteger> cb5(8, v.begin(), v.end()), std::exception);
 597
 598     circular_buffer<MyInteger> cb6(5, 10);
 599     circular_buffer<MyInteger> cb7(8, 3);
 600     MyInteger::set_exception_trigger(3);
 601     BOOST_TEST_THROWS(cb7 = cb6, std::exception);
 602     BOOST_TEST(cb7.size() == 8);
 603     BOOST_TEST(cb7.capacity() == 8);
 604     BOOST_TEST(cb7[0] == 3);
 605     BOOST_TEST(cb7[7] == 3);
 606     generic_test(cb7);
 607
 608     circular_buffer<MyInteger> cb8(5, 10);
 609     MyInteger::set_exception_trigger(2);
 610     BOOST_TEST_THROWS(cb8.push_front(1), std::exception);
 611
 612     circular_buffer<MyInteger> cb9(5);
 613     cb9.push_back(1);
 614     cb9.push_back(2);
 615     cb9.push_back(3);
 616     MyInteger::set_exception_trigger(3);
 617     BOOST_TEST_THROWS(cb9.insert(cb9.begin() + 1, 4), std::exception);
 618
 619     circular_buffer<MyInteger> cb10(5);
 620     cb10.push_back(1);
 621     cb10.push_back(2);
 622     cb10.push_back(3);
 623     MyInteger::set_exception_trigger(3);
 624     BOOST_TEST_THROWS(cb10.rinsert(cb10.begin() + 1, 4), std::exception);
 625
 626     circular_buffer<MyInteger> cb11(5);
 627     cb11.push_back(1);
 628     cb11.push_back(2);
 629     MyInteger::set_exception_trigger(2);
 630     BOOST_TEST_THROWS(cb11.rinsert(cb11.begin(), 1), std::exception);
 631
 632     circular_buffer<MyInteger> cb12(5, 1);
 633     MyInteger::set_exception_trigger(3);
 634     BOOST_TEST_THROWS(cb12.assign(4, 2), std::exception);
 635
 636     circular_buffer<MyInteger> cb13(5, 1);
 637     MyInteger::set_exception_trigger(3);
 638     BOOST_TEST_THROWS(cb13.assign(6, 2), std::exception);
 639
 640     circular_buffer<MyInteger> cb14(5);
 641     cb14.push_back(1);
 642     cb14.push_back(2);
 643     MyInteger::set_exception_trigger(3);
 644     BOOST_TEST_THROWS(cb14.insert(cb14.begin(), 10, 3), std::exception);
 645
 646     circular_buffer<MyInteger> cb15(5);
 647     cb15.push_back(1);
 648     cb15.push_back(2);
 649     MyInteger::set_exception_trigger(3);
 650     BOOST_TEST_THROWS(cb15.insert(cb15.end(), 10, 3), std::exception);
 651
 652     circular_buffer<MyInteger> cb16(5);
 653     cb16.push_back(1);
 654     cb16.push_back(2);
 655     MyInteger::set_exception_trigger(3);
 656     BOOST_TEST_THROWS(cb16.rinsert(cb16.begin(), 10, 3), std::exception);
 657
 658     circular_buffer<MyInteger> cb17(5);
 659     cb17.push_back(1);
 660     cb17.push_back(2);
 661     MyInteger::set_exception_trigger(3);
 662     BOOST_TEST_THROWS(cb17.rinsert(cb17.end(), 10, 3), std::exception);
 663
 664     circular_buffer<MyInteger> cb18(5, 0);
 665     cb18.push_back(1);
 666     cb18.push_back(2);
 667     cb18.pop_front();
 668     MyInteger::set_exception_trigger(4);
 669     BOOST_TEST_THROWS(cb18.linearize(), std::exception);
 670
 671     circular_buffer<MyInteger> cb19(5, 0);
 672     cb19.push_back(1);
 673     cb19.push_back(2);
 674     MyInteger::set_exception_trigger(5);
 675     BOOST_TEST_THROWS(cb19.linearize(), std::exception);
 676
 677     circular_buffer<MyInteger> cb20(5, 0);
 678     cb20.push_back(1);
 679     cb20.push_back(2);
 680     MyInteger::set_exception_trigger(6);
 681     BOOST_TEST_THROWS(cb20.linearize(), std::exception);
 682
 683     circular_buffer<MyInteger> cb21(5);
 684     cb21.push_back(1);
 685     cb21.push_back(2);
 686     cb21.push_back(3);
 687     MyInteger::set_exception_trigger(2);
 688     BOOST_TEST_THROWS(cb21.insert(cb21.begin() + 1, 4), std::exception);
 689
 690     circular_buffer<MyInteger> cb22(5);
 691     cb22.push_back(1);
 692     cb22.push_back(2);
 693     cb22.push_back(3);
 694     MyInteger::set_exception_trigger(2);
 695     BOOST_TEST_THROWS(cb22.insert(cb22.end(), 4), std::exception);
 696
 697     circular_buffer<MyInteger> cb23(5, 0);
 698     MyInteger::set_exception_trigger(2);
 699     BOOST_TEST_THROWS(cb23.insert(cb23.begin() + 1, 4), std::exception);
 700
 701     circular_buffer<MyInteger> cb24(5);
 702     cb24.push_back(1);
 703     cb24.push_back(2);
 704     cb24.push_back(3);
 705     MyInteger::set_exception_trigger(2);
 706     BOOST_TEST_THROWS(cb24.rinsert(cb24.begin() + 1, 4), std::exception);
 707
 708     circular_buffer<MyInteger> cb25(5, 0);
 709     MyInteger::set_exception_trigger(2);
 710     BOOST_TEST_THROWS(cb25.rinsert(cb25.begin() + 3, 4), std::exception);
 711
 712     circular_buffer<MyInteger> cb26(5);
 713     cb26.push_back(1);
 714     cb26.push_back(2);
 715     MyInteger::set_exception_trigger(5);
 716     BOOST_TEST_THROWS(cb26.insert(cb26.begin(), 10, 3), std::exception);
 717
 718     circular_buffer<MyInteger> cb27(5);
 719     cb27.push_back(1);
 720     cb27.push_back(2);
 721     MyInteger::set_exception_trigger(5);
 722     BOOST_TEST_THROWS(cb27.insert(cb27.end(), 10, 3), std::exception);
 723
 724     circular_buffer<MyInteger> cb28(5);
 725     cb28.push_back(1);
 726     cb28.push_back(2);
 727     MyInteger::set_exception_trigger(5);
 728     BOOST_TEST_THROWS(cb28.rinsert(cb28.begin(), 10, 3), std::exception);
 729
 730     circular_buffer<MyInteger> cb29(5);
 731     cb29.push_back(1);
 732     cb29.push_back(2);
 733     MyInteger::set_exception_trigger(5);
 734     BOOST_TEST_THROWS(cb29.rinsert(cb29.end(), 10, 3), std::exception);
 735
 736     circular_buffer<MyInteger> cb30(10);
 737     cb30.push_back(1);
 738     cb30.push_back(2);
 739     cb30.push_back(3);
 740     MyInteger::set_exception_trigger(2);
 741     BOOST_TEST_THROWS(cb30.rinsert(cb30.begin(), 10, 3), std::exception);
 742
 743 #endif // #if !defined(BOOST_NO_EXCEPTIONS)
 744 }
 745
 746
 747 void move_container_values_except() {
 748     move_container_values_impl<noncopyable_movable_except_t>();
 749 }
 750
 751 template <class T>
 752 void move_container_values_resetting_impl() {
 753     typedef T noncopyable_movable_test_t;
 754     CB_CONTAINER<noncopyable_movable_test_t> cb1(1);
 755     noncopyable_movable_test_t var;
 756     cb1.push_back();
 757
 758     cb1.push_back(boost::move(var));
 759     BOOST_TEST(!cb1.back().is_moved());
 760     BOOST_TEST(var.is_moved());
 761     BOOST_TEST(cb1.size() == 1);
 762     var = boost::move(cb1.back());
 763     BOOST_TEST(cb1.back().is_moved());
 764
 765     cb1.push_front(boost::move(var));
 766     BOOST_TEST(!cb1.front().is_moved());
 767     BOOST_TEST(var.is_moved());
 768     BOOST_TEST(cb1.size() == 1);
 769     var = boost::move(cb1.back());
 770     BOOST_TEST(cb1.back().is_moved());
 771
 772     cb1.push_back();
 773     BOOST_TEST(!cb1.back().is_moved());
 774     BOOST_TEST(cb1.size() == 1);
 775     var = boost::move(cb1.back());
 776     BOOST_TEST(cb1.back().is_moved());
 777
 778     cb1.push_front();
 779     BOOST_TEST(!cb1.front().is_moved());
 780     BOOST_TEST(cb1.size() == 1);
 781     var = boost::move(cb1.back());
 782     BOOST_TEST(cb1.back().is_moved());
 783
 784
 785     cb1.insert(cb1.begin());
 786     // If the circular_buffer is full and the pos points to begin(),
 787     // then the item will not be inserted.
 788     BOOST_TEST(cb1.front().is_moved());
 789     BOOST_TEST(cb1.size() == 1);
 790     var = boost::move(cb1.back());
 791     BOOST_TEST(cb1.back().is_moved());
 792
 793     cb1.insert(cb1.begin(), boost::move(var));
 794     // If the circular_buffer is full and the pos points to begin(),
 795     // then the item will not be inserted.
 796     BOOST_TEST(cb1.front().is_moved());
 797     BOOST_TEST(cb1.size() == 1);
 798     var = boost::move(cb1.back());
 799     BOOST_TEST(cb1.back().is_moved());
 800
 801     cb1.rinsert(cb1.begin());
 802     BOOST_TEST(!cb1.back().is_moved());
 803     BOOST_TEST(cb1.size() == 1);
 804     var = boost::move(cb1.back());
 805     BOOST_TEST(cb1.back().is_moved());
 806
 807     var.reinit();
 808     cb1.rinsert(cb1.begin(), boost::move(var));
 809     BOOST_TEST(!cb1.back().is_moved());
 810     BOOST_TEST(cb1.size() == 1);
 811     var = boost::move(cb1.back());
 812     BOOST_TEST(cb1.back().is_moved());
 813
 814     cb1.rinsert(cb1.end());
 815     BOOST_TEST(cb1.back().is_moved());
 816     BOOST_TEST(cb1.size() == 1);
 817     var = boost::move(cb1.back());
 818     BOOST_TEST(cb1.back().is_moved());
 819
 820     var.reinit();
 821     cb1.rinsert(cb1.end(), boost::move(var));
 822     BOOST_TEST(cb1.back().is_moved());
 823     BOOST_TEST(cb1.size() == 1);
 824     var = boost::move(cb1.back());
 825     BOOST_TEST(cb1.back().is_moved());
 826     cb1.push_back();
 827     BOOST_TEST(!cb1[0].is_moved());
 828
 829     const int val = cb1[0].value();
 830     cb1.linearize();
 831     BOOST_TEST(!cb1[0].is_moved());
 832     BOOST_TEST(cb1[0].value() == val);
 833
 834     cb1.rotate(cb1.begin());
 835     BOOST_TEST(!cb1[0].is_moved());
 836     BOOST_TEST(cb1[0].value() == val);
 837 }
 838
 839 void move_container_values_resetting_except() {
 840     move_container_values_resetting_impl<noncopyable_movable_except_t>();
 841 }
 842
 843 void move_container_values_resetting_noexcept() {
 844     move_container_values_resetting_impl<noncopyable_movable_noexcept_t>();
 845 }
 846
 847 // test main
 848 int main()
 849 {
 850     run_common_tests();
 851     iterator_constructor_and_assign_test();
 852     iterator_reference_test();
 853     iterator_difference_test();
 854     iterator_increment_test();
 855     iterator_decrement_test();
 856     iterator_addition_test();
 857     iterator_subtraction_test();
 858     iterator_element_access_test();
 859     iterator_comparison_test();
 860     iterator_invalidation_test();
 861     exception_safety_test();
 862     move_container_values_except();
 863     move_container_values_resetting_except();
 864     move_container_values_resetting_noexcept();
 865     return boost::report_errors();
 866 }