1 // { dg-options "-std=gnu++17" }
2 // { dg-do compile }
3
4 // Copyright (C) 2016-2020 Free Software Foundation, Inc.
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 <variant>
22 #include <string>
23 #include <vector>
24
25 using namespace std;
26
27 struct AllDeleted
28 {
29 AllDeleted() = delete;
30 AllDeleted(const AllDeleted&) = delete;
31 AllDeleted(AllDeleted&&) = delete;
32 AllDeleted& operator=(const AllDeleted&) = delete;
33 AllDeleted& operator=(AllDeleted&&) = delete;
34 };
35
36 struct Empty
37 {
EmptyEmpty38 Empty() { };
EmptyEmpty39 Empty(const Empty&) { };
EmptyEmpty40 Empty(Empty&&) { };
operator =Empty41 Empty& operator=(const Empty&) { return *this; };
operator =Empty42 Empty& operator=(Empty&&) { return *this; };
43 };
44
45 struct DefaultNoexcept
46 {
47 DefaultNoexcept() noexcept = default;
48 DefaultNoexcept(const DefaultNoexcept&) noexcept = default;
49 DefaultNoexcept(DefaultNoexcept&&) noexcept = default;
50 DefaultNoexcept& operator=(const DefaultNoexcept&) noexcept = default;
51 DefaultNoexcept& operator=(DefaultNoexcept&&) noexcept = default;
52 };
53
54 struct MoveCtorOnly
55 {
56 MoveCtorOnly() noexcept = delete;
57 MoveCtorOnly(const MoveCtorOnly&) noexcept = delete;
MoveCtorOnlyMoveCtorOnly58 MoveCtorOnly(MoveCtorOnly&&) noexcept { }
59 MoveCtorOnly& operator=(const MoveCtorOnly&) noexcept = delete;
60 MoveCtorOnly& operator=(MoveCtorOnly&&) noexcept = delete;
61 };
62
63 struct MoveCtorAndSwapOnly : MoveCtorOnly { };
swap(MoveCtorAndSwapOnly &,MoveCtorAndSwapOnly &)64 void swap(MoveCtorAndSwapOnly&, MoveCtorAndSwapOnly&) { }
65
66 struct DeletedMoves
67 {
68 DeletedMoves() = default;
69 DeletedMoves(const DeletedMoves&) = default;
70 DeletedMoves(DeletedMoves&&) = delete;
71 DeletedMoves& operator=(const DeletedMoves&) = default;
72 DeletedMoves& operator=(DeletedMoves&&) = delete;
73 };
74
75 struct nonliteral
76 {
nonliteralnonliteral77 nonliteral() { }
78
79 bool operator<(const nonliteral&) const;
80 bool operator<=(const nonliteral&) const;
81 bool operator==(const nonliteral&) const;
82 bool operator!=(const nonliteral&) const;
83 bool operator>=(const nonliteral&) const;
84 bool operator>(const nonliteral&) const;
85 };
86
87 struct virtual_default_dtor {
88 virtual ~virtual_default_dtor() = default;
89 };
90
default_ctor()91 void default_ctor()
92 {
93 static_assert(is_default_constructible_v<variant<int, string>>);
94 static_assert(is_default_constructible_v<variant<string, string>>);
95 static_assert(!is_default_constructible_v<variant<AllDeleted, string>>);
96 static_assert(is_default_constructible_v<variant<string, AllDeleted>>);
97 static_assert(is_default_constructible_v<variant<DeletedMoves>>);
98
99 static_assert(noexcept(variant<int>()));
100 static_assert(!noexcept(variant<Empty>()));
101 static_assert(noexcept(variant<DefaultNoexcept>()));
102 {
103 variant<virtual_default_dtor> a;
104 }
105 }
106
copy_ctor()107 void copy_ctor()
108 {
109 static_assert(is_copy_constructible_v<variant<int, string>>);
110 static_assert(!is_copy_constructible_v<variant<AllDeleted, string>>);
111 static_assert(is_trivially_copy_constructible_v<variant<int>>);
112 static_assert(!is_trivially_copy_constructible_v<variant<std::string>>);
113 static_assert(is_trivially_copy_constructible_v<variant<DeletedMoves>>);
114
115 {
116 variant<int> a;
117 static_assert(noexcept(variant<int>(a)));
118 }
119 {
120 variant<string> a;
121 static_assert(!noexcept(variant<string>(a)));
122 }
123 {
124 variant<int, string> a;
125 static_assert(!noexcept(variant<int, string>(a)));
126 }
127 {
128 variant<int, char> a;
129 static_assert(noexcept(variant<int, char>(a)));
130 }
131 }
132
move_ctor()133 void move_ctor()
134 {
135 static_assert(is_move_constructible_v<variant<int, string>>);
136 static_assert(!is_move_constructible_v<variant<AllDeleted, string>>);
137 static_assert(is_move_constructible_v<variant<int, DeletedMoves>>); // uses copy ctor
138 static_assert(is_trivially_move_constructible_v<variant<int>>);
139 static_assert(!is_trivially_move_constructible_v<variant<std::string>>);
140 static_assert(!noexcept(variant<int, Empty>(declval<variant<int, Empty>>())));
141 static_assert(noexcept(variant<int, DefaultNoexcept>(declval<variant<int, DefaultNoexcept>>())));
142 }
143
arbitrary_ctor()144 void arbitrary_ctor()
145 {
146 static_assert(!is_constructible_v<variant<string, string>, const char*>);
147 static_assert(is_constructible_v<variant<int, string>, const char*>);
148 static_assert(noexcept(variant<int, Empty>(int{})));
149 static_assert(noexcept(variant<int, DefaultNoexcept>(int{})));
150 static_assert(!noexcept(variant<int, Empty>(Empty{})));
151 static_assert(noexcept(variant<int, DefaultNoexcept>(DefaultNoexcept{})));
152
153 // P0608R3 disallow narrowing conversions and boolean conversions
154 static_assert(!is_constructible_v<variant<float>, int>);
155 static_assert(!is_constructible_v<variant<float, vector<int>>, int>);
156 static_assert(is_constructible_v<variant<float, int>, char>);
157 static_assert(!is_constructible_v<variant<float, char>, int>);
158 static_assert(is_constructible_v<variant<float, long>, int>);
159 struct big_int { big_int(int) { } };
160 static_assert(is_constructible_v<variant<float, big_int>, int>);
161
162 static_assert(!is_constructible_v<variant<int>, unsigned>);
163 static_assert(!is_constructible_v<variant<bool>, int>);
164 static_assert(!is_constructible_v<variant<bool>, void*>);
165 }
166
167 struct none { none() = delete; };
anyany168 struct any { template <typename T> any(T&&) {} };
169
in_place_index_ctor()170 void in_place_index_ctor()
171 {
172 variant<string, string> a(in_place_index<0>, "a");
173 variant<string, string> b(in_place_index<1>, {'a'});
174
175 static_assert(!is_constructible_v<variant<none, any>, std::in_place_index_t<0>>, "PR libstdc++/90165");
176 }
177
in_place_type_ctor()178 void in_place_type_ctor()
179 {
180 variant<int, string, int> a(in_place_type<string>, "a");
181 variant<int, string, int> b(in_place_type<string>, {'a'});
182 static_assert(!is_constructible_v<variant<string, string>, in_place_type_t<string>, const char*>);
183 static_assert(!is_constructible_v<variant<none, any>, std::in_place_type_t<none>>, "PR libstdc++/90165");
184 }
185
dtor()186 void dtor()
187 {
188 static_assert(is_destructible_v<variant<int, string>>);
189 static_assert(is_destructible_v<variant<AllDeleted, string>>);
190 }
191
copy_assign()192 void copy_assign()
193 {
194 static_assert(is_copy_assignable_v<variant<int, string>>);
195 static_assert(!is_copy_assignable_v<variant<AllDeleted, string>>);
196 static_assert(is_trivially_copy_assignable_v<variant<int>>);
197 static_assert(!is_trivially_copy_assignable_v<variant<string>>);
198 static_assert(is_trivially_copy_assignable_v<variant<DeletedMoves>>);
199 {
200 variant<Empty> a;
201 static_assert(!noexcept(a = a));
202 }
203 {
204 variant<DefaultNoexcept> a;
205 static_assert(noexcept(a = a));
206 }
207 }
208
move_assign()209 void move_assign()
210 {
211 static_assert(is_move_assignable_v<variant<int, string>>);
212 static_assert(!is_move_assignable_v<variant<AllDeleted, string>>);
213 static_assert(is_move_assignable_v<variant<int, DeletedMoves>>); // uses copy assignment
214 static_assert(is_trivially_move_assignable_v<variant<int>>);
215 static_assert(!is_trivially_move_assignable_v<variant<string>>);
216 {
217 variant<Empty> a;
218 static_assert(!noexcept(a = std::move(a)));
219 }
220 {
221 variant<DefaultNoexcept> a;
222 static_assert(noexcept(a = std::move(a)));
223 }
224 }
225
arbitrary_assign()226 void arbitrary_assign()
227 {
228 static_assert(!is_assignable_v<variant<string, string>, const char*>);
229 static_assert(is_assignable_v<variant<int, string>, const char*>);
230 static_assert(noexcept(variant<int, Empty>() = int{}));
231 static_assert(noexcept(variant<int, DefaultNoexcept>() = int{}));
232 static_assert(!noexcept(variant<int, Empty>() = Empty{}));
233 static_assert(noexcept(variant<int, DefaultNoexcept>() = DefaultNoexcept{}));
234 }
235
test_get()236 void test_get()
237 {
238 static_assert(is_same<decltype(get<0>(variant<int, string>())), int&&>::value);
239 static_assert(is_same<decltype(get<1>(variant<int, string>())), string&&>::value);
240 static_assert(is_same<decltype(get<1>(variant<int, const string>())), const string&&>::value);
241
242 static_assert(is_same<decltype(get<int>(variant<int, string>())), int&&>::value);
243 static_assert(is_same<decltype(get<string>(variant<int, string>())), string&&>::value);
244 static_assert(is_same<decltype(get<const string>(variant<int, const string>())), const string&&>::value);
245 }
246
test_relational()247 void test_relational()
248 {
249 {
250 constexpr variant<int, nonliteral> a(42), b(43);
251 static_assert((a < b));
252 static_assert(!(a > b));
253 static_assert((a <= b));
254 static_assert(!(a == b));
255 static_assert((a != b));
256 static_assert(!(a >= b));
257 }
258 {
259 constexpr variant<int, nonliteral> a(42), b(42);
260 static_assert(!(a < b));
261 static_assert(!(a > b));
262 static_assert((a <= b));
263 static_assert((a == b));
264 static_assert(!(a != b));
265 static_assert((a >= b));
266 }
267 {
268 constexpr variant<int, nonliteral> a(43), b(42);
269 static_assert(!(a < b));
270 static_assert((a > b));
271 static_assert(!(a <= b));
272 static_assert(!(a == b));
273 static_assert((a != b));
274 static_assert((a >= b));
275 }
276 {
277 constexpr monostate a, b;
278 static_assert(!(a < b));
279 static_assert(!(a > b));
280 static_assert((a <= b));
281 static_assert((a == b));
282 static_assert(!(a != b));
283 static_assert((a >= b));
284 }
285 }
286
287 // Not swappable, and variant<C> not swappable via the generic std::swap.
288 struct C { };
289 void swap(C&, C&) = delete;
290
291 static_assert( !std::is_swappable_v<variant<C>> );
292 static_assert( !std::is_swappable_v<variant<int, C>> );
293 static_assert( !std::is_swappable_v<variant<C, int>> );
294
295 // Not swappable, and variant<D> not swappable via the generic std::swap.
296 struct D { D(D&&) = delete; };
297
298 static_assert( !std::is_swappable_v<variant<D>> );
299 static_assert( !std::is_swappable_v<variant<int, D>> );
300 static_assert( !std::is_swappable_v<variant<D, int>> );
301
test_swap()302 void test_swap()
303 {
304 static_assert(is_swappable_v<variant<int, string>>);
305 static_assert(!is_swappable_v<variant<MoveCtorOnly>>);
306 static_assert(is_swappable_v<variant<MoveCtorAndSwapOnly>>);
307 static_assert(!is_swappable_v<variant<AllDeleted>>);
308 }
309
test_visit()310 void test_visit()
311 {
312 {
313 struct Visitor
314 {
315 void operator()(monostate) {}
316 void operator()(const int&) {}
317 };
318 struct CVisitor
319 {
320 void operator()(monostate) const {}
321 void operator()(const int&) const {}
322 };
323 }
324 {
325 struct Visitor
326 {
327 bool operator()(int, float) { return false; }
328 bool operator()(int, double) { return false; }
329 bool operator()(char, float) { return false; }
330 bool operator()(char, double) { return false; }
331 };
332 visit(Visitor(), variant<int, char>(), variant<float, double>());
333 }
334 {
335 struct Visitor
336 {
337 constexpr bool operator()(const int&) { return true; }
338 constexpr bool operator()(const nonliteral&) { return false; }
339 };
340 static_assert(visit(Visitor(), variant<int, nonliteral>(0)));
341 }
342 {
343 struct Visitor
344 {
345 constexpr bool operator()(const int&) { return true; }
346 constexpr bool operator()(const nonliteral&) { return false; }
347 };
348 static_assert(visit(Visitor(), variant<int, nonliteral>(0)));
349 }
350 // PR libstdc++/79513
351 {
352 std::variant<int> v [[gnu::unused]] (5);
353 std::visit([](int&){}, v);
354 std::visit([](int&&){}, std::move(v));
355 }
356 }
357
test_constexpr()358 void test_constexpr()
359 {
360 constexpr variant<int> a;
361 static_assert(holds_alternative<int>(a));
362 constexpr variant<int, char> b(in_place_index<0>, int{});
363 static_assert(holds_alternative<int>(b));
364 constexpr variant<int, char> c(in_place_type<int>, int{});
365 static_assert(holds_alternative<int>(c));
366 constexpr variant<int, char> d(in_place_index<1>, char{});
367 static_assert(holds_alternative<char>(d));
368 constexpr variant<int, char> e(in_place_type<char>, char{});
369 static_assert(holds_alternative<char>(e));
370 constexpr variant<int, char> f(char{});
371 static_assert(holds_alternative<char>(f));
372
373 {
374 struct literal {
375 constexpr literal() = default;
376 };
377
378 constexpr variant<literal, nonliteral> v{};
379 constexpr variant<literal, nonliteral> v1{in_place_type<literal>};
380 constexpr variant<literal, nonliteral> v2{in_place_index<0>};
381 }
382
383 {
384 constexpr variant<int> a(42);
385 static_assert(get<0>(a) == 42);
386 }
387 {
388 constexpr variant<int, nonliteral> a(42);
389 static_assert(get<0>(a) == 42);
390 }
391 {
392 constexpr variant<nonliteral, int> a(42);
393 static_assert(get<1>(a) == 42);
394 }
395 {
396 constexpr variant<int> a(42);
397 static_assert(get<int>(a) == 42);
398 }
399 {
400 constexpr variant<int, nonliteral> a(42);
401 static_assert(get<int>(a) == 42);
402 }
403 {
404 constexpr variant<nonliteral, int> a(42);
405 static_assert(get<int>(a) == 42);
406 }
407 {
408 constexpr variant<int> a(42);
409 static_assert(get<0>(std::move(a)) == 42);
410 }
411 {
412 constexpr variant<int, nonliteral> a(42);
413 static_assert(get<0>(std::move(a)) == 42);
414 }
415 {
416 constexpr variant<nonliteral, int> a(42);
417 static_assert(get<1>(std::move(a)) == 42);
418 }
419 {
420 constexpr variant<int> a(42);
421 static_assert(get<int>(std::move(a)) == 42);
422 }
423 {
424 constexpr variant<int, nonliteral> a(42);
425 static_assert(get<int>(std::move(a)) == 42);
426 }
427 {
428 constexpr variant<nonliteral, int> a(42);
429 static_assert(get<int>(std::move(a)) == 42);
430 }
431 }
432
test_pr77641()433 void test_pr77641()
434 {
435 struct X {
436 constexpr X() { }
437 };
438
439 constexpr std::variant<X> v1 = X{};
440 }
441
442 namespace adl_trap
443 {
444 struct X {
445 X() = default;
Xadl_trap::X446 X(int) { }
Xadl_trap::X447 X(std::initializer_list<int>, const X&) { }
448 };
move(T &)449 template<typename T> void move(T&) { }
forward(T &)450 template<typename T> void forward(T&) { }
451
452 struct Visitor {
operator ()adl_trap::Visitor453 template<typename T> void operator()(T&&) { }
454 };
455 }
456
test_adl()457 void test_adl()
458 {
459 using adl_trap::X;
460 X x;
461 std::initializer_list<int> il;
462 adl_trap::Visitor vis;
463
464 std::variant<X> v0(x);
465 v0 = x;
466 v0.emplace<0>(x);
467 v0.emplace<0>(il, x);
468 visit(vis, v0);
469 variant<X> v1{in_place_index<0>, x};
470 variant<X> v2{in_place_type<X>, x};
471 variant<X> v3{in_place_index<0>, il, x};
472 variant<X> v4{in_place_type<X>, il, x};
473 }
474
test_variant_alternative()475 void test_variant_alternative()
476 {
477 static_assert(is_same_v<variant_alternative_t<0, variant<int, string>>, int>);
478 static_assert(is_same_v<variant_alternative_t<1, variant<int, string>>, string>);
479
480 static_assert(is_same_v<variant_alternative_t<0, const variant<int>>, const int>);
481 static_assert(is_same_v<variant_alternative_t<0, volatile variant<int>>, volatile int>);
482 static_assert(is_same_v<variant_alternative_t<0, const volatile variant<int>>, const volatile int>);
483 }
484
485 template<typename V, typename T>
has_type_emplace(int)486 constexpr auto has_type_emplace(int) -> decltype((declval<V>().template emplace<T>(), true))
487 { return true; };
488
489 template<typename V, typename T>
has_type_emplace(...)490 constexpr bool has_type_emplace(...)
491 { return false; };
492
493 template<typename V, size_t N>
has_index_emplace(int)494 constexpr auto has_index_emplace(int) -> decltype((declval<V>().template emplace<N>(), true))
495 { return true; };
496
497 template<typename V, size_t T>
has_index_emplace(...)498 constexpr bool has_index_emplace(...)
499 { return false; };
500
test_emplace()501 void test_emplace()
502 {
503 static_assert(has_type_emplace<variant<int>, int>(0));
504 static_assert(!has_type_emplace<variant<long>, int>(0));
505 static_assert(has_index_emplace<variant<int>, 0>(0));
506 static_assert(!has_type_emplace<variant<AllDeleted>, AllDeleted>(0));
507 static_assert(!has_index_emplace<variant<AllDeleted>, 0>(0));
508 static_assert(has_type_emplace<variant<int, AllDeleted>, int>(0));
509 static_assert(has_index_emplace<variant<int, AllDeleted>, 0>(0));
510 static_assert(has_type_emplace<variant<int, vector<int>, AllDeleted>, vector<int>>(0));
511 static_assert(has_index_emplace<variant<int, vector<int>, AllDeleted>, 1>(0));
512
513 // The above tests only check the emplace members are available for
514 // overload resolution. The following odr-uses will instantiate them:
515 variant<int, vector<int>, AllDeleted> v;
516 v.emplace<0>(1);
517 v.emplace<int>(1);
518 v.emplace<1>(1, 1);
519 v.emplace<vector<int>>(1, 1);
520 v.emplace<1>({1, 2, 3, 4});
521 v.emplace<vector<int>>({1, 2, 3, 4});
522 }
523
test_triviality()524 void test_triviality()
525 {
526 #define TEST_TEMPLATE(DT, CC, MC, CA, MA, CC_VAL, MC_VAL, CA_VAL, MA_VAL) \
527 { \
528 struct A \
529 { \
530 ~A() DT; \
531 A(const A&) CC; \
532 A(A&&) MC; \
533 A& operator=(const A&) CA; \
534 A& operator=(A&&) MA; \
535 }; \
536 static_assert(CC_VAL == is_trivially_copy_constructible_v<variant<A>>); \
537 static_assert(MC_VAL == is_trivially_move_constructible_v<variant<A>>); \
538 static_assert(CA_VAL == is_trivially_copy_assignable_v<variant<A>>); \
539 static_assert(MA_VAL == is_trivially_move_assignable_v<variant<A>>); \
540 }
541 TEST_TEMPLATE(=default, =default, =default, =default, =default, true, true, true, true)
542 TEST_TEMPLATE(=default, =default, =default, =default, , true, true, true, false)
543 TEST_TEMPLATE(=default, =default, =default, , =default, true, true, false, true)
544 TEST_TEMPLATE(=default, =default, =default, , , true, true, false, false)
545 TEST_TEMPLATE(=default, =default, , =default, =default, true, false, true, false)
546 TEST_TEMPLATE(=default, =default, , =default, , true, false, true, false)
547 TEST_TEMPLATE(=default, =default, , , =default, true, false, false, false)
548 TEST_TEMPLATE(=default, =default, , , , true, false, false, false)
549 TEST_TEMPLATE(=default, , =default, =default, =default, false, true, false, true)
550 TEST_TEMPLATE(=default, , =default, =default, , false, true, false, false)
551 TEST_TEMPLATE(=default, , =default, , =default, false, true, false, true)
552 TEST_TEMPLATE(=default, , =default, , , false, true, false, false)
553 TEST_TEMPLATE(=default, , , =default, =default, false, false, false, false)
554 TEST_TEMPLATE(=default, , , =default, , false, false, false, false)
555 TEST_TEMPLATE(=default, , , , =default, false, false, false, false)
556 TEST_TEMPLATE(=default, , , , , false, false, false, false)
557 TEST_TEMPLATE( , =default, =default, =default, =default, false, false, false, false)
558 TEST_TEMPLATE( , =default, =default, =default, , false, false, false, false)
559 TEST_TEMPLATE( , =default, =default, , =default, false, false, false, false)
560 TEST_TEMPLATE( , =default, =default, , , false, false, false, false)
561 TEST_TEMPLATE( , =default, , =default, =default, false, false, false, false)
562 TEST_TEMPLATE( , =default, , =default, , false, false, false, false)
563 TEST_TEMPLATE( , =default, , , =default, false, false, false, false)
564 TEST_TEMPLATE( , =default, , , , false, false, false, false)
565 TEST_TEMPLATE( , , =default, =default, =default, false, false, false, false)
566 TEST_TEMPLATE( , , =default, =default, , false, false, false, false)
567 TEST_TEMPLATE( , , =default, , =default, false, false, false, false)
568 TEST_TEMPLATE( , , =default, , , false, false, false, false)
569 TEST_TEMPLATE( , , , =default, =default, false, false, false, false)
570 TEST_TEMPLATE( , , , =default, , false, false, false, false)
571 TEST_TEMPLATE( , , , , =default, false, false, false, false)
572 TEST_TEMPLATE( , , , , , false, false, false, false)
573 #undef TEST_TEMPLATE
574
575 #define TEST_TEMPLATE(CC, MC, CA, MA) \
576 { \
577 struct A \
578 { \
579 A(const A&) CC; \
580 A(A&&) MC; \
581 A& operator=(const A&) CA; \
582 A& operator=(A&&) MA; \
583 }; \
584 static_assert(!is_trivially_copy_constructible_v<variant<AllDeleted, A>>); \
585 static_assert(!is_trivially_move_constructible_v<variant<AllDeleted, A>>); \
586 static_assert(!is_trivially_copy_assignable_v<variant<AllDeleted, A>>); \
587 static_assert(!is_trivially_move_assignable_v<variant<AllDeleted, A>>); \
588 }
589 TEST_TEMPLATE(=default, =default, =default, =default)
590 TEST_TEMPLATE(=default, =default, =default, )
591 TEST_TEMPLATE(=default, =default, , =default)
592 TEST_TEMPLATE(=default, =default, , )
593 TEST_TEMPLATE(=default, , =default, =default)
594 TEST_TEMPLATE(=default, , =default, )
595 TEST_TEMPLATE(=default, , , =default)
596 TEST_TEMPLATE(=default, , , )
597 TEST_TEMPLATE( , =default, =default, =default)
598 TEST_TEMPLATE( , =default, =default, )
599 TEST_TEMPLATE( , =default, , =default)
600 TEST_TEMPLATE( , =default, , )
601 TEST_TEMPLATE( , , =default, =default)
602 TEST_TEMPLATE( , , =default, )
603 TEST_TEMPLATE( , , , =default)
604 TEST_TEMPLATE( , , , )
605 #undef TEST_TEMPLATE
606
607 static_assert(is_trivially_copy_constructible_v<variant<DefaultNoexcept, int, char, float, double>>);
608 static_assert(is_trivially_move_constructible_v<variant<DefaultNoexcept, int, char, float, double>>);
609 static_assert(is_trivially_copy_assignable_v<variant<DefaultNoexcept, int, char, float, double>>);
610 static_assert(is_trivially_move_assignable_v<variant<DefaultNoexcept, int, char, float, double>>);
611 }
612