Home | History | Annotate | Download | only in uninitialized.copy
      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 // <memory>
     11 
     12 // template <class InputIterator, class Size, class ForwardIterator>
     13 //   ForwardIterator
     14 //   uninitialized_copy_n(InputIterator first, Size n,
     15 //                        ForwardIterator result);
     16 
     17 #include <memory>
     18 #include <cassert>
     19 
     20 #include "test_macros.h"
     21 
     22 struct B
     23 {
     24     static int count_;
     25     static int population_;
     26     int data_;
     27     explicit B() : data_(1) { ++population_; }
     28     B(const B &b) {
     29       ++count_;
     30       if (count_ == 3)
     31         TEST_THROW(1);
     32       data_ = b.data_;
     33       ++population_;
     34     }
     35     ~B() {data_ = 0; --population_; }
     36 };
     37 
     38 int B::population_ = 0;
     39 int B::count_ = 0;
     40 
     41 struct Nasty
     42 {
     43     Nasty() : i_ ( counter_++ ) {}
     44     Nasty * operator &() const { return NULL; }
     45     int i_;
     46     static int counter_;
     47 };
     48 
     49 int Nasty::counter_ = 0;
     50 
     51 int main()
     52 {
     53     {
     54     const int N = 5;
     55     char pool[sizeof(B)*N] = {0};
     56     B* bp = (B*)pool;
     57     B b[N];
     58     assert(B::population_ == N);
     59 #ifndef TEST_HAS_NO_EXCEPTIONS
     60     try
     61     {
     62         std::uninitialized_copy_n(b, 5, bp);
     63         assert(false);
     64     }
     65     catch (...)
     66     {
     67         assert(B::population_ == N);
     68     }
     69 #endif
     70     B::count_ = 0;
     71     std::uninitialized_copy_n(b, 2, bp);
     72     for (int i = 0; i < 2; ++i)
     73         assert(bp[i].data_ == 1);
     74     assert(B::population_ == N + 2);
     75     }
     76 
     77     {
     78     const int N = 5;
     79     char pool[sizeof(Nasty)*N] = {0};
     80     Nasty * p = (Nasty *) pool;
     81     Nasty arr[N];
     82     std::uninitialized_copy_n(arr, N, p);
     83     for (int i = 0; i < N; ++i) {
     84         assert(arr[i].i_ == i);
     85         assert(  p[i].i_ == i);
     86     }
     87     }
     88 }
     89