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 // optional<T>& operator=(optional<T>&& rhs) 14 // noexcept(is_nothrow_move_assignable<T>::value && 15 // is_nothrow_move_constructible<T>::value); 16 17 #include <optional> 18 #include <type_traits> 19 #include <cassert> 20 21 #include "test_macros.h" 22 #include "archetypes.hpp" 23 24 using std::optional; 25 26 struct X 27 { 28 static bool throw_now; 29 static int alive; 30 31 X() { ++alive; } 32 X(X&&) 33 { 34 if (throw_now) 35 TEST_THROW(6); 36 ++alive; 37 } 38 39 X& operator=(X&&) 40 { 41 if (throw_now) 42 TEST_THROW(42); 43 return *this; 44 } 45 46 ~X() { assert(alive > 0); --alive; } 47 }; 48 49 struct Y {}; 50 51 bool X::throw_now = false; 52 int X::alive = 0; 53 54 int main() 55 { 56 { 57 static_assert(std::is_nothrow_move_assignable<optional<int>>::value, ""); 58 optional<int> opt; 59 constexpr optional<int> opt2; 60 opt = std::move(opt2); 61 static_assert(static_cast<bool>(opt2) == false, ""); 62 assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); 63 } 64 { 65 optional<int> opt; 66 constexpr optional<int> opt2(2); 67 opt = std::move(opt2); 68 static_assert(static_cast<bool>(opt2) == true, ""); 69 static_assert(*opt2 == 2, ""); 70 assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); 71 assert(*opt == *opt2); 72 } 73 { 74 optional<int> opt(3); 75 constexpr optional<int> opt2; 76 opt = std::move(opt2); 77 static_assert(static_cast<bool>(opt2) == false, ""); 78 assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); 79 } 80 { 81 using T = TestTypes::TestType; 82 T::reset(); 83 optional<T> opt(3); 84 optional<T> opt2; 85 assert(T::alive == 1); 86 opt = std::move(opt2); 87 assert(T::alive == 0); 88 assert(static_cast<bool>(opt2) == false); 89 assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); 90 } 91 { 92 optional<int> opt(3); 93 constexpr optional<int> opt2(2); 94 opt = std::move(opt2); 95 static_assert(static_cast<bool>(opt2) == true, ""); 96 static_assert(*opt2 == 2, ""); 97 assert(static_cast<bool>(opt) == static_cast<bool>(opt2)); 98 assert(*opt == *opt2); 99 } 100 #ifndef TEST_HAS_NO_EXCEPTIONS 101 { 102 static_assert(!std::is_nothrow_move_assignable<optional<X>>::value, ""); 103 X::alive = 0; 104 X::throw_now = false; 105 optional<X> opt; 106 optional<X> opt2(X{}); 107 assert(X::alive == 1); 108 assert(static_cast<bool>(opt2) == true); 109 try 110 { 111 X::throw_now = true; 112 opt = std::move(opt2); 113 assert(false); 114 } 115 catch (int i) 116 { 117 assert(i == 6); 118 assert(static_cast<bool>(opt) == false); 119 } 120 assert(X::alive == 1); 121 } 122 assert(X::alive == 0); 123 { 124 static_assert(!std::is_nothrow_move_assignable<optional<X>>::value, ""); 125 X::throw_now = false; 126 optional<X> opt(X{}); 127 optional<X> opt2(X{}); 128 assert(X::alive == 2); 129 assert(static_cast<bool>(opt2) == true); 130 try 131 { 132 X::throw_now = true; 133 opt = std::move(opt2); 134 assert(false); 135 } 136 catch (int i) 137 { 138 assert(i == 42); 139 assert(static_cast<bool>(opt) == true); 140 } 141 assert(X::alive == 2); 142 } 143 assert(X::alive == 0); 144 #endif // TEST_HAS_NO_EXCEPTIONS 145 { 146 static_assert(std::is_nothrow_move_assignable<optional<Y>>::value, ""); 147 } 148 { 149 struct ThrowsMove { 150 ThrowsMove() noexcept {} 151 ThrowsMove(ThrowsMove const&) noexcept {} 152 ThrowsMove(ThrowsMove &&) noexcept(false) {} 153 ThrowsMove& operator=(ThrowsMove const&) noexcept { return *this; } 154 ThrowsMove& operator=(ThrowsMove &&) noexcept { return *this; } 155 }; 156 static_assert(!std::is_nothrow_move_assignable<optional<ThrowsMove>>::value, ""); 157 struct ThrowsMoveAssign { 158 ThrowsMoveAssign() noexcept {} 159 ThrowsMoveAssign(ThrowsMoveAssign const&) noexcept {} 160 ThrowsMoveAssign(ThrowsMoveAssign &&) noexcept {} 161 ThrowsMoveAssign& operator=(ThrowsMoveAssign const&) noexcept { return *this; } 162 ThrowsMoveAssign& operator=(ThrowsMoveAssign &&) noexcept(false) { return *this; } 163 }; 164 static_assert(!std::is_nothrow_move_assignable<optional<ThrowsMoveAssign>>::value, ""); 165 struct NoThrowMove { 166 NoThrowMove() noexcept(false) {} 167 NoThrowMove(NoThrowMove const&) noexcept(false) {} 168 NoThrowMove(NoThrowMove &&) noexcept {} 169 NoThrowMove& operator=(NoThrowMove const&) noexcept { return *this; } 170 NoThrowMove& operator=(NoThrowMove&&) noexcept { return *this; } 171 }; 172 static_assert(std::is_nothrow_move_assignable<optional<NoThrowMove>>::value, ""); 173 } 174 } 175
