test/std/containers/sequences/vector.bool/insert_iter_iter_iter.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // <vector>
  11 // vector<bool>
  12
  13 // template <class Iter>
  14 //   iterator insert(const_iterator position, Iter first, Iter last);
  15
  16 #include <vector>
  17 #include <cassert>
  18 #include <cstddef>
  19
  20 #include "test_macros.h"
  21 #include "test_iterators.h"
  22 #include "min_allocator.h"
  23
  24 int main()
  25 {
  26     {
  27         std::vector<bool> v(100);
  28         bool a[] = {1, 0, 0, 1, 1};
  29         const unsigned N = sizeof(a)/sizeof(a[0]);
  30         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const bool*>(a),
  31                                         input_iterator<const bool*>(a+N));
  32         assert(v.size() == 100 + N);
  33         assert(i == v.begin() + 10);
  34         std::size_t j;
  35         for (j = 0; j < 10; ++j)
  36             assert(v[j] == 0);
  37         for (std::size_t k = 0; k < N; ++j, ++k)
  38             assert(v[j] == a[k]);
  39         for (; j < v.size(); ++j)
  40             assert(v[j] == 0);
  41     }
  42     {
  43         std::vector<bool> v(100);
  44         bool a[] = {1, 0, 0, 1, 1};
  45         const unsigned N = sizeof(a)/sizeof(a[0]);
  46         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const bool*>(a),
  47                                         forward_iterator<const bool*>(a+N));
  48         assert(v.size() == 100 + N);
  49         assert(i == v.begin() + 10);
  50         int j;
  51         for (j = 0; j < 10; ++j)
  52             assert(v[j] == 0);
  53         for (std::size_t k = 0; k < N; ++j, ++k)
  54             assert(v[j] == a[k]);
  55         for (; j < 105; ++j)
  56             assert(v[j] == 0);
  57     }
  58     {
  59         std::vector<bool> v(100);
  60         while(v.size() < v.capacity()) v.push_back(false);
  61         size_t sz = v.size();
  62         bool a[] = {1, 0, 0, 1, 1};
  63         const unsigned N = sizeof(a)/sizeof(a[0]);
  64         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const bool*>(a),
  65                                         forward_iterator<const bool*>(a+N));
  66         assert(v.size() == sz + N);
  67         assert(i == v.begin() + 10);
  68         std::size_t j;
  69         for (j = 0; j < 10; ++j)
  70             assert(v[j] == 0);
  71         for (std::size_t k = 0; k < N; ++j, ++k)
  72             assert(v[j] == a[k]);
  73         for (; j < v.size(); ++j)
  74             assert(v[j] == 0);
  75     }
  76     {
  77         std::vector<bool> v(100);
  78         while(v.size() < v.capacity()) v.push_back(false);
  79         v.pop_back(); v.pop_back(); v.pop_back();
  80         size_t sz = v.size();
  81         bool a[] = {1, 0, 0, 1, 1};
  82         const unsigned N = sizeof(a)/sizeof(a[0]);
  83         std::vector<bool>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const bool*>(a),
  84                                         forward_iterator<const bool*>(a+N));
  85         assert(v.size() == sz + N);
  86         assert(i == v.begin() + 10);
  87         std::size_t j;
  88         for (j = 0; j < 10; ++j)
  89             assert(v[j] == 0);
  90         for (std::size_t k = 0; k < N; ++j, ++k)
  91             assert(v[j] == a[k]);
  92         for (; j < v.size(); ++j)
  93             assert(v[j] == 0);
  94     }
  95 #if TEST_STD_VER >= 11
  96     {
  97         std::vector<bool, min_allocator<bool>> v(100);
  98         bool a[] = {1, 0, 0, 1, 1};
  99         const unsigned N = sizeof(a)/sizeof(a[0]);
 100         std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const bool*>(a),
 101                                         input_iterator<const bool*>(a+N));
 102         assert(v.size() == 100 + N);
 103         assert(i == v.begin() + 10);
 104         std::size_t j;
 105         for (j = 0; j < 10; ++j)
 106             assert(v[j] == 0);
 107         for (std::size_t k = 0; k < N; ++j, ++k)
 108             assert(v[j] == a[k]);
 109         for (; j < v.size(); ++j)
 110             assert(v[j] == 0);
 111     }
 112     {
 113         std::vector<bool, min_allocator<bool>> v(100);
 114         bool a[] = {1, 0, 0, 1, 1};
 115         const unsigned N = sizeof(a)/sizeof(a[0]);
 116         std::vector<bool, min_allocator<bool>>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const bool*>(a),
 117                                         forward_iterator<const bool*>(a+N));
 118         assert(v.size() == 100 + N);
 119         assert(i == v.begin() + 10);
 120         std::size_t j;
 121         for (j = 0; j < 10; ++j)
 122             assert(v[j] == 0);
 123         for (std::size_t k = 0; k < N; ++j, ++k)
 124             assert(v[j] == a[k]);
 125         for (; j < v.size(); ++j)
 126             assert(v[j] == 0);
 127     }
 128 #endif
 129 }