test/std/containers/sequences/list/list.modifiers/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 // XFAIL: libcpp-no-exceptions
  11 // <list>
  12
  13 // template <InputIterator Iter>
  14 //   iterator insert(const_iterator position, Iter first, Iter last);
  15
  16 // UNSUPPORTED: sanitizer-new-delete
  17
  18 #if _LIBCPP_DEBUG >= 1
  19 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
  20 #endif
  21
  22 #include <list>
  23 #include <cstdlib>
  24 #include <cassert>
  25 #include "test_iterators.h"
  26 #include "min_allocator.h"
  27
  28 int throw_next = 0xFFFF;
  29 int count = 0;
  30
  31 void* operator new(std::size_t s) throw(std::bad_alloc)
  32 {
  33     if (throw_next == 0)
  34         throw std::bad_alloc();
  35     --throw_next;
  36     ++count;
  37     return std::malloc(s);
  38 }
  39
  40 void  operator delete(void* p) throw()
  41 {
  42     --count;
  43     std::free(p);
  44 }
  45
  46 int main()
  47 {
  48     {
  49     int a1[] = {1, 2, 3};
  50     std::list<int> l1;
  51     std::list<int>::iterator i = l1.insert(l1.begin(), a1, a1+3);
  52     assert(i == l1.begin());
  53     assert(l1.size() == 3);
  54     assert(distance(l1.begin(), l1.end()) == 3);
  55     i = l1.begin();
  56     assert(*i == 1);
  57     ++i;
  58     assert(*i == 2);
  59     ++i;
  60     assert(*i == 3);
  61     int a2[] = {4, 5, 6};
  62     i = l1.insert(i, a2, a2+3);
  63     assert(*i == 4);
  64     assert(l1.size() == 6);
  65     assert(distance(l1.begin(), l1.end()) == 6);
  66     i = l1.begin();
  67     assert(*i == 1);
  68     ++i;
  69     assert(*i == 2);
  70     ++i;
  71     assert(*i == 4);
  72     ++i;
  73     assert(*i == 5);
  74     ++i;
  75     assert(*i == 6);
  76     ++i;
  77     assert(*i == 3);
  78     throw_next = 2;
  79     int save_count = count;
  80     try
  81     {
  82         i = l1.insert(i, a2, a2+3);
  83         assert(false);
  84     }
  85     catch (...)
  86     {
  87     }
  88     assert(save_count == count);
  89     assert(l1.size() == 6);
  90     assert(distance(l1.begin(), l1.end()) == 6);
  91     i = l1.begin();
  92     assert(*i == 1);
  93     ++i;
  94     assert(*i == 2);
  95     ++i;
  96     assert(*i == 4);
  97     ++i;
  98     assert(*i == 5);
  99     ++i;
 100     assert(*i == 6);
 101     ++i;
 102     assert(*i == 3);
 103     }
 104     throw_next = 0xFFFF;
 105 #if _LIBCPP_DEBUG >= 1
 106     {
 107         std::list<int> v(100);
 108         std::list<int> v2(100);
 109         int a[] = {1, 2, 3, 4, 5};
 110         const int N = sizeof(a)/sizeof(a[0]);
 111         std::list<int>::iterator i = v.insert(next(v2.cbegin(), 10), input_iterator<const int*>(a),
 112                                        input_iterator<const int*>(a+N));
 113         assert(false);
 114     }
 115 #endif
 116 #if __cplusplus >= 201103L
 117     {
 118     int a1[] = {1, 2, 3};
 119     std::list<int, min_allocator<int>> l1;
 120     std::list<int, min_allocator<int>>::iterator i = l1.insert(l1.begin(), a1, a1+3);
 121     assert(i == l1.begin());
 122     assert(l1.size() == 3);
 123     assert(distance(l1.begin(), l1.end()) == 3);
 124     i = l1.begin();
 125     assert(*i == 1);
 126     ++i;
 127     assert(*i == 2);
 128     ++i;
 129     assert(*i == 3);
 130     int a2[] = {4, 5, 6};
 131     i = l1.insert(i, a2, a2+3);
 132     assert(*i == 4);
 133     assert(l1.size() == 6);
 134     assert(distance(l1.begin(), l1.end()) == 6);
 135     i = l1.begin();
 136     assert(*i == 1);
 137     ++i;
 138     assert(*i == 2);
 139     ++i;
 140     assert(*i == 4);
 141     ++i;
 142     assert(*i == 5);
 143     ++i;
 144     assert(*i == 6);
 145     ++i;
 146     assert(*i == 3);
 147     throw_next = 2;
 148     int save_count = count;
 149     try
 150     {
 151         i = l1.insert(i, a2, a2+3);
 152         assert(false);
 153     }
 154     catch (...)
 155     {
 156     }
 157     assert(save_count == count);
 158     assert(l1.size() == 6);
 159     assert(distance(l1.begin(), l1.end()) == 6);
 160     i = l1.begin();
 161     assert(*i == 1);
 162     ++i;
 163     assert(*i == 2);
 164     ++i;
 165     assert(*i == 4);
 166     ++i;
 167     assert(*i == 5);
 168     ++i;
 169     assert(*i == 6);
 170     ++i;
 171     assert(*i == 3);
 172     }
 173 #if _LIBCPP_DEBUG >= 1
 174     {
 175         throw_next = 0xFFFF;
 176         std::list<int, min_allocator<int>> v(100);
 177         std::list<int, min_allocator<int>> v2(100);
 178         int a[] = {1, 2, 3, 4, 5};
 179         const int N = sizeof(a)/sizeof(a[0]);
 180         std::list<int, min_allocator<int>>::iterator i = v.insert(next(v2.cbegin(), 10), input_iterator<const int*>(a),
 181                                        input_iterator<const int*>(a+N));
 182         assert(false);
 183     }
 184 #endif
 185 #endif
 186 }