]>
Commit | Line | Data |
---|---|---|
9e589880 JW |
1 | // { dg-options "-std=gnu++2a" } |
2 | // { dg-do run { target c++2a } } | |
3 | ||
99dee823 | 4 | // Copyright (C) 2020-2021 Free Software Foundation, Inc. |
9e589880 JW |
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 | // Tuple | |
22 | ||
23 | #include <tuple> | |
24 | #include <testsuite_hooks.h> | |
25 | ||
26 | using namespace std; | |
27 | ||
28 | template<typename T> | |
29 | bool self_consistent(const T& x) | |
30 | { | |
31 | return std::is_eq(x <=> x) && x == x && !(x != x) && x <= x && !(x < x); | |
32 | } | |
33 | ||
34 | void | |
35 | test01() | |
36 | { | |
37 | int i=0; | |
38 | int j=0; | |
39 | int k=2; | |
40 | tuple<int, int, int> a(0, 0, 0); | |
41 | tuple<int, int, int> b(0, 0, 1); | |
42 | tuple<int& , int& , int&> c(i,j,k); | |
43 | tuple<const int&, const int&, const int&> d(c); | |
44 | VERIFY( self_consistent(a) ); | |
45 | VERIFY( self_consistent(b) ); | |
46 | VERIFY( self_consistent(c) ); | |
47 | VERIFY( self_consistent(d) ); | |
48 | VERIFY( !(a > a) && !(b > b) ); | |
49 | VERIFY( a >= a && b >= b ); | |
50 | VERIFY( a < b && !(b < a) && a <= b && !(b <= a) ); | |
51 | VERIFY( b > a && !(a > b) && b >= a && !(a >= b) ); | |
52 | ||
53 | VERIFY( std::is_lt(a <=> b) ); | |
54 | VERIFY( std::is_gt(b <=> a) ); | |
55 | VERIFY( std::is_gt(c <=> a) ); | |
56 | VERIFY( std::is_eq(c <=> d) ); | |
57 | ||
58 | static_assert( std::is_same_v<decltype(a <=> d), std::strong_ordering> ); | |
59 | } | |
60 | ||
61 | template<typename T, typename U, typename C> | |
62 | constexpr bool | |
63 | check_compare(T&& t, U&& u, C c) | |
64 | { | |
65 | using R = std::compare_three_way_result_t<T, U>; | |
66 | static_assert( std::same_as<C, R> ); | |
67 | return (t <=> u) == c; | |
68 | } | |
69 | ||
70 | void | |
71 | test02() | |
72 | { | |
73 | using std::strong_ordering; | |
74 | using std::weak_ordering; | |
75 | using std::partial_ordering; | |
76 | ||
77 | using T0 = std::tuple<>; | |
78 | static_assert( check_compare(T0(), T0(), strong_ordering::equal) ); | |
79 | ||
80 | using Ti = std::tuple<int>; | |
81 | using Tu = std::tuple<unsigned>; | |
82 | static_assert( check_compare(Ti(1), Tu(1u), weak_ordering::equivalent) ); | |
83 | static_assert( check_compare(Ti(1), Tu(2u), weak_ordering::less) ); | |
84 | static_assert( check_compare(Ti(-1), Tu(1u), weak_ordering::greater) ); | |
85 | ||
86 | using Tii = std::tuple<int, int>; | |
87 | using Tlu = std::tuple<long, unsigned>; | |
88 | static_assert( check_compare(Tii(1, 2), Tlu(2l, 1u), weak_ordering::less) ); | |
89 | ||
90 | using Tid = std::tuple<int, double>; | |
91 | static_assert( check_compare(Tii(3, 4), Tid(2, 0.9), partial_ordering::greater) ); | |
92 | ||
93 | static_assert( !std::three_way_comparable_with<T0, Ti> ); | |
94 | static_assert( !std::three_way_comparable_with<Ti, Tii> ); | |
95 | static_assert( !std::three_way_comparable_with<Ti, Tid> ); | |
96 | } | |
97 | ||
98 | int main() | |
99 | { | |
100 | test01(); | |
101 | test02(); | |
102 | } |