test/std/utilities/memory/specialized.algorithms/uninitialized.copy/uninitialized_copy.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 // <memory>
  11
  12 // template <class InputIterator, class ForwardIterator>
  13 //   ForwardIterator
  14 //   uninitialized_copy(InputIterator first, InputIterator last,
  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::count_ = 0;
  39 int B::population_ = 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(b, b+N, bp);
  63         assert(false);
  64     }
  65     catch (...)
  66     {
  67         assert(B::population_ == N);
  68     }
  69 #endif
  70     B::count_ = 0;
  71     std::uninitialized_copy(b, 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(arr, 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 }