libcxx/test/std/utilities/optional/optional.object/optional.object.assign/const_optional_U.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 // UNSUPPORTED: c++03, c++11, c++14
  10 // <optional>
  11
  12 // From LWG2451:
  13 // template<class U>
  14 //   optional<T>& operator=(const optional<U>& rhs);
  15
  16 #include <optional>
  17 #include <type_traits>
  18 #include <cassert>
  19
  20 #include "test_macros.h"
  21 #include "archetypes.h"
  22
  23 using std::optional;
  24
  25 struct X
  26 {
  27     static bool throw_now;
  28
  29     X() = default;
  30     X(int)
  31     {
  32         if (throw_now)
  33             TEST_THROW(6);
  34     }
  35 };
  36
  37 bool X::throw_now = false;
  38
  39 struct Y1
  40 {
  41     Y1() = default;
  42     Y1(const int&) {}
  43     Y1& operator=(const Y1&) = delete;
  44 };
  45
  46 struct Y2
  47 {
  48     Y2() = default;
  49     Y2(const int&) = delete;
  50     Y2& operator=(const int&) { return *this; }
  51 };
  52
  53 template <class T>
  54 struct AssignableFrom {
  55   static int type_constructed;
  56   static int type_assigned;
  57 static int int_constructed;
  58   static int int_assigned;
  59
  60   static void reset() {
  61       type_constructed = int_constructed = 0;
  62       type_assigned = int_assigned = 0;
  63   }
  64
  65   AssignableFrom() = default;
  66
  67   explicit AssignableFrom(T) { ++type_constructed; }
  68   AssignableFrom& operator=(T) { ++type_assigned; return *this; }
  69
  70   AssignableFrom(int) { ++int_constructed; }
  71   AssignableFrom& operator=(int) { ++int_assigned; return *this; }
  72 private:
  73   AssignableFrom(AssignableFrom const&) = delete;
  74   AssignableFrom& operator=(AssignableFrom const&) = delete;
  75 };
  76
  77 template <class T> int AssignableFrom<T>::type_constructed = 0;
  78 template <class T> int AssignableFrom<T>::type_assigned = 0;
  79 template <class T> int AssignableFrom<T>::int_constructed = 0;
  80 template <class T> int AssignableFrom<T>::int_assigned = 0;
  81
  82
  83 void test_with_test_type() {
  84     using T = TestTypes::TestType;
  85     T::reset();
  86     { // non-empty to empty
  87         T::reset_constructors();
  88         optional<T> opt;
  89         const optional<int> other(42);
  90         opt = other;
  91         assert(T::alive == 1);
  92         assert(T::constructed == 1);
  93         assert(T::value_constructed == 1);
  94         assert(T::assigned == 0);
  95         assert(T::destroyed == 0);
  96         assert(static_cast<bool>(other) == true);
  97         assert(*other == 42);
  98         assert(static_cast<bool>(opt) == true);
  99         assert(*opt == T(42));
 100     }
 101     assert(T::alive == 0);
 102     { // non-empty to non-empty
 103         optional<T> opt(101);
 104         const optional<int> other(42);
 105         T::reset_constructors();
 106         opt = other;
 107         assert(T::alive == 1);
 108         assert(T::constructed == 0);
 109         assert(T::assigned == 1);
 110         assert(T::value_assigned == 1);
 111         assert(T::destroyed == 0);
 112         assert(static_cast<bool>(other) == true);
 113         assert(*other == 42);
 114         assert(static_cast<bool>(opt) == true);
 115         assert(*opt == T(42));
 116     }
 117     assert(T::alive == 0);
 118     { // empty to non-empty
 119         optional<T> opt(101);
 120         const optional<int> other;
 121         T::reset_constructors();
 122         opt = other;
 123         assert(T::alive == 0);
 124         assert(T::constructed == 0);
 125         assert(T::assigned == 0);
 126         assert(T::destroyed == 1);
 127         assert(static_cast<bool>(other) == false);
 128         assert(static_cast<bool>(opt) == false);
 129     }
 130     assert(T::alive == 0);
 131     { // empty to empty
 132         optional<T> opt;
 133         const optional<int> other;
 134         T::reset_constructors();
 135         opt = other;
 136         assert(T::alive == 0);
 137         assert(T::constructed == 0);
 138         assert(T::assigned == 0);
 139         assert(T::destroyed == 0);
 140         assert(static_cast<bool>(other) == false);
 141         assert(static_cast<bool>(opt) == false);
 142     }
 143     assert(T::alive == 0);
 144 }
 145
 146 void test_ambiguous_assign() {
 147     using OptInt = std::optional<int>;
 148     {
 149         using T = AssignableFrom<OptInt const&>;
 150         const OptInt a(42);
 151         T::reset();
 152         {
 153             std::optional<T> t;
 154             t = a;
 155             assert(T::type_constructed == 1);
 156             assert(T::type_assigned == 0);
 157             assert(T::int_constructed == 0);
 158             assert(T::int_assigned == 0);
 159         }
 160         T::reset();
 161         {
 162             std::optional<T> t(42);
 163             t = a;
 164             assert(T::type_constructed == 0);
 165             assert(T::type_assigned == 1);
 166             assert(T::int_constructed == 1);
 167             assert(T::int_assigned == 0);
 168         }
 169         T::reset();
 170         {
 171             std::optional<T> t(42);
 172             t = std::move(a);
 173             assert(T::type_constructed == 0);
 174             assert(T::type_assigned == 1);
 175             assert(T::int_constructed == 1);
 176             assert(T::int_assigned == 0);
 177         }
 178     }
 179     {
 180         using T = AssignableFrom<OptInt&>;
 181         OptInt a(42);
 182         T::reset();
 183         {
 184             std::optional<T> t;
 185             t = a;
 186             assert(T::type_constructed == 1);
 187             assert(T::type_assigned == 0);
 188             assert(T::int_constructed == 0);
 189             assert(T::int_assigned == 0);
 190         }
 191         {
 192             using Opt = std::optional<T>;
 193             static_assert(!std::is_assignable_v<Opt&, OptInt const&>, "");
 194         }
 195     }
 196 }
 197
 198
 199 int main(int, char**)
 200 {
 201     test_with_test_type();
 202     test_ambiguous_assign();
 203     {
 204         optional<int> opt;
 205         constexpr optional<short> opt2;
 206         opt = opt2;
 207         static_assert(static_cast<bool>(opt2) == false, "");
 208         assert(static_cast<bool>(opt) == static_cast<bool>(opt2));
 209     }
 210     {
 211         optional<int> opt;
 212         constexpr optional<short> opt2(short{2});
 213         opt = opt2;
 214         static_assert(static_cast<bool>(opt2) == true, "");
 215         static_assert(*opt2 == 2, "");
 216         assert(static_cast<bool>(opt) == static_cast<bool>(opt2));
 217         assert(*opt == *opt2);
 218     }
 219     {
 220         optional<int> opt(3);
 221         constexpr optional<short> opt2;
 222         opt = opt2;
 223         static_assert(static_cast<bool>(opt2) == false, "");
 224         assert(static_cast<bool>(opt) == static_cast<bool>(opt2));
 225     }
 226     {
 227         optional<int> opt(3);
 228         constexpr optional<short> opt2(short{2});
 229         opt = opt2;
 230         static_assert(static_cast<bool>(opt2) == true, "");
 231         static_assert(*opt2 == 2, "");
 232         assert(static_cast<bool>(opt) == static_cast<bool>(opt2));
 233         assert(*opt == *opt2);
 234     }
 235 #ifndef TEST_HAS_NO_EXCEPTIONS
 236     {
 237         optional<X> opt;
 238         optional<int> opt2(42);
 239         assert(static_cast<bool>(opt2) == true);
 240         try
 241         {
 242             X::throw_now = true;
 243             opt = opt2;
 244             assert(false);
 245         }
 246         catch (int i)
 247         {
 248             assert(i == 6);
 249             assert(static_cast<bool>(opt) == false);
 250         }
 251     }
 252 #endif
 253
 254   return 0;
 255 }