libs/container/test/static_vector_test.cpp

   1 // Boost.Container static_vector
   2 // Unit Test
   3
   4 // Copyright (c) 2012-2013 Adam Wulkiewicz, Lodz, Poland.
   5 // Copyright (c) 2012-2013 Andrew Hundt.
   6
   7 // Use, modification and distribution is subject to the Boost Software License,
   8 // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   9 // http://www.boost.org/LICENSE_1_0.txt)
  10 #include <boost/container/detail/config_begin.hpp>
  11 #include <boost/core/lightweight_test.hpp>
  12 #include <boost/core/no_exceptions_support.hpp>
  13
  14 #include <vector>
  15 #include <list>
  16
  17 #include <boost/container/vector.hpp>
  18 #include <boost/container/stable_vector.hpp>
  19
  20 #include "static_vector_test.hpp"
  21
  22 namespace boost {
  23 namespace container {
  24
  25 //Explicit instantiation to detect compilation errors
  26 template class boost::container::static_vector<int, 10>;
  27
  28 }}
  29
  30
  31 template <typename T, size_t N>
  32 void test_ctor_ndc()
  33 {
  34    static_vector<T, N> s;
  35    BOOST_TEST_EQ(s.size() , 0u);
  36    BOOST_TEST(s.capacity() == N);
  37    BOOST_TEST_THROWS( s.at(0u), std::out_of_range );
  38 }
  39
  40 template <typename T, size_t N>
  41 void test_ctor_nc(size_t n)
  42 {
  43    static_vector<T, N> s(n);
  44    BOOST_TEST(s.size() == n);
  45    BOOST_TEST(s.capacity() == N);
  46    BOOST_TEST_THROWS( s.at(n), std::out_of_range );
  47    if ( 1 < n )
  48    {
  49       T val10(10);
  50       s[0] = val10;
  51       BOOST_TEST(T(10) == s[0]);
  52       BOOST_TEST(T(10) == s.at(0));
  53       T val20(20);
  54       s.at(1) = val20;
  55       BOOST_TEST(T(20) == s[1]);
  56       BOOST_TEST(T(20) == s.at(1));
  57    }
  58 }
  59
  60 template <typename T, size_t N>
  61 void test_ctor_nd(size_t n, T const& v)
  62 {
  63    static_vector<T, N> s(n, v);
  64    BOOST_TEST(s.size() == n);
  65    BOOST_TEST(s.capacity() == N);
  66    BOOST_TEST_THROWS( s.at(n), std::out_of_range );
  67    if ( 1 < n )
  68    {
  69       BOOST_TEST(v == s[0]);
  70       BOOST_TEST(v == s.at(0));
  71       BOOST_TEST(v == s[1]);
  72       BOOST_TEST(v == s.at(1));
  73       s[0] = T(10);
  74       BOOST_TEST(T(10) == s[0]);
  75       BOOST_TEST(T(10) == s.at(0));
  76       s.at(1) = T(20);
  77       BOOST_TEST(T(20) == s[1]);
  78       BOOST_TEST(T(20) == s.at(1));
  79    }
  80 }
  81
  82 void test_support_for_initializer_list()
  83 {
  84 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
  85    {
  86       static_vector<int, 2> sv = {10, 8};
  87       BOOST_TEST(10 == sv[0]);
  88       BOOST_TEST(8 == sv[1]);
  89
  90       typedef static_vector<int, 1> sv_cap_1;
  91       BOOST_TEST_THROWS(sv_cap_1({1, 1}), std::bad_alloc);
  92    }
  93
  94    {
  95       static_vector<int, 2> sv;
  96       sv.assign({1, 2});
  97       BOOST_TEST(1 == sv[0]);
  98       BOOST_TEST(2 == sv[1]);
  99
 100       BOOST_TEST_THROWS(sv.assign({1, 2, 3}), std::bad_alloc);
 101
 102       static_vector<int, 3> greaterThanSv = {1, 2, 3};
 103       BOOST_TEST_THROWS(sv = greaterThanSv, std::bad_alloc);
 104    }
 105
 106    {
 107       static_vector<int, 2> sv;
 108       sv.insert(sv.begin(), {99, 95});
 109       BOOST_TEST(99 == sv[0]);
 110       BOOST_TEST(95 == sv[1]);
 111
 112       BOOST_TEST_THROWS(sv.insert(sv.begin(), {101, 102, 103}), std::bad_alloc);
 113    }
 114 #endif
 115 }
 116
 117 template <typename T, size_t N>
 118 void test_resize_nc(size_t n)
 119 {
 120    static_vector<T, N> s;
 121
 122    s.resize(n);
 123    BOOST_TEST(s.size() == n);
 124    BOOST_TEST(s.capacity() == N);
 125    BOOST_TEST_THROWS( s.at(n), std::out_of_range );
 126    if ( 1 < n )
 127    {
 128       T val10(10);
 129       s[0] = val10;
 130       BOOST_TEST(T(10) == s[0]);
 131       BOOST_TEST(T(10) == s.at(0));
 132       T val20(20);
 133       s.at(1) = val20;
 134       BOOST_TEST(T(20) == s[1]);
 135       BOOST_TEST(T(20) == s.at(1));
 136    }
 137 }
 138
 139 template <typename T, size_t N>
 140 void test_resize_nd(size_t n, T const& v)
 141 {
 142    static_vector<T, N> s;
 143
 144    s.resize(n, v);
 145    BOOST_TEST(s.size() == n);
 146    BOOST_TEST(s.capacity() == N);
 147    BOOST_TEST_THROWS( s.at(n), std::out_of_range );
 148    if ( 1 < n )
 149    {
 150       BOOST_TEST(v == s[0]);
 151       BOOST_TEST(v == s.at(0));
 152       BOOST_TEST(v == s[1]);
 153       BOOST_TEST(v == s.at(1));
 154       s[0] = T(10);
 155       BOOST_TEST(T(10) == s[0]);
 156       BOOST_TEST(T(10) == s.at(0));
 157       s.at(1) = T(20);
 158       BOOST_TEST(T(20) == s[1]);
 159       BOOST_TEST(T(20) == s.at(1));
 160    }
 161 }
 162
 163 template <typename T, size_t N>
 164 void test_push_back_nd()
 165 {
 166    static_vector<T, N> s;
 167
 168    BOOST_TEST(s.size() == 0);
 169    BOOST_TEST_THROWS( s.at(0), std::out_of_range );
 170
 171    for ( size_t i = 0 ; i < N ; ++i )
 172    {
 173       T t(i);
 174       s.push_back(t);
 175       BOOST_TEST(s.size() == i + 1);
 176       BOOST_TEST_THROWS( s.at(i + 1), std::out_of_range );
 177       BOOST_TEST(T(i) == s.at(i));
 178       BOOST_TEST(T(i) == s[i]);
 179       BOOST_TEST(T(i) == s.back());
 180       BOOST_TEST(T(0) == s.front());
 181       BOOST_TEST(T(i) == *(s.data() + i));
 182    }
 183 }
 184
 185 template <typename T, size_t N>
 186 void test_pop_back_nd()
 187 {
 188    static_vector<T, N> s;
 189
 190    for ( size_t i = 0 ; i < N ; ++i )
 191    {
 192       T t(i);
 193       s.push_back(t);
 194    }
 195
 196    for ( size_t i = N ; i > 1 ; --i )
 197    {
 198       s.pop_back();
 199       BOOST_TEST(s.size() == i - 1);
 200       BOOST_TEST_THROWS( s.at(i - 1), std::out_of_range );
 201       BOOST_TEST(T(i - 2) == s.at(i - 2));
 202       BOOST_TEST(T(i - 2) == s[i - 2]);
 203       BOOST_TEST(T(i - 2) == s.back());
 204       BOOST_TEST(T(0) == s.front());
 205    }
 206 }
 207
 208 template <typename It1, typename It2>
 209 void test_compare_ranges(It1 first1, It1 last1, It2 first2, It2 last2)
 210 {
 211    BOOST_TEST(std::distance(first1, last1) == std::distance(first2, last2));
 212    for ( ; first1 != last1 && first2 != last2 ; ++first1, ++first2 )
 213       BOOST_TEST(*first1 == *first2);
 214 }
 215
 216 template <typename T, size_t N, typename C>
 217 void test_copy_and_assign(C const& c)
 218 {
 219    {
 220       static_vector<T, N> s(c.begin(), c.end());
 221       BOOST_TEST(s.size() == c.size());
 222       test_compare_ranges(s.begin(), s.end(), c.begin(), c.end());
 223    }
 224    {
 225       static_vector<T, N> s;
 226       BOOST_TEST(0 == s.size());
 227       s.assign(c.begin(), c.end());
 228       BOOST_TEST(s.size() == c.size());
 229       test_compare_ranges(s.begin(), s.end(), c.begin(), c.end());
 230    }
 231 }
 232
 233 template <typename T, size_t N>
 234 void test_copy_and_assign_nd(T const& val)
 235 {
 236    static_vector<T, N> s;
 237    std::vector<T> v;
 238    std::list<T> l;
 239
 240    for ( size_t i = 0 ; i < N ; ++i )
 241    {
 242       T t(i);
 243       s.push_back(t);
 244       v.push_back(t);
 245       l.push_back(t);
 246    }
 247    // copy ctor
 248    {
 249       static_vector<T, N> s1(s);
 250       BOOST_TEST(s.size() == s1.size());
 251       test_compare_ranges(s.begin(), s.end(), s1.begin(), s1.end());
 252    }
 253    // copy assignment
 254    {
 255       static_vector<T, N> s1;
 256       BOOST_TEST(0 == s1.size());
 257       s1 = s;
 258       BOOST_TEST(s.size() == s1.size());
 259       test_compare_ranges(s.begin(), s.end(), s1.begin(), s1.end());
 260    }
 261
 262    // ctor(Iter, Iter) and assign(Iter, Iter)
 263    test_copy_and_assign<T, N>(s);
 264    test_copy_and_assign<T, N>(v);
 265    test_copy_and_assign<T, N>(l);
 266
 267    // assign(N, V)
 268    {
 269       static_vector<T, N> s1(s);
 270       test_compare_ranges(s.begin(), s.end(), s1.begin(), s1.end());
 271       std::vector<T> a(N, val);
 272       s1.assign(N, val);
 273       test_compare_ranges(a.begin(), a.end(), s1.begin(), s1.end());
 274    }
 275
 276    stable_vector<T> bsv(s.begin(), s.end());
 277    vector<T> bv(s.begin(), s.end());
 278    test_copy_and_assign<T, N>(bsv);
 279    test_copy_and_assign<T, N>(bv);
 280 }
 281
 282 template <typename T, size_t N>
 283 void test_iterators_nd()
 284 {
 285    static_vector<T, N> s;
 286    std::vector<T> v;
 287
 288    for ( size_t i = 0 ; i < N ; ++i )
 289    {
 290       s.push_back(T(i));
 291       v.push_back(T(i));
 292    }
 293
 294    test_compare_ranges(s.begin(), s.end(), v.begin(), v.end());
 295    test_compare_ranges(s.rbegin(), s.rend(), v.rbegin(), v.rend());
 296
 297    s.assign(v.rbegin(), v.rend());
 298
 299    test_compare_ranges(s.begin(), s.end(), v.rbegin(), v.rend());
 300    test_compare_ranges(s.rbegin(), s.rend(), v.begin(), v.end());
 301 }
 302
 303 template <typename T, size_t N>
 304 void test_erase_nd()
 305 {
 306    static_vector<T, N> s;
 307    typedef typename static_vector<T, N>::iterator It;
 308
 309    for ( size_t i = 0 ; i < N ; ++i )
 310       s.push_back(T(i));
 311
 312    // erase(pos)
 313    {
 314       for ( size_t i = 0 ; i < N ; ++i )
 315       {
 316           static_vector<T, N> s1(s);
 317           It it = s1.erase(s1.begin() + i);
 318           BOOST_TEST(s1.begin() + i == it);
 319           BOOST_TEST(s1.size() == N - 1);
 320           for ( size_t j = 0 ; j < i ; ++j )
 321               BOOST_TEST(s1[j] == T(j));
 322           for ( size_t j = i+1 ; j < N ; ++j )
 323               BOOST_TEST(s1[j-1] == T(j));
 324       }
 325    }
 326    // erase(first, last)
 327    {
 328       size_t n = N/3;
 329       for ( size_t i = 0 ; i <= N ; ++i )
 330       {
 331           static_vector<T, N> s1(s);
 332           size_t removed = i + n < N ? n : N - i;
 333           It it = s1.erase(s1.begin() + i, s1.begin() + i + removed);
 334           BOOST_TEST(s1.begin() + i == it);
 335           BOOST_TEST(s1.size() == N - removed);
 336           for ( size_t j = 0 ; j < i ; ++j )
 337               BOOST_TEST(s1[j] == T(j));
 338           for ( size_t j = i+n ; j < N ; ++j )
 339               BOOST_TEST(s1[j-n] == T(j));
 340       }
 341    }
 342 }
 343
 344 template <typename T, size_t N, typename SV, typename C>
 345 void test_insert(SV const& s, C const& c)
 346 {
 347    size_t h = N/2;
 348    size_t n = size_t(h/1.5f);
 349
 350    for ( size_t i = 0 ; i <= h ; ++i )
 351    {
 352       static_vector<T, N> s1(s);
 353
 354       typename C::const_iterator it = c.begin();
 355       std::advance(it, n);
 356       typename static_vector<T, N>::iterator
 357           it1 = s1.insert(s1.begin() + i, c.begin(), it);
 358
 359       BOOST_TEST(s1.begin() + i == it1);
 360       BOOST_TEST(s1.size() == h+n);
 361       for ( size_t j = 0 ; j < i ; ++j )
 362           BOOST_TEST(s1[j] == T(j));
 363       for ( size_t j = 0 ; j < n ; ++j )
 364           BOOST_TEST(s1[j+i] == T(100 + j));
 365       for ( size_t j = 0 ; j < h-i ; ++j )
 366           BOOST_TEST(s1[j+i+n] == T(j+i));
 367    }
 368 }
 369
 370 template <typename T, size_t N>
 371 void test_insert_nd(T const& val)
 372 {
 373    size_t h = N/2;
 374
 375    static_vector<T, N> s, ss;
 376    std::vector<T> v;
 377    std::list<T> l;
 378
 379    typedef typename static_vector<T, N>::iterator It;
 380
 381    for ( size_t i = 0 ; i < h ; ++i )
 382    {
 383       s.push_back(T(i));
 384       ss.push_back(T(100 + i));
 385       v.push_back(T(100 + i));
 386       l.push_back(T(100 + i));
 387    }
 388
 389    // insert(pos, val)
 390    {
 391       for ( size_t i = 0 ; i <= h ; ++i )
 392       {
 393           static_vector<T, N> s1(s);
 394           It it = s1.insert(s1.begin() + i, val);
 395           BOOST_TEST(s1.begin() + i == it);
 396           BOOST_TEST(s1.size() == h+1);
 397           for ( size_t j = 0 ; j < i ; ++j )
 398               BOOST_TEST(s1[j] == T(j));
 399           BOOST_TEST(s1[i] == val);
 400           for ( size_t j = 0 ; j < h-i ; ++j )
 401               BOOST_TEST(s1[j+i+1] == T(j+i));
 402       }
 403    }
 404    // insert(pos, n, val)
 405    {
 406       size_t n = size_t(h/1.5f);
 407       for ( size_t i = 0 ; i <= h ; ++i )
 408       {
 409           static_vector<T, N> s1(s);
 410           It it = s1.insert(s1.begin() + i, n, val);
 411           BOOST_TEST(s1.begin() + i == it);
 412           BOOST_TEST(s1.size() == h+n);
 413           for ( size_t j = 0 ; j < i ; ++j )
 414               BOOST_TEST(s1[j] == T(j));
 415           for ( size_t j = 0 ; j < n ; ++j )
 416               BOOST_TEST(s1[j+i] == val);
 417           for ( size_t j = 0 ; j < h-i ; ++j )
 418               BOOST_TEST(s1[j+i+n] == T(j+i));
 419       }
 420    }
 421    // insert(pos, first, last)
 422    test_insert<T, N>(s, ss);
 423    test_insert<T, N>(s, v);
 424    test_insert<T, N>(s, l);
 425
 426    stable_vector<T> bsv(ss.begin(), ss.end());
 427    vector<T> bv(ss.begin(), ss.end());
 428    test_insert<T, N>(s, bv);
 429    test_insert<T, N>(s, bsv);
 430 }
 431
 432 template <typename T>
 433 void test_capacity_0_nd()
 434 {
 435    static_vector<T, 10> v(5u, T(0));
 436
 437    static_vector<T, 0 > s;
 438    BOOST_TEST(s.size() == 0);
 439    BOOST_TEST(s.capacity() == 0);
 440    BOOST_TEST_THROWS(s.at(0), std::out_of_range);
 441    BOOST_TEST_THROWS(s.resize(5u, T(0)), std::bad_alloc);
 442    BOOST_TEST_THROWS(s.push_back(T(0)), std::bad_alloc);
 443    BOOST_TEST_THROWS(s.insert(s.end(), T(0)), std::bad_alloc);
 444    BOOST_TEST_THROWS(s.insert(s.end(), 5u, T(0)), std::bad_alloc);
 445    BOOST_TEST_THROWS(s.insert(s.end(), v.begin(), v.end()), std::bad_alloc);
 446    BOOST_TEST_THROWS(s.assign(v.begin(), v.end()), std::bad_alloc);
 447    BOOST_TEST_THROWS(s.assign(5u, T(0)), std::bad_alloc);
 448    BOOST_TEST_THROWS(s.assign(5u, T(0)), std::bad_alloc);
 449    typedef static_vector<T, 0> static_vector_0_t;
 450    BOOST_TEST_THROWS(static_vector_0_t s2(v.begin(), v.end()), std::bad_alloc);
 451    BOOST_TEST_THROWS(static_vector_0_t s1(5u, T(0)), std::bad_alloc);
 452 }
 453
 454 template <typename T, size_t N>
 455 void test_exceptions_nd()
 456 {
 457    static_vector<T, N> v(N, T(0));
 458    static_vector<T, N/2> s(N/2, T(0));
 459
 460    BOOST_TEST_THROWS(s.resize(N, T(0)), std::bad_alloc);
 461    BOOST_TEST_THROWS(s.push_back(T(0)), std::bad_alloc);
 462    BOOST_TEST_THROWS(s.insert(s.end(), T(0)), std::bad_alloc);
 463    BOOST_TEST_THROWS(s.insert(s.end(), N, T(0)), std::bad_alloc);
 464    BOOST_TEST_THROWS(s.insert(s.end(), v.begin(), v.end()), std::bad_alloc);
 465    BOOST_TEST_THROWS(s.assign(v.begin(), v.end()), std::bad_alloc);
 466    BOOST_TEST_THROWS(s.assign(N, T(0)), std::bad_alloc);
 467    typedef static_vector<T, N/2> static_vector_n_half_t;
 468    BOOST_TEST_THROWS(static_vector_n_half_t s2(v.begin(), v.end()), std::bad_alloc);
 469    BOOST_TEST_THROWS(static_vector_n_half_t s1(N, T(0)), std::bad_alloc);
 470 }
 471
 472 template <typename T, size_t N>
 473 void test_swap_and_move_nd()
 474 {
 475    {
 476       static_vector<T, N> v1, v2, v3, v4;
 477       static_vector<T, N> s1, s2;
 478       static_vector<T, N> s4;
 479
 480       for (size_t i = 0 ; i < N ; ++i )
 481       {
 482           v1.push_back(T(i));
 483           v2.push_back(T(i));
 484           v3.push_back(T(i));
 485           v4.push_back(T(i));
 486       }
 487       for (size_t i = 0 ; i < N/2 ; ++i )
 488       {
 489           s1.push_back(T(100 + i));
 490           s2.push_back(T(100 + i));
 491           s4.push_back(T(100 + i));
 492       }
 493
 494       s1.swap(v1);
 495       s2 = boost::move(v2);
 496       static_vector<T, N> s3(boost::move(v3));
 497       s4.swap(v4);
 498
 499       BOOST_TEST(v1.size() == N/2);
 500       BOOST_TEST(s1.size() == N);
 501       //iG moving does not imply emptying source
 502       //BOOST_TEST(v2.size() == 0);
 503       BOOST_TEST(s2.size() == N);
 504       //iG moving does not imply emptying source
 505       //BOOST_TEST(v3.size() == 0);
 506       BOOST_TEST(s3.size() == N);
 507       BOOST_TEST(v4.size() == N/2);
 508       BOOST_TEST(s4.size() == N);
 509       for (size_t i = 0 ; i < N/2 ; ++i )
 510       {
 511           BOOST_TEST(v1[i] == T(100 + i));
 512           BOOST_TEST(v4[i] == T(100 + i));
 513       }
 514       for (size_t i = 0 ; i < N ; ++i )
 515       {
 516           BOOST_TEST(s1[i] == T(i));
 517           BOOST_TEST(s2[i] == T(i));
 518           BOOST_TEST(s3[i] == T(i));
 519           BOOST_TEST(s4[i] == T(i));
 520       }
 521    }
 522    {
 523       static_vector<T, N> v1, v2, v3;
 524       static_vector<T, N/2> s1, s2, s3;
 525
 526       for (size_t i = 0 ; i < N/2 ; ++i )
 527       {
 528           v1.push_back(T(i));
 529           v2.push_back(T(i));
 530           v3.push_back(T(i));
 531       }
 532       for (size_t i = 0 ; i < N/3 ; ++i )
 533       {
 534           s1.push_back(T(100 + i));
 535           s2.push_back(T(100 + i));
 536       }
 537
 538       s1.swap(v1);
 539       s3 = v2;
 540       s2 = boost::move(v2);
 541       static_vector<T, N/2> s4(boost::move(v3));
 542
 543       BOOST_TEST(v1.size() == N/3);
 544       BOOST_TEST(s1.size() == N/2);
 545       //iG moving does not imply emptying source
 546       //BOOST_TEST(v2.size() == 0);
 547       BOOST_TEST(s2.size() == N/2);
 548       BOOST_TEST(s3.size() == N/2);
 549       //iG moving does not imply emptying source
 550       //BOOST_TEST(v3.size() == 0);
 551       BOOST_TEST(s4.size() == N/2);
 552       for (size_t i = 0 ; i < N/3 ; ++i )
 553           BOOST_TEST(v1[i] == T(100 + i));
 554       for (size_t i = 0 ; i < N/2 ; ++i )
 555       {
 556           BOOST_TEST(s1[i] == T(i));
 557           BOOST_TEST(s2[i] == T(i));
 558           BOOST_TEST(s3[i] == T(i));
 559           BOOST_TEST(s4[i] == T(i));
 560       }
 561    }
 562    {
 563       typedef static_vector<T, N/2> small_vector_t;
 564       static_vector<T, N> v(N, T(0));
 565       small_vector_t s(N/2, T(1));
 566       BOOST_TEST_THROWS(s.swap(v), std::bad_alloc);
 567       v.resize(N, T(0));
 568       BOOST_TEST_THROWS(s = boost::move(v), std::bad_alloc);
 569       BOOST_TEST_THROWS(s = v, std::bad_alloc);
 570       v.resize(N, T(0));
 571       BOOST_TEST_THROWS(small_vector_t s2(boost::move(v)), std::bad_alloc);
 572    }
 573 }
 574
 575 template <typename T, size_t N>
 576 void test_emplace_0p()
 577 {
 578    //emplace_back()
 579    {
 580       static_vector<T, N> v;
 581
 582       for (int i = 0 ; i < int(N) ; ++i )
 583           v.emplace_back();
 584       BOOST_TEST(v.size() == N);
 585       BOOST_TEST_THROWS(v.emplace_back(), std::bad_alloc);
 586    }
 587 }
 588
 589 template <typename T, size_t N>
 590 void test_emplace_2p()
 591 {
 592    //emplace_back(pos, int, int)
 593    {
 594       static_vector<T, N> v;
 595
 596       for (int i = 0 ; i < int(N) ; ++i )
 597           v.emplace_back(i, 100 + i);
 598       BOOST_TEST(v.size() == N);
 599       BOOST_TEST_THROWS(v.emplace_back(N, 100 + N), std::bad_alloc);
 600       BOOST_TEST(v.size() == N);
 601       for (int i = 0 ; i < int(N) ; ++i )
 602           BOOST_TEST(v[i] == T(i, 100 + i));
 603    }
 604
 605    // emplace(pos, int, int)
 606    {
 607       typedef typename static_vector<T, N>::iterator It;
 608
 609       int h = N / 2;
 610
 611       static_vector<T, N> v;
 612       for ( int i = 0 ; i < h ; ++i )
 613           v.emplace_back(i, 100 + i);
 614
 615       for ( int i = 0 ; i <= h ; ++i )
 616       {
 617           static_vector<T, N> vv(v);
 618           It it = vv.emplace(vv.begin() + i, i+100, i+200);
 619           BOOST_TEST(vv.begin() + i == it);
 620           BOOST_TEST(vv.size() == size_t(h+1));
 621           for ( int j = 0 ; j < i ; ++j )
 622               BOOST_TEST(vv[j] == T(j, j+100));
 623           BOOST_TEST(vv[i] == T(i+100, i+200));
 624           for ( int j = 0 ; j < h-i ; ++j )
 625               BOOST_TEST(vv[j+i+1] == T(j+i, j+i+100));
 626       }
 627    }
 628 }
 629
 630 template <typename T, size_t N>
 631 void test_sv_elem(T const& t)
 632 {
 633    typedef static_vector<T, N> V;
 634
 635    static_vector<V, N> v;
 636
 637    v.push_back(V(N/2, t));
 638    V vvv(N/2, t);
 639    v.push_back(boost::move(vvv));
 640    v.insert(v.begin(), V(N/2, t));
 641    v.insert(v.end(), V(N/2, t));
 642    v.emplace_back(N/2, t);
 643 }
 644
 645 bool default_init_test()//Test for default initialization
 646 {
 647    typedef static_vector<int, 100> di_vector_t;
 648
 649    const std::size_t Capacity = 100;
 650
 651    {
 652       di_vector_t v;
 653       int *p = v.data();
 654
 655       for(std::size_t i = 0; i != Capacity; ++i, ++p){
 656          *p = static_cast<int>(i);
 657       }
 658
 659       //Destroy the vector, p stilll pointing to the storage
 660       v.~di_vector_t();
 661
 662       di_vector_t &rv = *::new(&v)di_vector_t(Capacity, default_init);
 663       di_vector_t::iterator it = rv.begin();
 664
 665       for(std::size_t i = 0; i != Capacity; ++i, ++it){
 666          if(*it != static_cast<int>(i))
 667             return false;
 668       }
 669
 670       v.~di_vector_t();
 671    }
 672    {
 673       di_vector_t v;
 674
 675       int *p = v.data();
 676       for(std::size_t i = 0; i != Capacity; ++i, ++p){
 677          *p = static_cast<int>(i+100);
 678       }
 679
 680       v.resize(Capacity, default_init);
 681
 682       di_vector_t::iterator it = v.begin();
 683       for(std::size_t i = 0; i != Capacity; ++i, ++it){
 684          if(*it != static_cast<int>(i+100))
 685             return false;
 686       }
 687    }
 688
 689    return true;
 690 }
 691
 692
 693 int main(int, char* [])
 694 {
 695    using boost::container::test::movable_and_copyable_int;
 696    using boost::container::test::produce_movable_and_copyable_int;
 697    BOOST_TEST(counting_value::count() == 0);
 698
 699    test_ctor_ndc<int, 10>();
 700    test_ctor_ndc<value_ndc, 10>();
 701    test_ctor_ndc<counting_value, 10>();
 702    BOOST_TEST(counting_value::count() == 0);
 703    test_ctor_ndc<shptr_value, 10>();
 704    test_ctor_ndc<movable_and_copyable_int, 10>();
 705
 706    test_ctor_nc<int, 10>(5);
 707    test_ctor_nc<value_nc, 10>(5);
 708    test_ctor_nc<counting_value, 10>(5);
 709    BOOST_TEST(counting_value::count() == 0);
 710    test_ctor_nc<shptr_value, 10>(5);
 711    test_ctor_nc<movable_and_copyable_int, 10>(5);
 712
 713    test_ctor_nd<int, 10>(5, 1);
 714    test_ctor_nd<value_nd, 10>(5, value_nd(1));
 715    test_ctor_nd<counting_value, 10>(5, counting_value(1));
 716    BOOST_TEST(counting_value::count() == 0);
 717    test_ctor_nd<shptr_value, 10>(5, shptr_value(1));
 718    test_ctor_nd<movable_and_copyable_int, 10>(5, produce_movable_and_copyable_int());
 719
 720    test_resize_nc<int, 10>(5);
 721    test_resize_nc<value_nc, 10>(5);
 722    test_resize_nc<counting_value, 10>(5);
 723    BOOST_TEST(counting_value::count() == 0);
 724    test_resize_nc<shptr_value, 10>(5);
 725    test_resize_nc<movable_and_copyable_int, 10>(5);
 726
 727    test_resize_nd<int, 10>(5, 1);
 728    test_resize_nd<value_nd, 10>(5, value_nd(1));
 729    test_resize_nd<counting_value, 10>(5, counting_value(1));
 730    BOOST_TEST(counting_value::count() == 0);
 731    test_resize_nd<shptr_value, 10>(5, shptr_value(1));
 732    test_resize_nd<movable_and_copyable_int, 10>(5, produce_movable_and_copyable_int());
 733
 734    test_push_back_nd<int, 10>();
 735    test_push_back_nd<value_nd, 10>();
 736    test_push_back_nd<counting_value, 10>();
 737    BOOST_TEST(counting_value::count() == 0);
 738    test_push_back_nd<shptr_value, 10>();
 739    test_push_back_nd<movable_and_copyable_int, 10>();
 740
 741    test_pop_back_nd<int, 10>();
 742    test_pop_back_nd<value_nd, 10>();
 743    test_pop_back_nd<counting_value, 10>();
 744    BOOST_TEST(counting_value::count() == 0);
 745    test_pop_back_nd<shptr_value, 10>();
 746    test_pop_back_nd<movable_and_copyable_int, 10>();
 747
 748    test_copy_and_assign_nd<int, 10>(1);
 749    test_copy_and_assign_nd<value_nd, 10>(value_nd(1));
 750    test_copy_and_assign_nd<counting_value, 10>(counting_value(1));
 751    BOOST_TEST(counting_value::count() == 0);
 752    test_copy_and_assign_nd<shptr_value, 10>(shptr_value(1));
 753    test_copy_and_assign_nd<movable_and_copyable_int, 10>(produce_movable_and_copyable_int());
 754
 755    test_iterators_nd<int, 10>();
 756    test_iterators_nd<value_nd, 10>();
 757    test_iterators_nd<counting_value, 10>();
 758    BOOST_TEST(counting_value::count() == 0);
 759    test_iterators_nd<shptr_value, 10>();
 760    test_iterators_nd<movable_and_copyable_int, 10>();
 761
 762    test_erase_nd<int, 10>();
 763    test_erase_nd<value_nd, 10>();
 764    test_erase_nd<counting_value, 10>();
 765    BOOST_TEST(counting_value::count() == 0);
 766    test_erase_nd<shptr_value, 10>();
 767    test_erase_nd<movable_and_copyable_int, 10>();
 768
 769    test_insert_nd<int, 10>(50);
 770    test_insert_nd<value_nd, 10>(value_nd(50));
 771    test_insert_nd<counting_value, 10>(counting_value(50));
 772    BOOST_TEST(counting_value::count() == 0);
 773    test_insert_nd<shptr_value, 10>(shptr_value(50));
 774    test_insert_nd<movable_and_copyable_int, 10>(produce_movable_and_copyable_int());
 775
 776    test_capacity_0_nd<int>();
 777    test_capacity_0_nd<value_nd>();
 778    test_capacity_0_nd<counting_value>();
 779    BOOST_TEST(counting_value::count() == 0);
 780    test_capacity_0_nd<shptr_value>();
 781    test_capacity_0_nd<movable_and_copyable_int>();
 782
 783    test_exceptions_nd<int, 10>();
 784    test_exceptions_nd<value_nd, 10>();
 785    test_exceptions_nd<counting_value, 10>();
 786    BOOST_TEST(counting_value::count() == 0);
 787    test_exceptions_nd<shptr_value, 10>();
 788    test_exceptions_nd<movable_and_copyable_int, 10>();
 789
 790    test_swap_and_move_nd<int, 10>();
 791    test_swap_and_move_nd<value_nd, 10>();
 792    test_swap_and_move_nd<counting_value, 10>();
 793    BOOST_TEST(counting_value::count() == 0);
 794    test_swap_and_move_nd<shptr_value, 10>();
 795    test_swap_and_move_nd<movable_and_copyable_int, 10>();
 796
 797    test_emplace_0p<counting_value, 10>();
 798    BOOST_TEST(counting_value::count() == 0);
 799
 800    test_emplace_2p<counting_value, 10>();
 801    BOOST_TEST(counting_value::count() == 0);
 802
 803    test_sv_elem<int, 10>(50);
 804    test_sv_elem<value_nd, 10>(value_nd(50));
 805    test_sv_elem<counting_value, 10>(counting_value(50));
 806    BOOST_TEST(counting_value::count() == 0);
 807    test_sv_elem<shptr_value, 10>(shptr_value(50));
 808    test_sv_elem<movable_and_copyable_int, 10>(movable_and_copyable_int(50));
 809
 810    BOOST_TEST(default_init_test() == true);
 811
 812    test_support_for_initializer_list();
 813
 814    return boost::report_errors();
 815 }
 816
 817 #include <boost/container/detail/config_end.hpp>