|
152
|
1 // { dg-options "-std=gnu++2a" }
|
|
|
2 // { dg-do run { target c++2a } }
|
|
|
3
|
|
|
4 // Copyright (C) 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 // 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 }
|
