1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 // UNSUPPORTED: c++03, c++11, c++14, c++17
10 // UNSUPPORTED: apple-clang-9, apple-clang-10, apple-clang-11, apple-clang-12.0.0
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 
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 
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 
54 constexpr bool test_conversion() {
55   static_assert(std::is_convertible<const std::weak_ordering&,
56       std::partial_ordering>::value, "");
57   { // value == 0
58     auto V = std::weak_ordering::equivalent;
59     std::partial_ordering WV = V;
60     assert(WV == 0);
61   }
62   { // value < 0
63     auto V = std::weak_ordering::less;
64     std::partial_ordering WV = V;
65     assert(WV < 0);
66   }
67   { // value > 0
68     auto V = std::weak_ordering::greater;
69     std::partial_ordering WV = V;
70     assert(WV > 0);
71   }
72   return true;
73 }
74 
75 constexpr bool test_constexpr() {
76   auto& Eq = std::weak_ordering::equivalent;
77   auto& Less = std::weak_ordering::less;
78   auto& Greater = std::weak_ordering::greater;
79   struct {
80     std::weak_ordering Value;
81     bool ExpectEq;
82     bool ExpectNeq;
83     bool ExpectLess;
84     bool ExpectGreater;
85   } TestCases[] = {
86       {Eq, true, false, false, false},
87       {Less, false, true, true, false},
88       {Greater, false, true, false, true},
89   };
90   for (auto TC : TestCases) {
91     auto V = TC.Value;
92     assert((V == 0) == TC.ExpectEq);
93     assert((0 == V) == TC.ExpectEq);
94     assert((V != 0) == TC.ExpectNeq);
95     assert((0 != V) == TC.ExpectNeq);
96 
97     assert((V < 0) == TC.ExpectLess);
98     assert((V > 0) == TC.ExpectGreater);
99     assert((V <= 0) == (TC.ExpectLess || TC.ExpectEq));
100     assert((V >= 0) == (TC.ExpectGreater || TC.ExpectEq));
101 
102     assert((0 < V) == TC.ExpectGreater);
103     assert((0 > V) == TC.ExpectLess);
104     assert((0 <= V) == (TC.ExpectGreater || TC.ExpectEq));
105     assert((0 >= V) == (TC.ExpectLess || TC.ExpectEq));
106   }
107 #ifndef TEST_HAS_NO_SPACESHIP_OPERATOR
108   {
109     std::weak_ordering res = (Eq <=> 0);
110     ((void)res);
111     res = (0 <=> Eq);
112     ((void)res);
113   }
114   enum ExpectRes {
115     ER_Greater,
116     ER_Less,
117     ER_Equiv
118   };
119   struct {
120     std::weak_ordering Value;
121     ExpectRes Expect;
122   } SpaceshipTestCases[] = {
123       {std::weak_ordering::equivalent, ER_Equiv},
124       {std::weak_ordering::less, ER_Less},
125       {std::weak_ordering::greater, ER_Greater},
126   };
127   for (auto TC : SpaceshipTestCases)
128   {
129     std::weak_ordering Res = (TC.Value <=> 0);
130     switch (TC.Expect) {
131     case ER_Equiv:
132       assert(Res == 0);
133       assert(0 == Res);
134       break;
135     case ER_Less:
136       assert(Res < 0);
137       break;
138     case ER_Greater:
139       assert(Res > 0);
140       break;
141     }
142   }
143 
144   {
145     static_assert(std::weak_ordering::less == std::weak_ordering::less);
146     static_assert(std::weak_ordering::less != std::weak_ordering::equivalent);
147     static_assert(std::weak_ordering::less != std::weak_ordering::greater);
148 
149     static_assert(std::weak_ordering::equivalent != std::weak_ordering::less);
150     static_assert(std::weak_ordering::equivalent ==
151                   std::weak_ordering::equivalent);
152     static_assert(std::weak_ordering::equivalent !=
153                   std::weak_ordering::greater);
154 
155     static_assert(std::weak_ordering::greater != std::weak_ordering::less);
156     static_assert(std::weak_ordering::greater !=
157                   std::weak_ordering::equivalent);
158     static_assert(std::weak_ordering::greater == std::weak_ordering::greater);
159   }
160 #endif
161 
162   return true;
163 }
164 
165 int main(int, char**) {
166   test_static_members();
167   test_signatures();
168   static_assert(test_conversion(), "conversion test failed");
169   static_assert(test_constexpr(), "constexpr test failed");
170 
171   return 0;
172 }
173