Update other comparison tests

Author: randomnetcat

libcxx/test/std/algorithms/alg.sorting/alg.sort/partial.sort.copy/ranges_partial_sort_copy.pass.cpp

@@ -75,7 +75,12 @@ static_assert(!HasPartialSortCopyIter<int*, int*, int*, int*, IndirectUnaryPredi
 static_assert(!HasPartialSortCopyIter<int*, int*, int*, int*, IndirectUnaryPredicateNotCopyConstructible>);
 
 // !indirectly_copyable<I1, I2>
-static_assert(!HasPartialSortCopyIter<int*, int*, MoveOnly*>);
+struct OrderedConvertibleToInt {
+  friend auto operator<=>(OrderedConvertibleToInt const&, OrderedConvertibleToInt const&) = default;
+  operator int() const;
+};
+
+static_assert(!HasPartialSortCopyIter<int*, int*, OrderedConvertibleToInt*, OrderedConvertibleToInt*>);
 
 // !sortable<I2, Comp, Proj2>
 static_assert(!HasPartialSortCopyIter<int*, int*, const int*, const int*>);
@@ -84,6 +89,12 @@ struct NoComparator {};
 // !indirect_strict_weak_order<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
 static_assert(!HasPartialSortCopyIter<NoComparator*, NoComparator*, NoComparator*, NoComparator*>);
 
+#if TEST_STD_VER >= 23
+static_assert(HasPartialSortCopyIter<int*, int*, MoveOnly*, MoveOnly*>);
+#else
+static_assert(!HasPartialSortCopyIter<int*, int*, MoveOnly*, MoveOnly*>);
+#endif // TEST_STD_VER >= 23
+
 // Test constraints of the (range) overload.
 // ======================================================
 
@@ -109,14 +120,20 @@ static_assert(!HasPartialSortCopyRange<R<int*>, RandomAccessRangeNotDerivedFrom>
 static_assert(!HasPartialSortCopyRange<R<int*>, RandomAccessRangeBadIndex>);
 
 // !indirectly_copyable<iterator_t<R1>, iterator_t<R2>>
-static_assert(!HasPartialSortCopyRange<R<int*>, R<MoveOnly*>>);
+static_assert(!HasPartialSortCopyRange<R<int*>, R<OrderedConvertibleToInt*>>);
 
 // !sortable<iterator_t<R2>, Comp, Proj2>
 static_assert(!HasPartialSortCopyRange<R<int*>, R<const int*>>);
 
 // !indirect_strict_weak_order<Comp, projected<iterator_t<R1>, Proj1>, projected<iterator_t<R2>, Proj2>>
 static_assert(!HasPartialSortCopyRange<R<NoComparator*>, R<NoComparator*>>);
 
+#if TEST_STD_VER >= 23
+static_assert(HasPartialSortCopyRange<R<int*>, R<MoveOnly*>>);
+#else
+static_assert(!HasPartialSortCopyRange<R<int*>, R<MoveOnly*>>);
+#endif // TEST_STD_VER >= 23
+
 static_assert(std::is_same_v<std::ranges::partial_sort_copy_result<int, int>, std::ranges::in_out_result<int, int>>);
 
 template <class Iter, class Sent, class OutIter, class OutSent, std::size_t N>

libcxx/test/std/utilities/function.objects/range.cmp/equal_to.pass.cpp

@@ -28,9 +28,14 @@ struct NotEqualityComparable {
 };
 
 static_assert(!std::is_invocable_v<std::ranges::equal_to, NotEqualityComparable, NotEqualityComparable>);
-static_assert(!std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
 static_assert(std::is_invocable_v<std::ranges::equal_to, explicit_operators, explicit_operators>);
 
+#if TEST_STD_VER >= 23
+static_assert(std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
+#else
+static_assert(!std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
+#endif // TEST_STD_VER >= 23
+
 static_assert(requires { typename std::ranges::equal_to::is_transparent; });
 
 constexpr bool test() {

libcxx/test/std/utilities/function.objects/range.cmp/greater.pass.cpp

@@ -27,9 +27,14 @@ struct NotTotallyOrdered {
 };
 
 static_assert(!std::is_invocable_v<std::ranges::greater, NotTotallyOrdered, NotTotallyOrdered>);
-static_assert(!std::is_invocable_v<std::ranges::greater, int, MoveOnly>);
 static_assert(std::is_invocable_v<std::ranges::greater, explicit_operators, explicit_operators>);
 
+#if TEST_STD_VER >= 23
+static_assert(std::is_invocable_v<std::ranges::greater, int, MoveOnly>);
+#else
+static_assert(!std::is_invocable_v<std::ranges::greater, int, MoveOnly>);
+#endif // TEST_STD_VER >= 23
+
 static_assert(requires { typename std::ranges::greater::is_transparent; });
 
 constexpr bool test() {

libcxx/test/std/utilities/function.objects/range.cmp/greater_equal.pass.cpp

@@ -27,9 +27,14 @@ struct NotTotallyOrdered {
 };
 
 static_assert(!std::is_invocable_v<std::ranges::greater_equal, NotTotallyOrdered, NotTotallyOrdered>);
-static_assert(!std::is_invocable_v<std::ranges::greater_equal, int, MoveOnly>);
 static_assert(std::is_invocable_v<std::ranges::greater_equal, explicit_operators, explicit_operators>);
 
+#if TEST_STD_VER >= 23
+static_assert(std::is_invocable_v<std::ranges::greater_equal, int, MoveOnly>);
+#else
+static_assert(!std::is_invocable_v<std::ranges::greater_equal, int, MoveOnly>);
+#endif // TEST_STD_VER >= 23
+
 static_assert(requires { typename std::ranges::greater_equal::is_transparent; });
 
 constexpr bool test() {

libcxx/test/std/utilities/function.objects/range.cmp/less.pass.cpp

@@ -27,9 +27,14 @@ struct NotTotallyOrdered {
 };
 
 static_assert(!std::is_invocable_v<std::ranges::less, NotTotallyOrdered, NotTotallyOrdered>);
-static_assert(!std::is_invocable_v<std::ranges::less, int, MoveOnly>);
 static_assert(std::is_invocable_v<std::ranges::less, explicit_operators, explicit_operators>);
 
+#if TEST_STD_VER >= 23
+static_assert(std::is_invocable_v<std::ranges::less, int, MoveOnly>);
+#else
+static_assert(!std::is_invocable_v<std::ranges::less, int, MoveOnly>);
+#endif // TEST_STD_VER >= 23
+
 static_assert(requires { typename std::ranges::less::is_transparent; });
 
 constexpr bool test() {

libcxx/test/std/utilities/function.objects/range.cmp/less_equal.pass.cpp

@@ -27,9 +27,14 @@ struct NotTotallyOrdered {
 };
 
 static_assert(!std::is_invocable_v<std::ranges::less_equal, NotTotallyOrdered, NotTotallyOrdered>);
-static_assert(!std::is_invocable_v<std::ranges::less_equal, int, MoveOnly>);
 static_assert(std::is_invocable_v<std::ranges::less_equal, explicit_operators, explicit_operators>);
 
+#if TEST_STD_VER >= 23
+static_assert(std::is_invocable_v<std::ranges::less_equal, int, MoveOnly>);
+#else
+static_assert(!std::is_invocable_v<std::ranges::less_equal, int, MoveOnly>);
+#endif // TEST_STD_VER >= 23
+
 static_assert(requires { typename std::ranges::less_equal::is_transparent; });
 
 constexpr bool test() {

libcxx/test/std/utilities/function.objects/range.cmp/not_equal_to.pass.cpp

@@ -28,9 +28,14 @@ struct NotEqualityComparable {
 };
 
 static_assert(!std::is_invocable_v<std::ranges::equal_to, NotEqualityComparable, NotEqualityComparable>);
-static_assert(!std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
 static_assert(std::is_invocable_v<std::ranges::equal_to, explicit_operators, explicit_operators>);
 
+#if TEST_STD_VER >= 23
+static_assert(std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
+#else
+static_assert(!std::is_invocable_v<std::ranges::equal_to, int, MoveOnly>);
+#endif // TEST_STD_VER >= 23
+
 static_assert(requires { typename std::ranges::not_equal_to::is_transparent; });
 
 struct PtrAndNotEqOperator {