1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
|
//===----------------------------------------------------------------------===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
// constexpr expected& operator=(const expected& rhs);
//
// Effects:
// - If this->has_value() && rhs.has_value() is true, no effects.
// - Otherwise, if this->has_value() is true, equivalent to: construct_at(addressof(unex), rhs.unex); has_val = false;
// - Otherwise, if rhs.has_value() is true, destroys unex and sets has_val to true.
// - Otherwise, equivalent to unex = rhs.error().
//
// Returns: *this.
//
// Remarks: This operator is defined as deleted unless is_copy_assignable_v<E> is true and is_copy_constructible_v<E> is true.
#include <cassert>
#include <concepts>
#include <expected>
#include <type_traits>
#include <utility>
#include "../../types.h"
#include "test_macros.h"
struct NotCopyConstructible {
NotCopyConstructible(const NotCopyConstructible&) = delete;
NotCopyConstructible& operator=(const NotCopyConstructible&) = default;
};
struct NotCopyAssignable {
NotCopyAssignable(const NotCopyAssignable&) = default;
NotCopyAssignable& operator=(const NotCopyAssignable&) = delete;
};
// Test constraints
static_assert(std::is_copy_assignable_v<std::expected<void, int>>);
// !is_copy_assignable_v<E>
static_assert(!std::is_copy_assignable_v<std::expected<void, NotCopyAssignable>>);
// !is_copy_constructible_v<E>
static_assert(!std::is_copy_assignable_v<std::expected<void, NotCopyConstructible>>);
constexpr bool test() {
// If this->has_value() && rhs.has_value() is true, no effects.
{
std::expected<void, int> e1;
std::expected<void, int> e2;
decltype(auto) x = (e1 = e2);
static_assert(std::same_as<decltype(x), std::expected<void, int>&>);
assert(&x == &e1);
assert(e1.has_value());
}
// Otherwise, if this->has_value() is true, equivalent to: construct_at(addressof(unex), rhs.unex); has_val = false;
{
Traced::state state{};
std::expected<void, Traced> e1;
std::expected<void, Traced> e2(std::unexpect, state, 5);
decltype(auto) x = (e1 = e2);
static_assert(std::same_as<decltype(x), std::expected<void, Traced>&>);
assert(&x == &e1);
assert(!e1.has_value());
assert(e1.error().data_ == 5);
assert(state.copyCtorCalled);
}
// Otherwise, if rhs.has_value() is true, destroys unex and sets has_val to true.
{
Traced::state state{};
std::expected<void, Traced> e1(std::unexpect, state, 5);
std::expected<void, Traced> e2;
decltype(auto) x = (e1 = e2);
static_assert(std::same_as<decltype(x), std::expected<void, Traced>&>);
assert(&x == &e1);
assert(e1.has_value());
assert(state.dtorCalled);
}
// Otherwise, equivalent to unex = rhs.error().
{
Traced::state state{};
std::expected<void, Traced> e1(std::unexpect, state, 5);
std::expected<void, Traced> e2(std::unexpect, state, 10);
decltype(auto) x = (e1 = e2);
static_assert(std::same_as<decltype(x), std::expected<void, Traced>&>);
assert(&x == &e1);
assert(!e1.has_value());
assert(e1.error().data_ == 10);
assert(state.copyAssignCalled);
}
// CheckForInvalidWrites
{
{
CheckForInvalidWrites<true, true> e1;
CheckForInvalidWrites<true, true> e2(std::unexpect);
e1 = e2;
assert(e1.check());
assert(e2.check());
}
{
CheckForInvalidWrites<false, true> e1;
CheckForInvalidWrites<false, true> e2(std::unexpect);
e1 = e2;
assert(e1.check());
assert(e2.check());
}
}
return true;
}
void testException() {
#ifndef TEST_HAS_NO_EXCEPTIONS
std::expected<void, ThrowOnCopyConstruct> e1(std::in_place);
std::expected<void, ThrowOnCopyConstruct> e2(std::unexpect);
try {
e1 = e2;
assert(false);
} catch (Except) {
assert(e1.has_value());
}
#endif // TEST_HAS_NO_EXCEPTIONS
}
int main(int, char**) {
test();
static_assert(test());
testException();
return 0;
}
|