shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
llvm-project/libcxx/test/std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
Louis Dionne f0fc8c4878 [libc++] Use named Lit features to flag back-deployment XFAILs 
Instead of writing something like `XFAIL: use_system_cxx_lib && target=...`
to XFAIL back-deployment tests, introduce named Lit features like
`availability-shared_mutex-missing` to represent those. This makes the
XFAIL annotations leaner, and solves the problem of XFAIL comments
potentially getting out of sync. This would also make it easier for
another vendor to add their own annotations to the test suite by simply
changing how the feature is defined for their OS releases, instead
of having to modify hundreds of tests to add repetitive annotations.

This doesn't touch *all* annotations -- only annotations that were widely
duplicated are given named features (e.g. when filesystem or shared_mutex
were introduced). I still think it probably doesn't make sense to have a
named feature for every single fix we make to the dylib.

This is in essence a revert of 2659663, but since then the test suite
has changed significantly. Back when I did 2659663, the configuration
files we have for the test suite right now were being bootstrapped and
it wasn't clear how to provide these features for back-deployment in
that context. Since then, we have a streamlined way of defining these
features in `features.py` and that doesn't impact the ability for a
configuration file to stay minimal.

The original motivation for this change was that I am about to propose
a change that would touch essentially all XFAIL annotations for back-deployment
in the test suite, and this greatly reduces the number of lines changed
by that upcoming change, in addition to making the test suite generally
better.

Differential Revision: https://reviews.llvm.org/D146359
2023-03-27 12:44:26 -04:00

501 lines
14 KiB
C++
Raw Blame History

