1 // Copyright (C) 2019-2021 Free Software Foundation, Inc.
2 //
3 // This file is part of the GNU ISO C++ Library.  This library is free
4 // software; you can redistribute it and/or modify it under the
5 // terms of the GNU General Public License as published by the
6 // Free Software Foundation; either version 3, or (at your option)
7 // any later version.
8 
9 // This library is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 
14 // You should have received a copy of the GNU General Public License along
15 // with this library; see the file COPYING3.  If not see
16 // <http://www.gnu.org/licenses/>.
17 
18 // { dg-options "-std=gnu++2a" }
19 // { dg-do compile { target c++2a } }
20 
21 #include <concepts>
22 
23 static_assert( std::copyable<int> );
24 static_assert( std::copyable<int*> );
25 static_assert( ! std::copyable<int&> );
26 static_assert( ! std::copyable<void> );
27 static_assert( ! std::copyable<void()> );
28 static_assert( ! std::copyable<void() noexcept> );
29 static_assert( ! std::copyable<void() const> );
30 
31 struct Trivial { };
32 static_assert( std::copyable<Trivial> );
33 
34 struct NotTrivial
35 {
NotTrivialNotTrivial36   NotTrivial(int) { }
NotTrivialNotTrivial37   NotTrivial(const NotTrivial&) { }
operator =NotTrivial38   NotTrivial& operator=(const NotTrivial&) { return *this; }
~NotTrivialNotTrivial39   ~NotTrivial() { }
40 };
41 static_assert( std::copyable<NotTrivial> );
42 
43 namespace N1
44 {
45   struct Immovable
46   {
47     Immovable() = default;
48     Immovable(Immovable&&) = delete;
49   };
50 }
51 static_assert( ! std::copyable<N1::Immovable> );
52 
53 struct Movable
54 {
55   Movable() = default;
56   Movable(Movable&&) = default;
57   Movable& operator=(Movable&&) = default;
58 };
59 static_assert( ! std::copyable<Movable> );
60 
61 struct MovableAndCopyAssignable
62 {
63   MovableAndCopyAssignable() = default;
64   MovableAndCopyAssignable(MovableAndCopyAssignable&&) = default;
65   MovableAndCopyAssignable& operator=(MovableAndCopyAssignable&&) = default;
66   MovableAndCopyAssignable& operator=(const MovableAndCopyAssignable&) = default;
67 };
68 static_assert( ! std::copyable<MovableAndCopyAssignable> );
69 
70 struct MovableAndCopyConstructible
71 {
72   MovableAndCopyConstructible() = default;
73   MovableAndCopyConstructible(MovableAndCopyConstructible&&) = default;
74   MovableAndCopyConstructible(const MovableAndCopyConstructible&) = default;
75   MovableAndCopyConstructible& operator=(MovableAndCopyConstructible&&) = default;
76 };
77 static_assert( ! std::copyable<MovableAndCopyConstructible> );
78 
79 namespace N2
80 {
81   struct Swappable
82   {
83     Swappable() = default;
84     Swappable(Swappable&&) = default;
swap(Swappable &,Swappable &)85     friend void swap(Swappable&, Swappable&) { }
86   };
87 }
88 static_assert( ! std::copyable<N2::Swappable> );
89 
90 struct NotAssignable
91 {
92   NotAssignable() = default;
93   NotAssignable(NotAssignable&&) = default;
94   NotAssignable& operator=(NotAssignable&&) = default;
95   NotAssignable(const NotAssignable&) = default;
96   NotAssignable& operator=(const NotAssignable&) = delete;
swap(NotAssignable &,NotAssignable &)97   friend void swap(NotAssignable&, NotAssignable&) { }
98 };
99 static_assert( ! std::copyable<NotAssignable> );
100 
101 struct NotSwappable
102 {
103   NotSwappable() = default;
104   NotSwappable(const NotSwappable&) = default;
105   NotSwappable& operator=(const NotSwappable&) = default;
106 };
107 void swap(NotSwappable&, NotSwappable&) = delete;
108 static_assert( std::copyable<NotSwappable> ); // ranges::swap still works!
109