test/std/utilities/optional/optional.specalg/swap.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 // UNSUPPORTED: c++98, c++03, c++11, c++14
  11 // <optional>
  12
  13 // template <class T> void swap(optional<T>& x, optional<T>& y)
  14 //     noexcept(noexcept(x.swap(y)));
  15
  16 #include <optional>
  17 #include <type_traits>
  18 #include <cassert>
  19
  20 #include "test_macros.h"
  21 #include "archetypes.hpp"
  22
  23 using std::optional;
  24
  25 class X
  26 {
  27     int i_;
  28 public:
  29     static unsigned dtor_called;
  30     X(int i) : i_(i) {}
  31     X(X&& x) = default;
  32     X& operator=(X&&) = default;
  33     ~X() {++dtor_called;}
  34
  35     friend bool operator==(const X& x, const X& y) {return x.i_ == y.i_;}
  36 };
  37
  38 unsigned X::dtor_called = 0;
  39
  40 class Y
  41 {
  42     int i_;
  43 public:
  44     static unsigned dtor_called;
  45     Y(int i) : i_(i) {}
  46     Y(Y&&) = default;
  47     ~Y() {++dtor_called;}
  48
  49     friend constexpr bool operator==(const Y& x, const Y& y) {return x.i_ == y.i_;}
  50     friend void swap(Y& x, Y& y) {std::swap(x.i_, y.i_);}
  51 };
  52
  53 unsigned Y::dtor_called = 0;
  54
  55 class Z
  56 {
  57     int i_;
  58 public:
  59     Z(int i) : i_(i) {}
  60     Z(Z&&) { TEST_THROW(7);}
  61
  62     friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
  63     friend void swap(Z&, Z&) { TEST_THROW(6);}
  64 };
  65
  66
  67 struct NonSwappable {
  68     NonSwappable(NonSwappable const&) = delete;
  69 };
  70 void swap(NonSwappable&, NonSwappable&) = delete;
  71
  72 void test_swap_sfinae() {
  73     using std::optional;
  74     {
  75         using T = TestTypes::TestType;
  76         static_assert(std::is_swappable_v<optional<T>>, "");
  77     }
  78     {
  79         using T = TestTypes::MoveOnly;
  80         static_assert(std::is_swappable_v<optional<T>>, "");
  81     }
  82     {
  83         using T = TestTypes::Copyable;
  84         static_assert(std::is_swappable_v<optional<T>>, "");
  85     }
  86     {
  87         using T = TestTypes::NoCtors;
  88         static_assert(!std::is_swappable_v<optional<T>>, "");
  89     }
  90     {
  91         using T = NonSwappable;
  92         static_assert(!std::is_swappable_v<optional<T>>, "");
  93     }
  94     {
  95         // Even thought CopyOnly has deleted move operations, those operations
  96         // cause optional<CopyOnly> to have implicitly deleted move operations
  97         // that decay into copies.
  98         using T = TestTypes::CopyOnly;
  99         using Opt = optional<T>;
 100         T::reset();
 101         Opt L(101), R(42);
 102         T::reset_constructors();
 103         std::swap(L, R);
 104         assert(L->value == 42);
 105         assert(R->value == 101);
 106         assert(T::copy_constructed == 1);
 107         assert(T::constructed == T::copy_constructed);
 108         assert(T::assigned == 2);
 109         assert(T::assigned == T::copy_assigned);
 110     }
 111 }
 112
 113 int main()
 114 {
 115     test_swap_sfinae();
 116     {
 117         optional<int> opt1;
 118         optional<int> opt2;
 119         static_assert(noexcept(swap(opt1, opt2)) == true, "");
 120         assert(static_cast<bool>(opt1) == false);
 121         assert(static_cast<bool>(opt2) == false);
 122         swap(opt1, opt2);
 123         assert(static_cast<bool>(opt1) == false);
 124         assert(static_cast<bool>(opt2) == false);
 125     }
 126     {
 127         optional<int> opt1(1);
 128         optional<int> opt2;
 129         static_assert(noexcept(swap(opt1, opt2)) == true, "");
 130         assert(static_cast<bool>(opt1) == true);
 131         assert(*opt1 == 1);
 132         assert(static_cast<bool>(opt2) == false);
 133         swap(opt1, opt2);
 134         assert(static_cast<bool>(opt1) == false);
 135         assert(static_cast<bool>(opt2) == true);
 136         assert(*opt2 == 1);
 137     }
 138     {
 139         optional<int> opt1;
 140         optional<int> opt2(2);
 141         static_assert(noexcept(swap(opt1, opt2)) == true, "");
 142         assert(static_cast<bool>(opt1) == false);
 143         assert(static_cast<bool>(opt2) == true);
 144         assert(*opt2 == 2);
 145         swap(opt1, opt2);
 146         assert(static_cast<bool>(opt1) == true);
 147         assert(*opt1 == 2);
 148         assert(static_cast<bool>(opt2) == false);
 149     }
 150     {
 151         optional<int> opt1(1);
 152         optional<int> opt2(2);
 153         static_assert(noexcept(swap(opt1, opt2)) == true, "");
 154         assert(static_cast<bool>(opt1) == true);
 155         assert(*opt1 == 1);
 156         assert(static_cast<bool>(opt2) == true);
 157         assert(*opt2 == 2);
 158         swap(opt1, opt2);
 159         assert(static_cast<bool>(opt1) == true);
 160         assert(*opt1 == 2);
 161         assert(static_cast<bool>(opt2) == true);
 162         assert(*opt2 == 1);
 163     }
 164     {
 165         optional<X> opt1;
 166         optional<X> opt2;
 167         static_assert(noexcept(swap(opt1, opt2)) == true, "");
 168         assert(static_cast<bool>(opt1) == false);
 169         assert(static_cast<bool>(opt2) == false);
 170         swap(opt1, opt2);
 171         assert(static_cast<bool>(opt1) == false);
 172         assert(static_cast<bool>(opt2) == false);
 173         assert(X::dtor_called == 0);
 174     }
 175     {
 176         optional<X> opt1(1);
 177         optional<X> opt2;
 178         static_assert(noexcept(swap(opt1, opt2)) == true, "");
 179         assert(static_cast<bool>(opt1) == true);
 180         assert(*opt1 == 1);
 181         assert(static_cast<bool>(opt2) == false);
 182         X::dtor_called = 0;
 183         swap(opt1, opt2);
 184         assert(X::dtor_called == 1);
 185         assert(static_cast<bool>(opt1) == false);
 186         assert(static_cast<bool>(opt2) == true);
 187         assert(*opt2 == 1);
 188     }
 189     {
 190         optional<X> opt1;
 191         optional<X> opt2(2);
 192         static_assert(noexcept(swap(opt1, opt2)) == true, "");
 193         assert(static_cast<bool>(opt1) == false);
 194         assert(static_cast<bool>(opt2) == true);
 195         assert(*opt2 == 2);
 196         X::dtor_called = 0;
 197         swap(opt1, opt2);
 198         assert(X::dtor_called == 1);
 199         assert(static_cast<bool>(opt1) == true);
 200         assert(*opt1 == 2);
 201         assert(static_cast<bool>(opt2) == false);
 202     }
 203     {
 204         optional<X> opt1(1);
 205         optional<X> opt2(2);
 206         static_assert(noexcept(swap(opt1, opt2)) == true, "");
 207         assert(static_cast<bool>(opt1) == true);
 208         assert(*opt1 == 1);
 209         assert(static_cast<bool>(opt2) == true);
 210         assert(*opt2 == 2);
 211         X::dtor_called = 0;
 212         swap(opt1, opt2);
 213         assert(X::dtor_called == 1);  // from inside std::swap
 214         assert(static_cast<bool>(opt1) == true);
 215         assert(*opt1 == 2);
 216         assert(static_cast<bool>(opt2) == true);
 217         assert(*opt2 == 1);
 218     }
 219     {
 220         optional<Y> opt1;
 221         optional<Y> opt2;
 222         static_assert(noexcept(swap(opt1, opt2)) == false, "");
 223         assert(static_cast<bool>(opt1) == false);
 224         assert(static_cast<bool>(opt2) == false);
 225         swap(opt1, opt2);
 226         assert(static_cast<bool>(opt1) == false);
 227         assert(static_cast<bool>(opt2) == false);
 228         assert(Y::dtor_called == 0);
 229     }
 230     {
 231         optional<Y> opt1(1);
 232         optional<Y> opt2;
 233         static_assert(noexcept(swap(opt1, opt2)) == false, "");
 234         assert(static_cast<bool>(opt1) == true);
 235         assert(*opt1 == 1);
 236         assert(static_cast<bool>(opt2) == false);
 237         Y::dtor_called = 0;
 238         swap(opt1, opt2);
 239         assert(Y::dtor_called == 1);
 240         assert(static_cast<bool>(opt1) == false);
 241         assert(static_cast<bool>(opt2) == true);
 242         assert(*opt2 == 1);
 243     }
 244     {
 245         optional<Y> opt1;
 246         optional<Y> opt2(2);
 247         static_assert(noexcept(swap(opt1, opt2)) == false, "");
 248         assert(static_cast<bool>(opt1) == false);
 249         assert(static_cast<bool>(opt2) == true);
 250         assert(*opt2 == 2);
 251         Y::dtor_called = 0;
 252         swap(opt1, opt2);
 253         assert(Y::dtor_called == 1);
 254         assert(static_cast<bool>(opt1) == true);
 255         assert(*opt1 == 2);
 256         assert(static_cast<bool>(opt2) == false);
 257     }
 258     {
 259         optional<Y> opt1(1);
 260         optional<Y> opt2(2);
 261         static_assert(noexcept(swap(opt1, opt2)) == false, "");
 262         assert(static_cast<bool>(opt1) == true);
 263         assert(*opt1 == 1);
 264         assert(static_cast<bool>(opt2) == true);
 265         assert(*opt2 == 2);
 266         Y::dtor_called = 0;
 267         swap(opt1, opt2);
 268         assert(Y::dtor_called == 0);
 269         assert(static_cast<bool>(opt1) == true);
 270         assert(*opt1 == 2);
 271         assert(static_cast<bool>(opt2) == true);
 272         assert(*opt2 == 1);
 273     }
 274     {
 275         optional<Z> opt1;
 276         optional<Z> opt2;
 277         static_assert(noexcept(swap(opt1, opt2)) == false, "");
 278         assert(static_cast<bool>(opt1) == false);
 279         assert(static_cast<bool>(opt2) == false);
 280         swap(opt1, opt2);
 281         assert(static_cast<bool>(opt1) == false);
 282         assert(static_cast<bool>(opt2) == false);
 283     }
 284 #ifndef TEST_HAS_NO_EXCEPTIONS
 285     {
 286         optional<Z> opt1;
 287         opt1.emplace(1);
 288         optional<Z> opt2;
 289         static_assert(noexcept(swap(opt1, opt2)) == false, "");
 290         assert(static_cast<bool>(opt1) == true);
 291         assert(*opt1 == 1);
 292         assert(static_cast<bool>(opt2) == false);
 293         try
 294         {
 295             swap(opt1, opt2);
 296             assert(false);
 297         }
 298         catch (int i)
 299         {
 300             assert(i == 7);
 301         }
 302         assert(static_cast<bool>(opt1) == true);
 303         assert(*opt1 == 1);
 304         assert(static_cast<bool>(opt2) == false);
 305     }
 306     {
 307         optional<Z> opt1;
 308         optional<Z> opt2;
 309         opt2.emplace(2);
 310         static_assert(noexcept(swap(opt1, opt2)) == false, "");
 311         assert(static_cast<bool>(opt1) == false);
 312         assert(static_cast<bool>(opt2) == true);
 313         assert(*opt2 == 2);
 314         try
 315         {
 316             swap(opt1, opt2);
 317             assert(false);
 318         }
 319         catch (int i)
 320         {
 321             assert(i == 7);
 322         }
 323         assert(static_cast<bool>(opt1) == false);
 324         assert(static_cast<bool>(opt2) == true);
 325         assert(*opt2 == 2);
 326     }
 327     {
 328         optional<Z> opt1;
 329         opt1.emplace(1);
 330         optional<Z> opt2;
 331         opt2.emplace(2);
 332         static_assert(noexcept(swap(opt1, opt2)) == false, "");
 333         assert(static_cast<bool>(opt1) == true);
 334         assert(*opt1 == 1);
 335         assert(static_cast<bool>(opt2) == true);
 336         assert(*opt2 == 2);
 337         try
 338         {
 339             swap(opt1, opt2);
 340             assert(false);
 341         }
 342         catch (int i)
 343         {
 344             assert(i == 6);
 345         }
 346         assert(static_cast<bool>(opt1) == true);
 347         assert(*opt1 == 1);
 348         assert(static_cast<bool>(opt2) == true);
 349         assert(*opt2 == 2);
 350     }
 351 #endif // TEST_HAS_NO_EXCEPTIONS
 352 }