libcxx/test/std/containers/sequences/array/array.cons/implicit_copy.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // <array>
  10
  11 // implicitly generated array constructors / assignment operators
  12
  13 #include <array>
  14 #include <type_traits>
  15 #include <cassert>
  16 #include "test_macros.h"
  17
  18 // In C++03 the copy assignment operator is not deleted when the implicitly
  19 // generated operator would be ill-formed; like in the case of a struct with a
  20 // const member.
  21 #if TEST_STD_VER < 11
  22 #   define TEST_NOT_COPY_ASSIGNABLE(T) ((void)0)
  23 #else
  24 #   define TEST_NOT_COPY_ASSIGNABLE(T) static_assert(!std::is_copy_assignable<T>::value, "")
  25 #endif
  26
  27 struct NoDefault {
  28     TEST_CONSTEXPR NoDefault(int) { }
  29 };
  30
  31 struct NonTrivialCopy {
  32     TEST_CONSTEXPR NonTrivialCopy() { }
  33     TEST_CONSTEXPR NonTrivialCopy(NonTrivialCopy const&) { }
  34     TEST_CONSTEXPR_CXX14 NonTrivialCopy& operator=(NonTrivialCopy const&) { return *this; }
  35 };
  36
  37 TEST_CONSTEXPR_CXX14 bool tests()
  38 {
  39     {
  40         typedef std::array<double, 3> Array;
  41         Array array = {1.1, 2.2, 3.3};
  42         Array copy = array;
  43         copy = array;
  44         static_assert(std::is_copy_constructible<Array>::value, "");
  45         static_assert(std::is_copy_assignable<Array>::value, "");
  46     }
  47     {
  48         typedef std::array<double const, 3> Array;
  49         Array array = {1.1, 2.2, 3.3};
  50         Array copy = array; (void)copy;
  51         static_assert(std::is_copy_constructible<Array>::value, "");
  52         TEST_NOT_COPY_ASSIGNABLE(Array);
  53     }
  54     {
  55         typedef std::array<double, 0> Array;
  56         Array array = {};
  57         Array copy = array;
  58         copy = array;
  59         static_assert(std::is_copy_constructible<Array>::value, "");
  60         static_assert(std::is_copy_assignable<Array>::value, "");
  61     }
  62     {
  63         // const arrays of size 0 should disable the implicit copy assignment operator.
  64         typedef std::array<double const, 0> Array;
  65         Array array = {};
  66         Array copy = array; (void)copy;
  67         static_assert(std::is_copy_constructible<Array>::value, "");
  68         TEST_NOT_COPY_ASSIGNABLE(Array);
  69     }
  70     {
  71         typedef std::array<NoDefault, 0> Array;
  72         Array array = {};
  73         Array copy = array;
  74         copy = array;
  75         static_assert(std::is_copy_constructible<Array>::value, "");
  76         static_assert(std::is_copy_assignable<Array>::value, "");
  77     }
  78     {
  79         typedef std::array<NoDefault const, 0> Array;
  80         Array array = {};
  81         Array copy = array; (void)copy;
  82         static_assert(std::is_copy_constructible<Array>::value, "");
  83         TEST_NOT_COPY_ASSIGNABLE(Array);
  84     }
  85
  86     // Make sure we can implicitly copy a std::array of a non-trivially copyable type
  87     {
  88         typedef std::array<NonTrivialCopy, 0> Array;
  89         Array array = {};
  90         Array copy = array;
  91         copy = array;
  92         static_assert(std::is_copy_constructible<Array>::value, "");
  93     }
  94     {
  95         typedef std::array<NonTrivialCopy, 1> Array;
  96         Array array = {};
  97         Array copy = array;
  98         copy = array;
  99         static_assert(std::is_copy_constructible<Array>::value, "");
 100     }
 101     {
 102         typedef std::array<NonTrivialCopy, 2> Array;
 103         Array array = {};
 104         Array copy = array;
 105         copy = array;
 106         static_assert(std::is_copy_constructible<Array>::value, "");
 107     }
 108
 109     return true;
 110 }
 111
 112 int main(int, char**)
 113 {
 114     tests();
 115 #if TEST_STD_VER >= 14
 116     static_assert(tests(), "");
 117 #endif
 118     return 0;
 119 }