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, c++17
10
11// template<class T>
12// concept movable = see below;
13
14#include <concepts>
15
16#include <deque>
17#include <forward_list>
18#include <list>
19#include <map>
20#include <optional>
21#include <unordered_map>
22#include <vector>
23
24#include "test_macros.h"
25
26#ifndef TEST_HAS_NO_THREADS
27# include <mutex>
28#endif
29
30#include "type_classification/moveconstructible.h"
31#include "type_classification/movable.h"
32
33// Movable types
34static_assert(std::movable<int>);
35static_assert(std::movable<int volatile>);
36static_assert(std::movable<int*>);
37static_assert(std::movable<int const*>);
38static_assert(std::movable<int volatile*>);
39static_assert(std::movable<int const volatile*>);
40static_assert(std::movable<int (*)()>);
41
42struct S {};
43static_assert(std::movable<S>);
44static_assert(std::movable<int S::*>);
45static_assert(std::movable<int (S::*)()>);
46static_assert(std::movable<int (S::*)() noexcept>);
47static_assert(std::movable<int (S::*)() &>);
48static_assert(std::movable<int (S::*)() & noexcept>);
49static_assert(std::movable<int (S::*)() &&>);
50static_assert(std::movable<int (S::*)() && noexcept>);
51static_assert(std::movable<int (S::*)() const>);
52static_assert(std::movable<int (S::*)() const noexcept>);
53static_assert(std::movable<int (S::*)() const&>);
54static_assert(std::movable<int (S::*)() const & noexcept>);
55static_assert(std::movable<int (S::*)() const&&>);
56static_assert(std::movable<int (S::*)() const && noexcept>);
57static_assert(std::movable<int (S::*)() volatile>);
58static_assert(std::movable<int (S::*)() volatile noexcept>);
59static_assert(std::movable<int (S::*)() volatile&>);
60static_assert(std::movable<int (S::*)() volatile & noexcept>);
61static_assert(std::movable<int (S::*)() volatile&&>);
62static_assert(std::movable<int (S::*)() volatile && noexcept>);
63static_assert(std::movable<int (S::*)() const volatile>);
64static_assert(std::movable<int (S::*)() const volatile noexcept>);
65static_assert(std::movable<int (S::*)() const volatile&>);
66static_assert(std::movable<int (S::*)() const volatile & noexcept>);
67static_assert(std::movable<int (S::*)() const volatile&&>);
68static_assert(std::movable<int (S::*)() const volatile && noexcept>);
69
70static_assert(std::movable<std::deque<int> >);
71static_assert(std::movable<std::forward_list<int> >);
72static_assert(std::movable<std::list<int> >);
73static_assert(std::movable<std::optional<std::vector<int> > >);
74static_assert(std::movable<std::vector<int> >);
75
76static_assert(std::movable<has_volatile_member>);
77static_assert(std::movable<has_array_member>);
78
79// Not objects
80static_assert(!std::movable<int&>);
81static_assert(!std::movable<int const&>);
82static_assert(!std::movable<int volatile&>);
83static_assert(!std::movable<int const volatile&>);
84static_assert(!std::movable<int&&>);
85static_assert(!std::movable<int const&&>);
86static_assert(!std::movable<int volatile&&>);
87static_assert(!std::movable<int const volatile&&>);
88static_assert(!std::movable<int()>);
89static_assert(!std::movable<int (&)()>);
90static_assert(!std::movable<int[5]>);
91
92// Core non-move assignable.
93static_assert(!std::movable<int const>);
94static_assert(!std::movable<int const volatile>);
95
96static_assert(!std::movable<DeletedMoveCtor>);
97static_assert(!std::movable<ImplicitlyDeletedMoveCtor>);
98static_assert(!std::movable<DeletedMoveAssign>);
99static_assert(!std::movable<ImplicitlyDeletedMoveAssign>);
100static_assert(!std::movable<NonMovable>);
101static_assert(!std::movable<DerivedFromNonMovable>);
102static_assert(!std::movable<HasANonMovable>);
103
104static_assert(std::movable<cpp03_friendly>);
105static_assert(std::movable<const_move_ctor>);
106static_assert(std::movable<volatile_move_ctor>);
107static_assert(std::movable<cv_move_ctor>);
108static_assert(std::movable<multi_param_move_ctor>);
109static_assert(!std::movable<not_quite_multi_param_move_ctor>);
110
111static_assert(!std::assignable_from<copy_with_mutable_parameter&,
112 copy_with_mutable_parameter>);
113static_assert(!std::movable<copy_with_mutable_parameter>);
114
115static_assert(!std::movable<const_move_assignment>);
116static_assert(std::movable<volatile_move_assignment>);
117static_assert(!std::movable<cv_move_assignment>);
118
119static_assert(!std::movable<const_move_assign_and_traditional_move_assign>);
120static_assert(!std::movable<volatile_move_assign_and_traditional_move_assign>);
121static_assert(!std::movable<cv_move_assign_and_traditional_move_assign>);
122static_assert(std::movable<const_move_assign_and_default_ops>);
123static_assert(std::movable<volatile_move_assign_and_default_ops>);
124static_assert(std::movable<cv_move_assign_and_default_ops>);
125
126static_assert(!std::movable<has_const_member>);
127static_assert(!std::movable<has_cv_member>);
128static_assert(!std::movable<has_lvalue_reference_member>);
129static_assert(!std::movable<has_rvalue_reference_member>);
130static_assert(!std::movable<has_function_ref_member>);
131
132static_assert(std::movable<deleted_assignment_from_const_rvalue>);
133
134// `move_constructible and assignable_from<T&, T>` implies `swappable<T>`,
135// so there's nothing to test for the case of non-swappable.
136

source code of libcxx/test/std/concepts/concepts.object/movable.compile.pass.cpp