//===----------------------------------------------------------------------===//
//
// 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
// XFAIL: availability-bad_variant_access-missing && !no-exceptions
// <variant>
// template <class ...Types> class variant;
// constexpr variant& operator=(variant&&) noexcept(see below);
#include <cassert>
#include <string>
#include <type_traits>
#include <utility>
#include <variant>
#include "test_macros.h"
#include "variant_test_helpers.h"
struct NoCopy {
NoCopy(const NoCopy &) = delete;
NoCopy &operator=(const NoCopy &) = default;
};
struct CopyOnly {
CopyOnly(const CopyOnly &) = default;
CopyOnly(CopyOnly &&) = delete;
CopyOnly &operator=(const CopyOnly &) = default;
CopyOnly &operator=(CopyOnly &&) = delete;
};
struct MoveOnly {
MoveOnly(const MoveOnly &) = delete;
MoveOnly(MoveOnly &&) = default;
MoveOnly &operator=(const MoveOnly &) = delete;
MoveOnly &operator=(MoveOnly &&) = default;
};
struct MoveOnlyNT {
MoveOnlyNT(const MoveOnlyNT &) = delete;
MoveOnlyNT(MoveOnlyNT &&) {}
MoveOnlyNT &operator=(const MoveOnlyNT &) = delete;
MoveOnlyNT &operator=(MoveOnlyNT &&) = default;
};
struct MoveOnlyOddNothrow {
MoveOnlyOddNothrow(MoveOnlyOddNothrow &&) noexcept(false) {}
MoveOnlyOddNothrow(const MoveOnlyOddNothrow &) = delete;
MoveOnlyOddNothrow &operator=(MoveOnlyOddNothrow &&) noexcept = default;
MoveOnlyOddNothrow &operator=(const MoveOnlyOddNothrow &) = delete;
};
struct MoveAssignOnly {
MoveAssignOnly(MoveAssignOnly &&) = delete;
MoveAssignOnly &operator=(MoveAssignOnly &&) = default;
};
struct MoveAssign {
static int move_construct;
static int move_assign;
static void reset() { move_construct = move_assign = 0; }
MoveAssign(int v) : value(v) {}
MoveAssign(MoveAssign &&o) : value(o.value) {
++move_construct;
o.value = -1;
}
MoveAssign &operator=(MoveAssign &&o) {
value = o.value;
++move_assign;
o.value = -1;
return *this;
}
int value;
};
int MoveAssign::move_construct = 0;
int MoveAssign::move_assign = 0;
struct NTMoveAssign {
constexpr NTMoveAssign(int v) : value(v) {}
NTMoveAssign(const NTMoveAssign &) = default;
NTMoveAssign(NTMoveAssign &&) = default;
NTMoveAssign &operator=(const NTMoveAssign &that) = default;
NTMoveAssign &operator=(NTMoveAssign &&that) {
value = that.value;
that.value = -1;
return *this;
};
int value;
};
static_assert(!std::is_trivially_move_assignable<NTMoveAssign>::value, "");
static_assert(std::is_move_assignable<NTMoveAssign>::value, "");
struct TMoveAssign {
constexpr TMoveAssign(int v) : value(v) {}
TMoveAssign(const TMoveAssign &) = delete;
TMoveAssign(TMoveAssign &&) = default;
TMoveAssign &operator=(const TMoveAssign &) = delete;
TMoveAssign &operator=(TMoveAssign &&) = default;
int value;
};
static_assert(std::is_trivially_move_assignable<TMoveAssign>::value, "");
struct TMoveAssignNTCopyAssign {
constexpr TMoveAssignNTCopyAssign(int v) : value(v) {}
TMoveAssignNTCopyAssign(const TMoveAssignNTCopyAssign &) = default;
TMoveAssignNTCopyAssign(TMoveAssignNTCopyAssign &&) = default;
TMoveAssignNTCopyAssign &operator=(const TMoveAssignNTCopyAssign &that) {
value = that.value;
return *this;
}
TMoveAssignNTCopyAssign &operator=(TMoveAssignNTCopyAssign &&) = default;
int value;
};
static_assert(std::is_trivially_move_assignable_v<TMoveAssignNTCopyAssign>, "");
struct TrivialCopyNontrivialMove {
TrivialCopyNontrivialMove(TrivialCopyNontrivialMove const&) = default;
TrivialCopyNontrivialMove(TrivialCopyNontrivialMove&&) noexcept {}
TrivialCopyNontrivialMove& operator=(TrivialCopyNontrivialMove const&) = default;
TrivialCopyNontrivialMove& operator=(TrivialCopyNontrivialMove&&) noexcept {
return *this;
}
};
static_assert(std::is_trivially_copy_assignable_v<TrivialCopyNontrivialMove>, "");
static_assert(!std::is_trivially_move_assignable_v<TrivialCopyNontrivialMove>, "");
void test_move_assignment_noexcept() {
{
using V = std::variant<int>;
static_assert(std::is_nothrow_move_assignable<V>::value, "");
}
{
using V = std::variant<MoveOnly>;
static_assert(std::is_nothrow_move_assignable<V>::value, "");
}
{
using V = std::variant<int, long>;
static_assert(std::is_nothrow_move_assignable<V>::value, "");
}
{
using V = std::variant<int, MoveOnly>;
static_assert(std::is_nothrow_move_assignable<V>::value, "");
}
{
using V = std::variant<MoveOnlyNT>;
static_assert(!std::is_nothrow_move_assignable<V>::value, "");
}
{
using V = std::variant<MoveOnlyOddNothrow>;
static_assert(!std::is_nothrow_move_assignable<V>::value, "");
}
}
void test_move_assignment_sfinae() {
{
using V = std::variant<int, long>;
static_assert(std::is_move_assignable<V>::value, "");
}
{
using V = std::variant<int, CopyOnly>;
static_assert(std::is_move_assignable<V>::value, "");
}
{
using V = std::variant<int, NoCopy>;
static_assert(!std::is_move_assignable<V>::value, "");
}
{
using V = std::variant<int, MoveOnly>;
static_assert(std::is_move_assignable<V>::value, "");
}
{
using V = std::variant<int, MoveOnlyNT>;
static_assert(std::is_move_assignable<V>::value, "");
}
{
// variant only provides move assignment when the types also provide
// a move constructor.
using V = std::variant<int, MoveAssignOnly>;
static_assert(!std::is_move_assignable<V>::value, "");
}
// Make sure we properly propagate triviality (see P0602R4).
{
using V = std::variant<int, long>;
static_assert(std::is_trivially_move_assignable<V>::value, "");
}
{
using V = std::variant<int, NTMoveAssign>;
static_assert(!std::is_trivially_move_assignable<V>::value, "");
static_assert(std::is_move_assignable<V>::value, "");
}
{
using V = std::variant<int, TMoveAssign>;
static_assert(std::is_trivially_move_assignable<V>::value, "");
}
{
using V = std::variant<int, TMoveAssignNTCopyAssign>;
static_assert(std::is_trivially_move_assignable<V>::value, "");
}
{
using V = std::variant<int, TrivialCopyNontrivialMove>;
static_assert(!std::is_trivially_move_assignable<V>::value, "");
}
{
using V = std::variant<int, CopyOnly>;
static_assert(std::is_trivially_move_assignable<V>::value, "");
}
}
void test_move_assignment_empty_empty() {
#ifndef TEST_HAS_NO_EXCEPTIONS
using MET = MakeEmptyT;
{
using V = std::variant<int, long, MET>;
V v1(std::in_place_index<0>);
makeEmpty(v1);
V v2(std::in_place_index<0>);
makeEmpty(v2);
V &vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.valueless_by_exception());
assert(v1.index() == std::variant_npos);
}
#endif // TEST_HAS_NO_EXCEPTIONS
}
void test_move_assignment_non_empty_empty() {
#ifndef TEST_HAS_NO_EXCEPTIONS
using MET = MakeEmptyT;
{
using V = std::variant<int, MET>;
V v1(std::in_place_index<0>, 42);
V v2(std::in_place_index<0>);
makeEmpty(v2);
V &vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.valueless_by_exception());
assert(v1.index() == std::variant_npos);
}
{
using V = std::variant<int, MET, std::string>;
V v1(std::in_place_index<2>, "hello");
V v2(std::in_place_index<0>);
makeEmpty(v2);
V &vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.valueless_by_exception());
assert(v1.index() == std::variant_npos);
}
#endif // TEST_HAS_NO_EXCEPTIONS
}
void test_move_assignment_empty_non_empty() {
#ifndef TEST_HAS_NO_EXCEPTIONS
using MET = MakeEmptyT;
{
using V = std::variant<int, MET>;
V v1(std::in_place_index<0>);
makeEmpty(v1);
V v2(std::in_place_index<0>, 42);
V &vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 0);
assert(std::get<0>(v1) == 42);
}
{
using V = std::variant<int, MET, std::string>;
V v1(std::in_place_index<0>);
makeEmpty(v1);
V v2(std::in_place_type<std::string>, "hello");
V &vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 2);
assert(std::get<2>(v1) == "hello");
}
#endif // TEST_HAS_NO_EXCEPTIONS
}
template <typename T> struct Result { std::size_t index; T value; };
void test_move_assignment_same_index() {
{
using V = std::variant<int>;
V v1(43);
V v2(42);
V &vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 0);
assert(std::get<0>(v1) == 42);
}
{
using V = std::variant<int, long, unsigned>;
V v1(43l);
V v2(42l);
V &vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 1);
assert(std::get<1>(v1) == 42);
}
{
using V = std::variant<int, MoveAssign, unsigned>;
V v1(std::in_place_type<MoveAssign>, 43);
V v2(std::in_place_type<MoveAssign>, 42);
MoveAssign::reset();
V &vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 1);
assert(std::get<1>(v1).value == 42);
assert(MoveAssign::move_construct == 0);
assert(MoveAssign::move_assign == 1);
}
#ifndef TEST_HAS_NO_EXCEPTIONS
using MET = MakeEmptyT;
{
using V = std::variant<int, MET, std::string>;
V v1(std::in_place_type<MET>);
MET &mref = std::get<1>(v1);
V v2(std::in_place_type<MET>);
try {
v1 = std::move(v2);
assert(false);
} catch (...) {
}
assert(v1.index() == 1);
assert(&std::get<1>(v1) == &mref);
}
#endif // TEST_HAS_NO_EXCEPTIONS
// Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
{
struct {
constexpr Result<int> operator()() const {
using V = std::variant<int>;
V v(43);
V v2(42);
v = std::move(v2);
return {v.index(), std::get<0>(v)};
}
} test;
constexpr auto result = test();
static_assert(result.index == 0, "");
static_assert(result.value == 42, "");
}
{
struct {
constexpr Result<long> operator()() const {
using V = std::variant<int, long, unsigned>;
V v(43l);
V v2(42l);
v = std::move(v2);
return {v.index(), std::get<1>(v)};
}
} test;
constexpr auto result = test();
static_assert(result.index == 1, "");
static_assert(result.value == 42l, "");
}
{
struct {
constexpr Result<int> operator()() const {
using V = std::variant<int, TMoveAssign, unsigned>;
V v(std::in_place_type<TMoveAssign>, 43);
V v2(std::in_place_type<TMoveAssign>, 42);
v = std::move(v2);
return {v.index(), std::get<1>(v).value};
}
} test;
constexpr auto result = test();
static_assert(result.index == 1, "");
static_assert(result.value == 42, "");
}
}
void test_move_assignment_different_index() {
{
using V = std::variant<int, long, unsigned>;
V v1(43);
V v2(42l);
V &vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 1);
assert(std::get<1>(v1) == 42);
}
{
using V = std::variant<int, MoveAssign, unsigned>;
V v1(std::in_place_type<unsigned>, 43u);
V v2(std::in_place_type<MoveAssign>, 42);
MoveAssign::reset();
V &vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 1);
assert(std::get<1>(v1).value == 42);
assert(MoveAssign::move_construct == 1);
assert(MoveAssign::move_assign == 0);
}
#ifndef TEST_HAS_NO_EXCEPTIONS
using MET = MakeEmptyT;
{
using V = std::variant<int, MET, std::string>;
V v1(std::in_place_type<int>);
V v2(std::in_place_type<MET>);
try {
v1 = std::move(v2);
assert(false);
} catch (...) {
}
assert(v1.valueless_by_exception());
assert(v1.index() == std::variant_npos);
}
{
using V = std::variant<int, MET, std::string>;
V v1(std::in_place_type<MET>);
V v2(std::in_place_type<std::string>, "hello");
V &vref = (v1 = std::move(v2));
assert(&vref == &v1);
assert(v1.index() == 2);
assert(std::get<2>(v1) == "hello");
}
#endif // TEST_HAS_NO_EXCEPTIONS
// Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
{
struct {
constexpr Result<long> operator()() const {
using V = std::variant<int, long, unsigned>;
V v(43);
V v2(42l);
v = std::move(v2);
return {v.index(), std::get<1>(v)};
}
} test;
constexpr auto result = test();
static_assert(result.index == 1, "");
static_assert(result.value == 42l, "");
}
{
struct {
constexpr Result<long> operator()() const {
using V = std::variant<int, TMoveAssign, unsigned>;
V v(std::in_place_type<unsigned>, 43u);
V v2(std::in_place_type<TMoveAssign>, 42);
v = std::move(v2);
return {v.index(), std::get<1>(v).value};
}
} test;
constexpr auto result = test();
static_assert(result.index == 1, "");
static_assert(result.value == 42, "");
}
}
template <std::size_t NewIdx, class ValueType>
constexpr bool test_constexpr_assign_imp(
std::variant<long, void*, int>&& v, ValueType&& new_value)
{
std::variant<long, void*, int> v2(
std::forward<ValueType>(new_value));
const auto cp = v2;
v = std::move(v2);
return v.index() == NewIdx &&
std::get<NewIdx>(v) == std::get<NewIdx>(cp);
}
void test_constexpr_move_assignment() {
// Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
using V = std::variant<long, void*, int>;
static_assert(std::is_trivially_copyable<V>::value, "");
static_assert(std::is_trivially_move_assignable<V>::value, "");
static_assert(test_constexpr_assign_imp<0>(V(42l), 101l), "");
static_assert(test_constexpr_assign_imp<0>(V(nullptr), 101l), "");
static_assert(test_constexpr_assign_imp<1>(V(42l), nullptr), "");
static_assert(test_constexpr_assign_imp<2>(V(42l), 101), "");
}
int main(int, char**) {
test_move_assignment_empty_empty();
test_move_assignment_non_empty_empty();
test_move_assignment_empty_non_empty();
test_move_assignment_same_index();
test_move_assignment_different_index();
test_move_assignment_sfinae();
test_move_assignment_noexcept();
test_constexpr_move_assignment();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink