1 //===----------------------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
11
12 // <compare>
13
14 // class weak_ordering
15
16
17 #include <compare>
18 #include <type_traits>
19 #include <cassert>
20
21 #include "test_macros.h"
22
23 const volatile void* volatile sink;
24
test_static_members()25 void test_static_members() {
26 DoNotOptimize(&std::weak_ordering::less);
27 DoNotOptimize(&std::weak_ordering::equivalent);
28 DoNotOptimize(&std::weak_ordering::greater);
29 }
30
test_signatures()31 void test_signatures() {
32 auto& Eq = std::weak_ordering::equivalent;
33
34 ASSERT_NOEXCEPT(Eq == 0);
35 ASSERT_NOEXCEPT(0 == Eq);
36 ASSERT_NOEXCEPT(Eq != 0);
37 ASSERT_NOEXCEPT(0 != Eq);
38 ASSERT_NOEXCEPT(0 < Eq);
39 ASSERT_NOEXCEPT(Eq < 0);
40 ASSERT_NOEXCEPT(0 <= Eq);
41 ASSERT_NOEXCEPT(Eq <= 0);
42 ASSERT_NOEXCEPT(0 > Eq);
43 ASSERT_NOEXCEPT(Eq > 0);
44 ASSERT_NOEXCEPT(0 >= Eq);
45 ASSERT_NOEXCEPT(Eq >= 0);
46 #ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
47 ASSERT_NOEXCEPT(0 <=> Eq);
48 ASSERT_NOEXCEPT(Eq <=> 0);
49 ASSERT_SAME_TYPE(decltype(Eq <=> 0), std::weak_ordering);
50 ASSERT_SAME_TYPE(decltype(0 <=> Eq), std::weak_ordering);
51 #endif
52 }
53
test_conversion()54 constexpr bool test_conversion() {
55 static_assert(std::is_convertible<const std::weak_ordering&,
56 std::weak_equality>::value, "");
57 { // value == 0
58 auto V = std::weak_ordering::equivalent;
59 std::weak_equality WV = V;
60 assert(WV == 0);
61 }
62 std::weak_ordering WeakTestCases[] = {
63 std::weak_ordering::less,
64 std::weak_ordering::greater,
65 };
66 for (auto V : WeakTestCases)
67 { // value != 0
68 std::weak_equality WV = V;
69 assert(WV != 0);
70 }
71 static_assert(std::is_convertible<const std::weak_ordering&,
72 std::partial_ordering>::value, "");
73 { // value == 0
74 auto V = std::weak_ordering::equivalent;
75 std::partial_ordering WV = V;
76 assert(WV == 0);
77 }
78 { // value < 0
79 auto V = std::weak_ordering::less;
80 std::partial_ordering WV = V;
81 assert(WV < 0);
82 }
83 { // value > 0
84 auto V = std::weak_ordering::greater;
85 std::partial_ordering WV = V;
86 assert(WV > 0);
87 }
88 return true;
89 }
90
test_constexpr()91 constexpr bool test_constexpr() {
92 auto& Eq = std::weak_ordering::equivalent;
93 auto& Less = std::weak_ordering::less;
94 auto& Greater = std::weak_ordering::greater;
95 struct {
96 std::weak_ordering Value;
97 bool ExpectEq;
98 bool ExpectNeq;
99 bool ExpectLess;
100 bool ExpectGreater;
101 } TestCases[] = {
102 {Eq, true, false, false, false},
103 {Less, false, true, true, false},
104 {Greater, false, true, false, true},
105 };
106 for (auto TC : TestCases) {
107 auto V = TC.Value;
108 assert((V == 0) == TC.ExpectEq);
109 assert((0 == V) == TC.ExpectEq);
110 assert((V != 0) == TC.ExpectNeq);
111 assert((0 != V) == TC.ExpectNeq);
112
113 assert((V < 0) == TC.ExpectLess);
114 assert((V > 0) == TC.ExpectGreater);
115 assert((V <= 0) == (TC.ExpectLess || TC.ExpectEq));
116 assert((V >= 0) == (TC.ExpectGreater || TC.ExpectEq));
117
118 assert((0 < V) == TC.ExpectGreater);
119 assert((0 > V) == TC.ExpectLess);
120 assert((0 <= V) == (TC.ExpectGreater || TC.ExpectEq));
121 assert((0 >= V) == (TC.ExpectLess || TC.ExpectEq));
122 }
123 #ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
124 {
125 std::weak_ordering res = (Eq <=> 0);
126 ((void)res);
127 res = (0 <=> Eq);
128 ((void)res);
129 }
130 enum ExpectRes {
131 ER_Greater,
132 ER_Less,
133 ER_Equiv
134 };
135 struct {
136 std::weak_ordering Value;
137 ExpectRes Expect;
138 } SpaceshipTestCases[] = {
139 {std::weak_ordering::equivalent, ER_Equiv},
140 {std::weak_ordering::less, ER_Less},
141 {std::weak_ordering::greater, ER_Greater},
142 };
143 for (auto TC : SpaceshipTestCases)
144 {
145 std::weak_ordering Res = (0 <=> TC.Value);
146 switch (TC.Expect) {
147 case ER_Equiv:
148 assert(Res == 0);
149 assert(0 == Res);
150 break;
151 case ER_Less:
152 assert(Res < 0);
153 break;
154 case ER_Greater:
155 assert(Res > 0);
156 break;
157 }
158 }
159 #endif
160
161 return true;
162 }
163
main()164 int main() {
165 test_static_members();
166 test_signatures();
167 static_assert(test_conversion(), "conversion test failed");
168 static_assert(test_constexpr(), "constexpr test failed");
169 }
170