Cleanup

Author: H-G-Hristov

libcxx/test/std/utilities/optional/optional.comp_with_t/equal.pass.cpp

@@ -28,7 +28,6 @@ static_assert(HasOperatorEqual<EqualityComparable, std::optional<EqualityCompara
 static_assert(!HasOperatorEqual<NonComparable, std::optional<NonComparable>>);
 static_assert(!HasOperatorEqual<NonComparable, std::optional<EqualityComparable>>);
 
-
 static_assert(HasOperatorEqual<std::optional<int>, int>);
 static_assert(HasOperatorEqual<std::optional<EqualityComparable>, int>);
 static_assert(HasOperatorEqual<std::optional<EqualityComparable>, EqualityComparable>);

libcxx/test/support/test_comparisons.h

@@ -293,20 +293,15 @@ concept HasOperatorGreaterThanEqual = requires(T1 t1, T2 t2) { t1 >= t2; };
 template <typename T1, typename T2 = T1>
 concept HasOperatorSpaceship = requires(T1 t1, T2 t2) { t1 <=> t2; };
 
-template <typename T1, typename T2 = T1>
-concept CanCompareWithSpaceship = HasOperatorSpaceship<T1, T2> && requires(T1 t1, T2 t2) {
-  { t1 <=> t2 } -> std::same_as<std::strong_ordering>;
-};
-
-template <typename T1, typename T2 = T1>
-concept CanCompare =
-    HasOperatorEqual<T1, T2> && HasOperatorNotEqual<T1, T2> && HasOperatorLessThan<T1, T2> &&
-    HasOperatorGreaterThan<T1, T2> && HasOperatorLessThanEqual<T1, T2> && HasOperatorGreaterThanEqual<T1, T2>;
-
 struct NonComparable {};
-
 static_assert(!std::equality_comparable<NonComparable>);
-static_assert(!CanCompare<NonComparable>);
+static_assert(!HasOperatorEqual<NonComparable>);
+static_assert(!HasOperatorNotEqual<NonComparable>);
+static_assert(!HasOperatorLessThan<NonComparable>);
+static_assert(!HasOperatorGreaterThan<NonComparable>);
+static_assert(!HasOperatorLessThanEqual<NonComparable>);
+static_assert(!HasOperatorGreaterThanEqual<NonComparable>);
+static_assert(!HasOperatorSpaceship<NonComparable>);
 
 class EqualityComparable {
 public:
@@ -318,26 +313,29 @@ class EqualityComparable {
   int value_;
 };
 static_assert(std::equality_comparable<EqualityComparable>);
+static_assert(HasOperatorEqual<EqualityComparable>);
+static_assert(HasOperatorNotEqual<EqualityComparable>);
 
 class ThreeWayComparable {
 public:
   constexpr ThreeWayComparable(int value) : value_{value} {};
 
-  friend constexpr std::strong_ordering operator<=>(const ThreeWayComparable&, const ThreeWayComparable&) noexcept = default;
   friend constexpr bool operator==(const ThreeWayComparable&, const ThreeWayComparable&) noexcept = default;
+  friend constexpr std::strong_ordering
+  operator<=>(const ThreeWayComparable&, const ThreeWayComparable&) noexcept = default;
+
 private:
   int value_;
 };
 static_assert(std::equality_comparable<ThreeWayComparable>);
+static_assert(std::three_way_comparable<ThreeWayComparable>);
 static_assert(HasOperatorEqual<ThreeWayComparable>);
 static_assert(HasOperatorNotEqual<ThreeWayComparable>);
 static_assert(HasOperatorLessThan<ThreeWayComparable>);
 static_assert(HasOperatorGreaterThan<ThreeWayComparable>);
 static_assert(HasOperatorLessThanEqual<ThreeWayComparable>);
 static_assert(HasOperatorGreaterThanEqual<ThreeWayComparable>);
 static_assert(HasOperatorSpaceship<ThreeWayComparable>);
-static_assert(CanCompare<ThreeWayComparable>);
-static_assert(CanCompareWithSpaceship<ThreeWayComparable>);
 
 #endif // TEST_STD_VER >= 26