]> gcc.gnu.org Git - gcc.git/blame - libstdc++-v3/testsuite/20_util/is_assignable/value.cc
git://gcc.gnu.org / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update copyright years.
[gcc.git] / libstdc++-v3 / testsuite / 20_util / is_assignable / value.cc
CommitLineData
4415f7a5 1// { dg-options "-std=gnu++11" }
f263981a
PC		 2// { dg-do compile }
3
5624e564 4// Copyright (C) 2011-2015 Free Software Foundation, Inc.
f263981a
PC		 5//
6// This file is part of the GNU ISO C++ Library. This library is free
7// software; you can redistribute it and/or modify it under the
8// terms of the GNU General Public License as published by the
9// Free Software Foundation; either version 3, or (at your option)
10// any later version.
11//
12// This library is distributed in the hope that it will be useful,
13// but WITHOUT ANY WARRANTY; without even the implied warranty of
14// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15// GNU General Public License for more details.
16//
17// You should have received a copy of the GNU General Public License along
18// with this library; see the file COPYING3. If not see
19// <http://www.gnu.org/licenses/>.
20
21#include <type_traits>
22#include <initializer_list>
23#include <testsuite_tr1.h>
24
25using namespace __gnu_test::assign;
26
27static_assert(std::is_assignable<int&, int>::value, "Error");
28static_assert(std::is_assignable<int&, const int>::value, "Error");
29static_assert(std::is_assignable<int&, int&>::value, "Error");
30static_assert(std::is_assignable<int&, const int&>::value, "Error");
31
32static_assert(!std::is_assignable<int, int>::value, "Error");
33static_assert(!std::is_assignable<int, const int>::value, "Error");
34static_assert(!std::is_assignable<int, int&>::value, "Error");
35static_assert(!std::is_assignable<int, const int&>::value, "Error");
36
37static_assert(!std::is_assignable<const int, int>::value, "Error");
38static_assert(!std::is_assignable<const int, const int>::value, "Error");
39static_assert(!std::is_assignable<const int, int&>::value, "Error");
40static_assert(!std::is_assignable<const int, const int&>::value, "Error");
41
42static_assert(!std::is_assignable<const int&, int>::value, "Error");
43static_assert(!std::is_assignable<const int&, const int>::value, "Error");
44static_assert(!std::is_assignable<const int&, int&>::value, "Error");
45static_assert(!std::is_assignable<const int&, const int&>::value, "Error");
46
47static_assert(std::is_assignable<Empty&, Empty>::value, "Error");
48static_assert(std::is_assignable<Empty&, const Empty>::value, "Error");
49static_assert(std::is_assignable<Empty&, Empty&>::value, "Error");
50static_assert(std::is_assignable<Empty&, const Empty&>::value, "Error");
51static_assert(std::is_assignable<Empty, Empty>::value, "Error");
52static_assert(std::is_assignable<Empty, const Empty>::value, "Error");
53static_assert(std::is_assignable<Empty, Empty&>::value, "Error");
54static_assert(std::is_assignable<Empty, const Empty&>::value, "Error");
55
56static_assert(std::is_assignable<B&, B>::value, "Error");
57static_assert(std::is_assignable<B&, const B>::value, "Error");
58static_assert(std::is_assignable<B&, B&>::value, "Error");
59static_assert(std::is_assignable<B&, const B&>::value, "Error");
60static_assert(std::is_assignable<B, B>::value, "Error");
61static_assert(std::is_assignable<B, const B>::value, "Error");
62static_assert(std::is_assignable<B, B&>::value, "Error");
63static_assert(std::is_assignable<B, const B&>::value, "Error");
64
65static_assert(std::is_assignable<bool&, bool>::value, "Error");
66static_assert(std::is_assignable<bool&, const bool>::value, "Error");
67static_assert(std::is_assignable<bool&, bool&>::value, "Error");
68static_assert(std::is_assignable<bool&, const bool&>::value, "Error");
69
70// bool is a fundamental type that does not allow assignment to an rvalue:
71static_assert(!std::is_assignable<bool, bool>::value, "Error");
72static_assert(!std::is_assignable<bool, const bool>::value, "Error");
73static_assert(!std::is_assignable<bool, bool&>::value, "Error");
74static_assert(!std::is_assignable<bool, const bool&>::value, "Error");
75
76static_assert(std::is_assignable<std::nullptr_t&,
77std::nullptr_t>::value, "Error");
78static_assert(std::is_assignable<std::nullptr_t&, const
79std::nullptr_t>::value, "Error");
80static_assert(std::is_assignable<std::nullptr_t&,
81std::nullptr_t&>::value, "Error");
82static_assert(std::is_assignable<std::nullptr_t&, const
83std::nullptr_t&>::value, "Error");
84
85// std::nullptr_t is a fundamental type that does not allow
86// assignment to an rvalue:
87static_assert(!std::is_assignable<std::nullptr_t,
88std::nullptr_t>::value, "Error");
89static_assert(!std::is_assignable<std::nullptr_t, const
90std::nullptr_t>::value, "Error");
91static_assert(!std::is_assignable<std::nullptr_t,
92std::nullptr_t&>::value, "Error");
93static_assert(!std::is_assignable<std::nullptr_t, const
94std::nullptr_t&>::value, "Error");
95
96static_assert(std::is_assignable<E&, E>::value, "Error");
97static_assert(std::is_assignable<E&, const E>::value, "Error");
98static_assert(std::is_assignable<E&, E&>::value, "Error");
99static_assert(std::is_assignable<E&, const E&>::value, "Error");
100
101static_assert(std::is_assignable<int&, E>::value, "Error");
102static_assert(std::is_assignable<int&, const E>::value, "Error");
103static_assert(std::is_assignable<int&, E&>::value, "Error");
104static_assert(std::is_assignable<int&, const E&>::value, "Error");
105
106static_assert(!std::is_assignable<E&, int>::value, "Error");
107static_assert(!std::is_assignable<E&, const int>::value, "Error");
108static_assert(!std::is_assignable<E&, int&>::value, "Error");
109static_assert(!std::is_assignable<E&, const int&>::value, "Error");
110
111static_assert(!std::is_assignable<E&, E2>::value, "Error");
112static_assert(!std::is_assignable<E&, const E2>::value, "Error");
113static_assert(!std::is_assignable<E&, E2&>::value, "Error");
114static_assert(!std::is_assignable<E&, const E2&>::value, "Error");
115
116// E is not a class type and thus does not allow assignment to an rvalue:
117static_assert(!std::is_assignable<E, E>::value, "Error");
118static_assert(!std::is_assignable<E, const E>::value, "Error");
119static_assert(!std::is_assignable<E, E&>::value, "Error");
120static_assert(!std::is_assignable<E, const E&>::value, "Error");
121
122static_assert(std::is_assignable<SE&, SE>::value, "Error");
123static_assert(std::is_assignable<SE&, const SE>::value, "Error");
124static_assert(std::is_assignable<SE&, SE&>::value, "Error");
125static_assert(std::is_assignable<SE&, const SE&>::value, "Error");
126
127static_assert(!std::is_assignable<int&, SE>::value, "Error");
128static_assert(!std::is_assignable<int&, const SE>::value, "Error");
129static_assert(!std::is_assignable<int&, SE&>::value, "Error");
130static_assert(!std::is_assignable<int&, const SE&>::value, "Error");
131
132static_assert(!std::is_assignable<SE&, int>::value, "Error");
133static_assert(!std::is_assignable<SE&, const int>::value, "Error");
134static_assert(!std::is_assignable<SE&, int&>::value, "Error");
135static_assert(!std::is_assignable<SE&, const int&>::value, "Error");
136
137// SE is not a class type and thus does not allow assignment to an rvalue:
138static_assert(!std::is_assignable<SE, SE>::value, "Error");
139static_assert(!std::is_assignable<SE, const SE>::value, "Error");
140static_assert(!std::is_assignable<SE, SE&>::value, "Error");
141static_assert(!std::is_assignable<SE, const SE&>::value, "Error");
142
143static_assert(std::is_assignable<AnyAssign&, int>::value, "Error");
144static_assert(std::is_assignable<AnyAssign&, std::nullptr_t>::value, "Error");
145static_assert(std::is_assignable<AnyAssign&, E>::value, "Error");
146static_assert(std::is_assignable<AnyAssign&, SE>::value, "Error");
147static_assert(std::is_assignable<AnyAssign&, Empty>::value, "Error");
148static_assert(std::is_assignable<AnyAssign&, U>::value, "Error");
149static_assert(std::is_assignable<AnyAssign&, int&>::value, "Error");
150static_assert(std::is_assignable<AnyAssign&, std::nullptr_t&>::value, "Error");
151static_assert(std::is_assignable<AnyAssign&, E&>::value, "Error");
152static_assert(std::is_assignable<AnyAssign&, SE&>::value, "Error");
153static_assert(std::is_assignable<AnyAssign&, Empty&>::value, "Error");
154static_assert(std::is_assignable<AnyAssign&, U&>::value, "Error");
155static_assert(std::is_assignable<AnyAssign&, AnyAssign>::value, "Error");
156static_assert(std::is_assignable<AnyAssign&,
157std::initializer_list<int>>::value, "Error");
158
159static_assert(std::is_assignable<AnyAssign&, int[1]>::value, "Error");
160static_assert(std::is_assignable<AnyAssign&,
161std::nullptr_t[1]>::value, "Error");
162static_assert(std::is_assignable<AnyAssign&, E[1]>::value, "Error");
163static_assert(std::is_assignable<AnyAssign&, SE[1]>::value, "Error");
164static_assert(std::is_assignable<AnyAssign&, int(&)[1]>::value, "Error");
165static_assert(std::is_assignable<AnyAssign&,
166std::nullptr_t(&)[1]>::value, "Error");
167static_assert(std::is_assignable<AnyAssign&, E(&)[1]>::value, "Error");
168static_assert(std::is_assignable<AnyAssign&, SE(&)[1]>::value, "Error");
169
170static_assert(std::is_assignable<int&, E>::value, "Error");
171static_assert(!std::is_assignable<int&, SE>::value, "Error");
172static_assert(std::is_assignable<bool&, E>::value, "Error");
173static_assert(!std::is_assignable<bool&, SE>::value, "Error");
174static_assert(std::is_assignable<bool&, void*>::value, "Error");
175static_assert(std::is_assignable<bool&, int B::*>::value, "Error");
176static_assert(std::is_assignable<bool&, void*>::value, "Error");
3c61a5ba 177static_assert(!std::is_assignable<bool&, std::nullptr_t>::value, "Error");
f263981a
PC		 178
179static_assert(std::is_assignable<std::nullptr_t&,
180std::nullptr_t>::value, "Error");
181static_assert(std::is_assignable<void*&, std::nullptr_t>::value, "Error");
182static_assert(std::is_assignable<int*&, std::nullptr_t>::value, "Error");
183static_assert(std::is_assignable<int B::*&, std::nullptr_t>::value, "Error");
184static_assert(!std::is_assignable<std::nullptr_t&, bool>::value, "Error");
185static_assert(!std::is_assignable<void*&, bool>::value, "Error");
186static_assert(!std::is_assignable<E&, bool>::value, "Error");
187static_assert(!std::is_assignable<SE&, bool>::value, "Error");
188
189static_assert(std::is_assignable<std::initializer_list<int>&,
190std::initializer_list<int>>::value, "Error");
191static_assert(std::is_assignable<std::initializer_list<int>&,
192std::initializer_list<int>&&>::value, "Error");
193static_assert(std::is_assignable<std::initializer_list<int>&, const
194std::initializer_list<int>&&>::value, "Error");
195static_assert(std::is_assignable<std::initializer_list<int>&,
196std::initializer_list<int>&>::value, "Error");
197static_assert(std::is_assignable<std::initializer_list<int>&, const
198std::initializer_list<int>&>::value, "Error");
199static_assert(!std::is_assignable<const std::initializer_list<int>&,
200std::initializer_list<int>>::value, "Error");
201
202static_assert(!std::is_assignable<const AnyAssign&, int>::value, "Error");
203static_assert(!std::is_assignable<AnyAssign&, void>::value, "Error");
204
205static_assert(!std::is_assignable<void, int>::value, "Error");
206static_assert(!std::is_assignable<const void, int>::value, "Error");
207static_assert(!std::is_assignable<int, void>::value, "Error");
208static_assert(!std::is_assignable<int, const void>::value, "Error");
209static_assert(!std::is_assignable<const int, void>::value, "Error");
210static_assert(!std::is_assignable<const int, const void>::value, "Error");
211static_assert(!std::is_assignable<int&, void>::value, "Error");
212static_assert(!std::is_assignable<int&, const void>::value, "Error");
213static_assert(!std::is_assignable<const int&, void>::value, "Error");
214static_assert(!std::is_assignable<const int&, const void>::value, "Error");
215static_assert(!std::is_assignable<void, void>::value, "Error");
216static_assert(!std::is_assignable<const void, void>::value, "Error");
217static_assert(!std::is_assignable<const void, const void>::value, "Error");
218
219static_assert(!std::is_assignable<int[1], int[1]>::value, "Error");
220static_assert(!std::is_assignable<int(&)[1], int[1]>::value, "Error");
221static_assert(!std::is_assignable<int(&)[1], int(&)[1]>::value, "Error");
222static_assert(!std::is_assignable<int[2], int[1]>::value, "Error");
223static_assert(!std::is_assignable<int(&)[2], int[1]>::value, "Error");
224static_assert(!std::is_assignable<int(&)[2], int(&)[1]>::value, "Error");
225static_assert(!std::is_assignable<int[1], void>::value, "Error");
226static_assert(!std::is_assignable<int(&)[1], void>::value, "Error");
227static_assert(!std::is_assignable<void, int[1]>::value, "Error");
228static_assert(!std::is_assignable<void, int(&)[1]>::value, "Error");
229
230static_assert(!std::is_assignable<int[], int[]>::value, "Error");
231static_assert(!std::is_assignable<int(&)[], int[]>::value, "Error");
232static_assert(!std::is_assignable<int(&)[], int(&)[]>::value, "Error");
233static_assert(!std::is_assignable<int[1], int[]>::value, "Error");
234static_assert(!std::is_assignable<int(&)[1], int[]>::value, "Error");
235static_assert(!std::is_assignable<int(&)[1], int(&)[]>::value, "Error");
236static_assert(!std::is_assignable<int[], int[1]>::value, "Error");
237static_assert(!std::is_assignable<int(&)[], int[1]>::value, "Error");
238static_assert(!std::is_assignable<int(&)[], int(&)[1]>::value, "Error");
239static_assert(!std::is_assignable<int[], void>::value, "Error");
240static_assert(!std::is_assignable<int(&)[], void>::value, "Error");
241static_assert(!std::is_assignable<void, int[]>::value, "Error");
242static_assert(!std::is_assignable<void, int(&)[]>::value, "Error");
243
244static_assert(std::is_assignable<DelCopyAssign&,
245DelCopyAssign>::value, "Error");
246static_assert(!std::is_assignable<DelCopyAssign&, const
247DelCopyAssign>::value, "Error");
248static_assert(!std::is_assignable<DelCopyAssign&,
249DelCopyAssign&>::value, "Error");
250static_assert(!std::is_assignable<DelCopyAssign&, const
251DelCopyAssign&>::value, "Error");
252static_assert(!std::is_assignable<DelCopyAssign&, void>::value, "Error");
253static_assert(!std::is_assignable<DelCopyAssign&, void()>::value, "Error");
254static_assert(!std::is_assignable<DelCopyAssign&, void(&)()>::value, "Error");
255static_assert(!std::is_assignable<DelCopyAssign&, int>::value, "Error");
256
257static_assert(std::is_assignable<DelAnyAssign&,
258DelAnyAssign&&>::value, "Error");
259static_assert(std::is_assignable<DelAnyAssign&, const
260DelAnyAssign&>::value, "Error");
261static_assert(std::is_assignable<DelAnyAssign,
262DelAnyAssign&&>::value, "Error");
263static_assert(std::is_assignable<DelAnyAssign, const
264DelAnyAssign&>::value, "Error");
265
266static_assert(!std::is_assignable<const DelAnyAssign&,
267DelAnyAssign&&>::value, "Error");
268static_assert(!std::is_assignable<const DelAnyAssign&, const
269DelAnyAssign&>::value, "Error");
270static_assert(!std::is_assignable<const DelAnyAssign,
271DelAnyAssign&&>::value, "Error");
272static_assert(!std::is_assignable<const DelAnyAssign, const
273DelAnyAssign&>::value, "Error");
274
275static_assert(!std::is_assignable<DelAnyAssign&, int>::value, "Error");
276static_assert(!std::is_assignable<DelAnyAssign&, int&>::value, "Error");
277static_assert(!std::is_assignable<DelAnyAssign&, const int&>::value, "Error");
278static_assert(!std::is_assignable<DelAnyAssign&, void>::value, "Error");
279static_assert(!std::is_assignable<DelAnyAssign&, void()>::value, "Error");
89898034
DK		 280static_assert(!std::is_assignable<DelAnyAssign&,
281 void() const>::value, "Error");
f263981a
PC		 282static_assert(!std::is_assignable<DelAnyAssign&, void(&)()>::value, "Error");
283static_assert(!std::is_assignable<DelAnyAssign&, void(&&)()>::value, "Error");
284static_assert(!std::is_assignable<DelAnyAssign&,
285std::nullptr_t>::value, "Error");
286static_assert(!std::is_assignable<DelAnyAssign&,
287std::nullptr_t&>::value, "Error");
288static_assert(!std::is_assignable<DelAnyAssign&,
289std::initializer_list<int>>::value, "Error");
290static_assert(!std::is_assignable<DelAnyAssign&,
291std::initializer_list<int>&>::value, "Error");
292static_assert(!std::is_assignable<DelAnyAssign&, bool>::value, "Error");
293static_assert(!std::is_assignable<DelAnyAssign&, bool&>::value, "Error");
294static_assert(!std::is_assignable<DelAnyAssign&, E>::value, "Error");
295static_assert(!std::is_assignable<DelAnyAssign&, E&>::value, "Error");
296static_assert(!std::is_assignable<DelAnyAssign&, SE>::value, "Error");
297static_assert(!std::is_assignable<DelAnyAssign&, SE&>::value, "Error");
298static_assert(!std::is_assignable<DelAnyAssign&, Empty>::value, "Error");
299static_assert(!std::is_assignable<DelAnyAssign&, Empty&>::value, "Error");
300static_assert(!std::is_assignable<DelAnyAssign&, B>::value, "Error");
301static_assert(!std::is_assignable<DelAnyAssign&, B&>::value, "Error");
302static_assert(!std::is_assignable<DelAnyAssign&, U>::value, "Error");
303static_assert(!std::is_assignable<DelAnyAssign&, U&>::value, "Error");
304static_assert(!std::is_assignable<DelAnyAssign&, void*>::value, "Error");
305static_assert(!std::is_assignable<DelAnyAssign&, int*>::value, "Error");
306static_assert(!std::is_assignable<DelAnyAssign&, B*>::value, "Error");
307static_assert(!std::is_assignable<DelAnyAssign&, D*>::value, "Error");
308static_assert(!std::is_assignable<DelAnyAssign&, int B::*>::value, "Error");
309static_assert(!std::is_assignable<DelAnyAssign&, int D::*>::value, "Error");
310static_assert(!std::is_assignable<DelAnyAssign&, int[]>::value, "Error");
311static_assert(!std::is_assignable<DelAnyAssign&, int[1]>::value, "Error");
312static_assert(!std::is_assignable<DelAnyAssign&, int(&)[]>::value, "Error");
313static_assert(!std::is_assignable<DelAnyAssign&, int(&)[1]>::value, "Error");
314
315static_assert(!std::is_assignable<void(), void>::value, "Error");
316static_assert(!std::is_assignable<void, void()>::value, "Error");
317static_assert(!std::is_assignable<void(), void()>::value, "Error");
318
319static_assert(!std::is_assignable<void(&)(), void>::value, "Error");
320static_assert(!std::is_assignable<void, void(&)()>::value, "Error");
321static_assert(!std::is_assignable<void(&)(), void(&)()>::value, "Error");
322static_assert(!std::is_assignable<void(&)(), void()>::value, "Error");
323static_assert(!std::is_assignable<void(), void(&)()>::value, "Error");
324
325static_assert(std::is_assignable<int&, ImplicitTo<int>>::value, "Error");
326static_assert(!std::is_assignable<int&, ExplicitTo<int>>::value, "Error");
327static_assert(!std::is_assignable<int, ImplicitTo<int>>::value, "Error");
328static_assert(!std::is_assignable<int, ExplicitTo<int>>::value, "Error");
329static_assert(!std::is_assignable<const int, ImplicitTo<int>>::value, "Error");
330static_assert(!std::is_assignable<const int, ExplicitTo<int>>::value, "Error");
331static_assert(!std::is_assignable<const int&,
332ImplicitTo<int>>::value, "Error");
333static_assert(!std::is_assignable<const int&,
334ExplicitTo<int>>::value, "Error");
335
336static_assert(std::is_assignable<DelImplicitTo<int>&,
337DelImplicitTo<int>>::value, "Error");
338static_assert(std::is_assignable<DelImplicitTo<int>,
339DelImplicitTo<int>>::value, "Error");
340static_assert(!std::is_assignable<int&, DelImplicitTo<int>>::value, "Error");
341static_assert(!std::is_assignable<int, DelImplicitTo<int>>::value, "Error");
342static_assert(!std::is_assignable<const int&,
343DelImplicitTo<int>>::value, "Error");
344static_assert(!std::is_assignable<const int,
345DelImplicitTo<int>>::value, "Error");
346static_assert(!std::is_assignable<int&, DelExplicitTo<int>>::value, "Error");
347static_assert(!std::is_assignable<int, DelExplicitTo<int>>::value, "Error");
348static_assert(!std::is_assignable<const int&,
349DelExplicitTo<int>>::value, "Error");
350static_assert(!std::is_assignable<const int,
351DelExplicitTo<int>>::value, "Error");
352
353static_assert(std::is_assignable<B&, B>::value, "Error");
354static_assert(std::is_assignable<B&, D>::value, "Error");
355static_assert(std::is_assignable<B&, B&>::value, "Error");
356static_assert(std::is_assignable<B&, D&>::value, "Error");
357static_assert(!std::is_assignable<const B&, B&>::value, "Error");
358static_assert(!std::is_assignable<const B&, D&>::value, "Error");
359static_assert(!std::is_assignable<D&, B>::value, "Error");
360static_assert(!std::is_assignable<D&, B&>::value, "Error");
361
362static_assert(std::is_assignable<B*&, B*>::value, "Error");
363static_assert(std::is_assignable<B*&, D*>::value, "Error");
364static_assert(std::is_assignable<const B*&, D*>::value, "Error");
365static_assert(std::is_assignable<const B*&, const D*>::value, "Error");
366static_assert(std::is_assignable<B*&, B*&>::value, "Error");
367static_assert(std::is_assignable<B*&, D*&>::value, "Error");
368static_assert(std::is_assignable<const B*&, B*&>::value, "Error");
369static_assert(std::is_assignable<const B*&, D*&>::value, "Error");
370static_assert(!std::is_assignable<B* const&, B*&>::value, "Error");
371static_assert(!std::is_assignable<B* const&, D*&>::value, "Error");
372static_assert(!std::is_assignable<D*&, B*>::value, "Error");
373static_assert(!std::is_assignable<D*&, B*&>::value, "Error");
374
375static_assert(std::is_assignable<MO&, MO>::value, "Error");
376static_assert(std::is_assignable<MO&, MO&&>::value, "Error");
377static_assert(std::is_assignable<MO, MO>::value, "Error");
378static_assert(std::is_assignable<MO, MO&&>::value, "Error");
379
380static_assert(!std::is_assignable<const MO&, MO>::value, "Error");
381static_assert(!std::is_assignable<const MO&, MO&&>::value, "Error");
382static_assert(!std::is_assignable<MO&, const MO&&>::value, "Error");
383static_assert(!std::is_assignable<MO&, MO&>::value, "Error");
384static_assert(!std::is_assignable<MO&, const MO&>::value, "Error");
385static_assert(!std::is_assignable<const MO, MO>::value, "Error");
386static_assert(!std::is_assignable<const MO, MO&&>::value, "Error");
387static_assert(!std::is_assignable<MO, const MO&&>::value, "Error");
388static_assert(!std::is_assignable<MO, MO&>::value, "Error");
389static_assert(!std::is_assignable<MO, const MO&>::value, "Error");
390
391static_assert(!std::is_assignable<NontrivialUnion&,
392NontrivialUnion>::value, "Error");
393static_assert(!std::is_assignable<NontrivialUnion&,
394NontrivialUnion&&>::value, "Error");
395static_assert(!std::is_assignable<NontrivialUnion&,
396NontrivialUnion&>::value, "Error");
397static_assert(!std::is_assignable<NontrivialUnion&, const
398NontrivialUnion&>::value, "Error");
399static_assert(!std::is_assignable<NontrivialUnion&, const
400NontrivialUnion&&>::value, "Error");
401
402static_assert(std::is_assignable<Abstract&, Abstract>::value, "Error");
403static_assert(std::is_assignable<Abstract&, Abstract&&>::value, "Error");
404static_assert(std::is_assignable<Abstract&, Abstract&>::value, "Error");
405static_assert(std::is_assignable<Abstract&, const Abstract&>::value, "Error");
406static_assert(std::is_assignable<Abstract&, const Abstract&&>::value, "Error");
407static_assert(std::is_assignable<Abstract&&, Abstract>::value, "Error");
408static_assert(std::is_assignable<Abstract&&, Abstract&&>::value, "Error");
409static_assert(std::is_assignable<Abstract&&, Abstract&>::value, "Error");
410static_assert(std::is_assignable<Abstract&&, const Abstract&>::value, "Error");
411static_assert(std::is_assignable<Abstract&&, const
412Abstract&&>::value, "Error");
413
414static_assert(std::is_assignable<AbstractDelDtor&,
415AbstractDelDtor>::value, "Error");
416static_assert(std::is_assignable<AbstractDelDtor&,
417AbstractDelDtor&&>::value, "Error");
418static_assert(std::is_assignable<AbstractDelDtor&,
419AbstractDelDtor&>::value, "Error");
420static_assert(std::is_assignable<AbstractDelDtor&, const
421AbstractDelDtor&>::value, "Error");
422static_assert(std::is_assignable<AbstractDelDtor&, const
423AbstractDelDtor&&>::value, "Error");
424static_assert(std::is_assignable<AbstractDelDtor&&,
425AbstractDelDtor>::value, "Error");
426static_assert(std::is_assignable<AbstractDelDtor&&,
427AbstractDelDtor&&>::value, "Error");
428static_assert(std::is_assignable<AbstractDelDtor&&,
429AbstractDelDtor&>::value, "Error");
430static_assert(std::is_assignable<AbstractDelDtor&&, const
431AbstractDelDtor&>::value, "Error");
432static_assert(std::is_assignable<AbstractDelDtor&&, const
433AbstractDelDtor&&>::value, "Error");
434
435static_assert(std::is_assignable<DelDef&, DelDef>::value, "Error");
436static_assert(std::is_assignable<DelDef&, DelDef&&>::value, "Error");
437static_assert(std::is_assignable<DelDef&, DelDef&>::value, "Error");
438static_assert(std::is_assignable<DelDef&, const DelDef&>::value, "Error");
439static_assert(std::is_assignable<DelDef&, const DelDef&&>::value, "Error");
440static_assert(std::is_assignable<DelDef&&, DelDef>::value, "Error");
441static_assert(std::is_assignable<DelDef&&, DelDef&&>::value, "Error");
442static_assert(std::is_assignable<DelDef&&, DelDef&>::value, "Error");
443static_assert(std::is_assignable<DelDef&&, const DelDef&>::value, "Error");
444static_assert(std::is_assignable<DelDef&&, const DelDef&&>::value, "Error");
445
446static_assert(std::is_assignable<Ellipsis&, Ellipsis>::value, "Error");
447static_assert(std::is_assignable<Ellipsis&, const Ellipsis>::value, "Error");
448static_assert(std::is_assignable<Ellipsis&, Ellipsis&>::value, "Error");
449static_assert(std::is_assignable<Ellipsis&, const Ellipsis&>::value, "Error");
450static_assert(std::is_assignable<Ellipsis, Ellipsis>::value, "Error");
451static_assert(std::is_assignable<Ellipsis, const Ellipsis>::value, "Error");
452static_assert(std::is_assignable<Ellipsis, Ellipsis&>::value, "Error");
453static_assert(std::is_assignable<Ellipsis, const Ellipsis&>::value, "Error");
454
455static_assert(!std::is_assignable<Ellipsis&, void>::value, "Error");
456
457static_assert(std::is_assignable<Ellipsis&, int>::value, "Error");
458static_assert(std::is_assignable<Ellipsis&, const int>::value, "Error");
459static_assert(std::is_assignable<Ellipsis&, int&>::value, "Error");
460static_assert(std::is_assignable<Ellipsis&, const int&>::value, "Error");
461static_assert(std::is_assignable<Ellipsis&, Empty>::value, "Error");
462static_assert(std::is_assignable<Ellipsis&, const Empty>::value, "Error");
463static_assert(std::is_assignable<Ellipsis&, Empty&>::value, "Error");
464static_assert(std::is_assignable<Ellipsis&, const Empty&>::value, "Error");
465static_assert(std::is_assignable<Ellipsis&, E>::value, "Error");
466static_assert(std::is_assignable<Ellipsis&, const E>::value, "Error");
467static_assert(std::is_assignable<Ellipsis&, E&>::value, "Error");
468static_assert(std::is_assignable<Ellipsis&, const E&>::value, "Error");
469static_assert(std::is_assignable<Ellipsis&, SE>::value, "Error");
470static_assert(std::is_assignable<Ellipsis&, const SE>::value, "Error");
471static_assert(std::is_assignable<Ellipsis&, SE&>::value, "Error");
472static_assert(std::is_assignable<Ellipsis&, const SE&>::value, "Error");
473static_assert(std::is_assignable<Ellipsis&, bool>::value, "Error");
474static_assert(std::is_assignable<Ellipsis&, const bool>::value, "Error");
475static_assert(std::is_assignable<Ellipsis&, bool&>::value, "Error");
476static_assert(std::is_assignable<Ellipsis&, const bool&>::value, "Error");
477static_assert(std::is_assignable<Ellipsis&, std::nullptr_t>::value, "Error");
478static_assert(std::is_assignable<Ellipsis&, const
479std::nullptr_t>::value, "Error");
480static_assert(std::is_assignable<Ellipsis&, std::nullptr_t&>::value, "Error");
481static_assert(std::is_assignable<Ellipsis&, const
482std::nullptr_t&>::value, "Error");
483static_assert(std::is_assignable<Ellipsis&, void*>::value, "Error");
484static_assert(std::is_assignable<Ellipsis&, const void*>::value, "Error");
485static_assert(std::is_assignable<Ellipsis&, void*&>::value, "Error");
486static_assert(std::is_assignable<Ellipsis&, const void*&>::value, "Error");
487static_assert(std::is_assignable<Ellipsis&, void()>::value, "Error");
488static_assert(std::is_assignable<Ellipsis&, void(&)()>::value, "Error");
489
490static_assert(std::is_assignable<DelEllipsis&, DelEllipsis>::value, "Error");
491static_assert(std::is_assignable<DelEllipsis&, const
492DelEllipsis>::value, "Error");
493static_assert(std::is_assignable<DelEllipsis&, DelEllipsis&>::value, "Error");
494static_assert(std::is_assignable<DelEllipsis&, const
495DelEllipsis&>::value, "Error");
496static_assert(std::is_assignable<DelEllipsis, DelEllipsis>::value, "Error");
497static_assert(std::is_assignable<DelEllipsis, const
498DelEllipsis>::value, "Error");
499static_assert(std::is_assignable<DelEllipsis, DelEllipsis&>::value, "Error");
500static_assert(std::is_assignable<DelEllipsis, const
501DelEllipsis&>::value, "Error");
502
503static_assert(!std::is_assignable<DelEllipsis&, void>::value, "Error");
504static_assert(!std::is_assignable<DelEllipsis&, int>::value, "Error");
505static_assert(!std::is_assignable<DelEllipsis&, const int>::value, "Error");
506static_assert(!std::is_assignable<DelEllipsis&, int&>::value, "Error");
507static_assert(!std::is_assignable<DelEllipsis&, const int&>::value, "Error");
508static_assert(!std::is_assignable<DelEllipsis&, Empty>::value, "Error");
509static_assert(!std::is_assignable<DelEllipsis&, const Empty>::value, "Error");
510static_assert(!std::is_assignable<DelEllipsis&, Empty&>::value, "Error");
511static_assert(!std::is_assignable<DelEllipsis&, const Empty&>::value, "Error");
512static_assert(!std::is_assignable<DelEllipsis&, E>::value, "Error");
513static_assert(!std::is_assignable<DelEllipsis&, const E>::value, "Error");
514static_assert(!std::is_assignable<DelEllipsis&, E&>::value, "Error");
515static_assert(!std::is_assignable<DelEllipsis&, const E&>::value, "Error");
516static_assert(!std::is_assignable<DelEllipsis&, SE>::value, "Error");
517static_assert(!std::is_assignable<DelEllipsis&, const SE>::value, "Error");
518static_assert(!std::is_assignable<DelEllipsis&, SE&>::value, "Error");
519static_assert(!std::is_assignable<DelEllipsis&, const SE&>::value, "Error");
520static_assert(!std::is_assignable<DelEllipsis&, bool>::value, "Error");
521static_assert(!std::is_assignable<DelEllipsis&, const bool>::value, "Error");
522static_assert(!std::is_assignable<DelEllipsis&, bool&>::value, "Error");
523static_assert(!std::is_assignable<DelEllipsis&, const bool&>::value, "Error");
524static_assert(!std::is_assignable<DelEllipsis&,
525std::nullptr_t>::value, "Error");
526static_assert(!std::is_assignable<DelEllipsis&, const
527std::nullptr_t>::value, "Error");
528static_assert(!std::is_assignable<DelEllipsis&,
529std::nullptr_t&>::value, "Error");
530static_assert(!std::is_assignable<DelEllipsis&, const
531std::nullptr_t&>::value, "Error");
532static_assert(!std::is_assignable<DelEllipsis&, void*>::value, "Error");
533static_assert(!std::is_assignable<DelEllipsis&, const void*>::value, "Error");
534static_assert(!std::is_assignable<DelEllipsis&, void*&>::value, "Error");
535static_assert(!std::is_assignable<DelEllipsis&, const void*&>::value, "Error");
536static_assert(!std::is_assignable<DelEllipsis&, void()>::value, "Error");
537static_assert(!std::is_assignable<DelEllipsis&, void(&)()>::value, "Error");
538
539static_assert(std::is_assignable<FromArgs<int>&, int>::value, "Error");
540static_assert(std::is_assignable<FromArgs<int>&, const int>::value, "Error");
541static_assert(!std::is_assignable<FromArgs<int>&,
542ImplicitTo<int>>::value, "Error");
543static_assert(!std::is_assignable<FromArgs<int>&, ImplicitTo<const
544int>>::value, "Error");
545static_assert(!std::is_assignable<FromArgs<int>&,
546ExplicitTo<int>>::value, "Error");
547static_assert(!std::is_assignable<FromArgs<int>&, ExplicitTo<const
548int>>::value, "Error");
549
550static_assert(!std::is_assignable<DelFromArgs<int>&, int>::value, "Error");
551static_assert(!std::is_assignable<DelFromArgs<int>&, const
552int>::value, "Error");
553
554static_assert(std::is_assignable<void(*&)(),
555ImplicitTo<void(*)()>>::value, "Error");
556static_assert(!std::is_assignable<void(*&)(),
557ExplicitTo<void(*)()>>::value, "Error");
558
559static_assert(std::is_assignable<UAssignAll&, UAssignAll>::value, "Error");
560static_assert(std::is_assignable<UAssignAll&, const
561UAssignAll>::value, "Error");
562static_assert(std::is_assignable<UAssignAll&, UAssignAll&>::value, "Error");
563static_assert(std::is_assignable<UAssignAll&, const
564UAssignAll&>::value, "Error");
565
566static_assert(std::is_assignable<UAssignAll, UAssignAll>::value, "Error");
567static_assert(std::is_assignable<UAssignAll, const
568UAssignAll>::value, "Error");
569static_assert(std::is_assignable<UAssignAll, UAssignAll&>::value, "Error");
570static_assert(std::is_assignable<UAssignAll, const
571UAssignAll&>::value, "Error");
572
573static_assert(!std::is_assignable<UAssignAll&, void>::value, "Error");
574static_assert(!std::is_assignable<const UAssignAll&, void>::value, "Error");
575static_assert(!std::is_assignable<const UAssignAll&,
576UAssignAll>::value, "Error");
577static_assert(!std::is_assignable<const UAssignAll&, const
578UAssignAll>::value, "Error");
579static_assert(!std::is_assignable<const UAssignAll&,
580UAssignAll&>::value, "Error");
581static_assert(!std::is_assignable<const UAssignAll&, const
582UAssignAll&>::value, "Error");
89898034
DK		 583static_assert(!std::is_assignable<UAssignAll&, void() const>::value, "Error");
584static_assert(!std::is_assignable<UAssignAll&, void() &>::value, "Error");
585static_assert(!std::is_assignable<UAssignAll&, void() const volatile &&>::value, "Error");
f263981a
PC		 586
587static_assert(std::is_assignable<UAssignAll&, int>::value, "Error");
588static_assert(std::is_assignable<UAssignAll&, int&>::value, "Error");
589static_assert(std::is_assignable<UAssignAll&, E>::value, "Error");
590static_assert(std::is_assignable<UAssignAll&, E&>::value, "Error");
591static_assert(std::is_assignable<UAssignAll&, SE>::value, "Error");
592static_assert(std::is_assignable<UAssignAll&, SE&>::value, "Error");
593static_assert(std::is_assignable<UAssignAll&, double>::value, "Error");
594static_assert(std::is_assignable<UAssignAll&, double&>::value, "Error");
595static_assert(std::is_assignable<UAssignAll&, Empty>::value, "Error");
596static_assert(std::is_assignable<UAssignAll&, Empty&>::value, "Error");
597static_assert(std::is_assignable<UAssignAll&, B>::value, "Error");
598static_assert(std::is_assignable<UAssignAll&, B&>::value, "Error");
599static_assert(std::is_assignable<UAssignAll&, U>::value, "Error");
600static_assert(std::is_assignable<UAssignAll&, U&>::value, "Error");
601static_assert(std::is_assignable<UAssignAll&, std::nullptr_t>::value, "Error");
602static_assert(std::is_assignable<UAssignAll&,
603std::nullptr_t&>::value, "Error");
604static_assert(std::is_assignable<UAssignAll&, void()>::value, "Error");
605static_assert(std::is_assignable<UAssignAll&, void(&)()>::value, "Error");
f263981a
PC		 606static_assert(std::is_assignable<UAssignAll&, void(*)()>::value, "Error");
607static_assert(std::is_assignable<UAssignAll&, void(*&)()>::value, "Error");
608static_assert(std::is_assignable<UAssignAll&, int*>::value, "Error");
609static_assert(std::is_assignable<UAssignAll&, int*&>::value, "Error");
610static_assert(std::is_assignable<UAssignAll&, void*>::value, "Error");
611static_assert(std::is_assignable<UAssignAll&, void*&>::value, "Error");
612static_assert(std::is_assignable<UAssignAll&, const int*>::value, "Error");
613static_assert(std::is_assignable<UAssignAll&, const int*&>::value, "Error");
614static_assert(std::is_assignable<UAssignAll&, const void*>::value, "Error");
615static_assert(std::is_assignable<UAssignAll&, const void*&>::value, "Error");
616static_assert(std::is_assignable<UAssignAll&, int[1]>::value, "Error");
617static_assert(std::is_assignable<UAssignAll&, int(&)[1]>::value, "Error");
618static_assert(std::is_assignable<UAssignAll&, int[]>::value, "Error");
619static_assert(std::is_assignable<UAssignAll&, int(&)[]>::value, "Error");
620
621static_assert(!std::is_assignable<UDelAssignAll&, int>::value, "Error");
622static_assert(!std::is_assignable<UDelAssignAll&, int&>::value, "Error");
623static_assert(!std::is_assignable<UDelAssignAll&, E>::value, "Error");
624static_assert(!std::is_assignable<UDelAssignAll&, E&>::value, "Error");
625static_assert(!std::is_assignable<UDelAssignAll&, SE>::value, "Error");
626static_assert(!std::is_assignable<UDelAssignAll&, SE&>::value, "Error");
627static_assert(!std::is_assignable<UDelAssignAll&, double>::value, "Error");
628static_assert(!std::is_assignable<UDelAssignAll&, double&>::value, "Error");
629static_assert(!std::is_assignable<UDelAssignAll&, Empty>::value, "Error");
630static_assert(!std::is_assignable<UDelAssignAll&, Empty&>::value, "Error");
631static_assert(!std::is_assignable<UDelAssignAll&, B>::value, "Error");
632static_assert(!std::is_assignable<UDelAssignAll&, B&>::value, "Error");
633static_assert(!std::is_assignable<UDelAssignAll&, U>::value, "Error");
634static_assert(!std::is_assignable<UDelAssignAll&, U&>::value, "Error");
635static_assert(!std::is_assignable<UDelAssignAll&,
636std::nullptr_t>::value, "Error");
637static_assert(!std::is_assignable<UDelAssignAll&,
638std::nullptr_t&>::value, "Error");
639static_assert(!std::is_assignable<UDelAssignAll&, void()>::value, "Error");
640static_assert(!std::is_assignable<UDelAssignAll&, void(&)()>::value, "Error");
89898034
DK		 641static_assert(!std::is_assignable<UDelAssignAll&, void()
642 const>::value, "Error");
f263981a
PC		 643static_assert(!std::is_assignable<UDelAssignAll&, void(*)()>::value, "Error");
644static_assert(!std::is_assignable<UDelAssignAll&, void(*&)()>::value, "Error");
645static_assert(!std::is_assignable<UDelAssignAll&, int*>::value, "Error");
646static_assert(!std::is_assignable<UDelAssignAll&, int*&>::value, "Error");
647static_assert(!std::is_assignable<UDelAssignAll&, void*>::value, "Error");
648static_assert(!std::is_assignable<UDelAssignAll&, void*&>::value, "Error");
649static_assert(!std::is_assignable<UDelAssignAll&, const int*>::value, "Error");
650static_assert(!std::is_assignable<UDelAssignAll&, const
651int*&>::value, "Error");
652static_assert(!std::is_assignable<UDelAssignAll&, const
653void*>::value, "Error");
654static_assert(!std::is_assignable<UDelAssignAll&, const
655void*&>::value, "Error");
656static_assert(!std::is_assignable<UDelAssignAll&, int[1]>::value, "Error");
657static_assert(!std::is_assignable<UDelAssignAll&, int(&)[1]>::value, "Error");
658static_assert(!std::is_assignable<UDelAssignAll&, int[]>::value, "Error");
659static_assert(!std::is_assignable<UDelAssignAll&, int(&)[]>::value, "Error");
660
661static_assert(!std::is_assignable<void(&)(), std::nullptr_t>::value, "Error");
662static_assert(!std::is_assignable<std::nullptr_t, void(&)()>::value, "Error");
663static_assert(!std::is_assignable<void(&)(), int[]>::value, "Error");
664static_assert(!std::is_assignable<int[], void(&)()>::value, "Error");
665static_assert(!std::is_assignable<int[], std::nullptr_t>::value, "Error");
666static_assert(!std::is_assignable<std::nullptr_t, int[]>::value, "Error");
667static_assert(!std::is_assignable<int[1], std::nullptr_t>::value, "Error");
668static_assert(!std::is_assignable<std::nullptr_t, int[1]>::value, "Error");
669static_assert(!std::is_assignable<void, std::nullptr_t>::value, "Error");
670static_assert(!std::is_assignable<std::nullptr_t, void>::value, "Error");
671static_assert(!std::is_assignable<const D&, B&>::value, "Error");
672static_assert(!std::is_assignable<const B&, B&>::value, "Error");
673
674static_assert(std::is_assignable<B&, const D&>::value, "Error");
675static_assert(std::is_assignable<B&, const B&>::value, "Error");
676static_assert(std::is_assignable<int&, const int&>::value, "Error");
677static_assert(std::is_assignable<int&, const double&>::value, "Error");
GNU Compiler Collection
This page took 0.442206 seconds and 5 git commands to generate.