[libc++] [C++20] [P0586] Implement safe integral comparisons

[kamleshbhalui]

Summary

• https://wg21.link/P0586

[curdeius]

The implementation looks okay at the first glance but you need to rework the tests.

• Test noexcept using ASSERT_NOEXCEPT
• Add tests in non-constexpr context. Look at other recently added commits and add a test function with asserts that gets called twice, once normally (runtime) and once in static_assert.
• Split tests for each added function. Please follow the naming of test files according to the standard paragraphs.
• Add more tests with all standard integer types and extended integer types.
• Test various values and their combinations: 0 limits::min/max +-1, min/2, max/2 and so on. Test interesting combinations of different types

[curdeius]

FWIW, you can take a look at the stub I've started writing at https://github.com/mkurdej/llvm-project/commit/0b7eccea2fbab13e897502c6d44ff958a0d550a9.
You might have a look at tests and other stuff like extended integer types.
It's just a WIP and far from ready though, so use with caution.

libcxx/include/utility

312

You need to guard the use of char(8|16|32)_t.

[kamleshbhalui]

addressed @curdeius comments.
added tests, few test snippets taken from the link given by @curdeius.

[kamleshbhalui]

used _LIBCPP_NO_HAS_CHAR8_T and _LIBCPP_HAS_NO_UNICODE_CHARS macro to guard char8_t, and char16_t, char32_t.

note:
I think _LIBCPP_NO_HAS_CHAR8_T should be _LIBCPP_HAS_NO_CHAR8_T since _LIBCPP_NO_HAS_CHAR8_T is used at several places I used it here as well, I can clean it up in
different patch if everyone agrees.

[Mordante]

In D94511#2562349, @kamleshbhalui wrote:

I think _LIBCPP_NO_HAS_CHAR8_T should be _LIBCPP_HAS_NO_CHAR8_T since _LIBCPP_NO_HAS_CHAR8_T is used at several places I used it here as well, I can clean it up in
different patch if everyone agrees.

Nice catch! @ldionne Do we want to change the macro or is it considered a part of our API?

I'll had a short look and some remarks, will look in more detail later.

libcxx/include/utility

319

Is byte considered an integral in libc++?

321

Is there a reason no to use template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>. That can than also be used without the extra requires for cmp_not_equal.

323

Libc++ should only use __ugly_names, can you rename all t1 and similar cases to __t1?

libcxx/test/std/utilities/utility/intcmp/intcmp.pass.cpp

12 ↗

(On Diff #323623)

Can you add the synopsis for the functions tested?
Can you also add test with ASSERT_NOEXCEPT to validate the functions are noexcept?

22 ↗

(On Diff #323623)

The tests are user-land code, so please don't use _UglyNames

[kamleshbhalui]

libcxx/include/utility

319

no. and the test for this is already in intcmp.fail.cpp.

[kamleshbhalui]

addressed @Mordante comments.

[Mordante]

Can you use arc to upload the next diff. This will trigger our CI and we can see whether your patch passes all build nodes.

Also can you address @curdeius request: "Split tests for each added function. Please follow the naming of test files according to the standard paragraphs."

libcxx/include/utility

319

Yes but since it's not an integral it doesn't need to be removed from the set of integrals. I was just concerned libc++ would accept std::byte as an integral.

322

Please also mark the functions with _LIBCPP_INLINE_VISIBILITY e.g:

template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
_LIBCPP_INLINE_VISIBILITY constexpr
bool cmp_equal(const _T1 __t1, const _T2 __t2) noexcept

334

I think it would be nice to also use __is_safe_integral_cmp to properly constrain these functions.

libcxx/test/std/utilities/utility/intcmp/intcmp.fail.cpp

48

The tests at lines 29-36 all expect to get 10 failures. So if _LIBCPP_NO_HAS_CHAR8_T isn't defined there will be 9 and the test will fail.

libcxx/test/std/utilities/utility/intcmp/intcmp.pass.cpp

58 ↗

(On Diff #323649)

There are only tests where std::in_range returns true. I miss test where it fails and test where the template arguments R and T aren't the same.

351 ↗

(On Diff #323649)

Can you also test that test1 and test2 pass. Normally we tend to have one constexpr bool test function and call use test(); static_assert(test()); in main. For example `libcxx/test/std/algorithms/alg.modifying.operations/alg.copy/copy.pass.cpp'.

358 ↗

(On Diff #323649)

I like these tests!
Maybe add some additional tests where the bitwidth in the first and second tuple differ.

[kamleshbhalui]

Updated the tests

[curdeius]

libcxx/test/std/utilities/utility/intcmp/intcmp.fail.cpp

122–124

Please test some non-primitive non-enum type.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp

103

Please test signed char and unsigned char. This applies to other tests too.

[kamleshbhalui]

Addressed @curdeius comments.

[• Quuxplusone]

libcxx/include/utility

323

While you're in the area, please remove all the redundant consts from these function headers: bool cmp_equal(const _T1 __t1...) is too easily mistaken for (a typo for) bool cmp_equal(const _T1& __t1...).
So, just write

bool cmp_equal(_T1 __t1, _T2 __t2) noexcept

Also, if you feel like it, I think it would be more consistent with existing libc++ style to use the parameter names (_Tp __t, _Up __u) throughout.

339

My ADL sense is tingling. This turns out to be OK because __t1 and __t2 are guaranteed to be integral types with no associated namespaces; but I think it would still be a peace-of-mind improvement to write return !_VSTD::cmp_equal(__t1, __t2) (or rather return !_VSTD::cmp_equal(__t, __u)).

libcxx/test/std/utilities/utility/intcmp/intcmp.fail.cpp

27–30

This is a confusing name, because NonEmptyT is in fact an empty type. Did you mean to give it some non-static data members?

Anyway, the point of this test file seems to be to test that various interesting cases are not overload-resolved. So, I recommend testing only the interesting cases. struct EmptyT {} already covers the "test a class type" case. If you're looking for more cases to test that are interesting, I suggest

• a class type with an implicit conversion to int
• an enum type
• nullptr_t
• __int128_t

To be clear, I don't think you should add any of these (except maybe the enum). But they'd all be much more interesting from the QA perspective than yet another empty class type.

36–38

Please revert your whitespace changes here. There's nothing wrong with the code on the left, and it's much easier to read.

If you'd like to shorten the message, e.g.

std::cmp_equal(T(), T()); // expected-error7{{no matching function}}

that'd be fine IMHO. (But unnecessary. There's nothing wrong with the code on the left.)

[kamleshbhalui]

Incorporated @Quuxplusone suggestions.

[curdeius]

libcxx/include/utility

332

This doesn't make sense._Tp is unsigned here. You should have swapped t and u.
Cf. the example implementation https://raw.githubusercontent.com/fekir/safeintegral/master/safeintegral/safeintegralop_cmp.hpp.
But first, you need to add a regression test for this.

[curdeius]

I'd like to see some "manual" tests like:

• max(uint64_t) vs. min(int64_t) (both represented as 0xFF'FF'FF'FF unless I'm mistaken)

And other cases for the different non-trivial conditions of cmp_equal/cmp_less.
Please correct me if they're already present.

libcxx/include/utility

325

Please _Uglify the names.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.fail.cpp

52 ↗

(On Diff #335859)

Please be exhaustive and test less_equal, greater_equal, not_equal too.

[• Quuxplusone]

libcxx/include/utility

325–326

Thanks for renaming T1 to _Tp and T2 to _Up; however, that implies you also need to rename T2U into e.g. _UnsignedUp. Or just get rid of the name; it seems like you use it only once? E.g.

if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
   return __t == __u;
else if constexpr (is_signed_v<_Tp>)
   return (__t >= 0) && (__u == make_unsigned_t<_Tp>(__t));
else
   return (__u >= 0) && (__t == make_unsigned_t<_Up>(__u));

I'm actually puzzled how this isn't equivalent to simply

if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
   return __t == __u;
else
   return (__t >= 0) && (__u >= 0) && (__t == __u);

but I don't object to the longer form, especially since it's currently given on cppreference.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp

97–113

It appears that Types1 and Types2 are just the exact same list in a different order.
So I think what you want to do here is use just one list, but do all O(n^2) comparisons:

std::tuple<
#ifndef _LIBCPP_HAS_NO_INT128
    __int128_t, __uint128_t,
#endif
    unsigned long long, long long, unsigned long, long,
    unsigned int, int, unsigned short, short,
    unsigned char, signed char
> types;
test1(types);
test2(types, types);

preceded by

template <class... Ts>
constexpr void test1(const std::tuple<Ts...>&) {
  assert((test_cmp_equal1<Ts>() && ...));
}
template <class T, class... Us>
constexpr void test2_impl(const std::tuple<Us...>& utuple) {
    assert((test_cmp_equal2<T, Us>() && ...));
}
template <class... Ts, class UTuple>
constexpr void test2(const std::tuple<Ts...>&, const UTuple& utuple) {
    (test2_impl<Ts>(utuple) , ...);
}

You don't need to test uint32_t etc. because those are just library typedefs for the primitive types that you're already testing (e.g. unsigned int or unsigned long).

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater_equal/cmp_greater_equal.pass.cpp

57–64

I think it'd probably make sense to rewrite this as unconditional — lose the if:

assert(std::cmp_greater_equal(T(-1), T(-1)));
assert(std::cmp_greater_equal(-2, tup.min) == std::is_signed_v<T>);
assert(std::cmp_greater_equal(tup.min, -2) == std::is_unsigned_v<T>);
assert(!std::cmp_greater_equal(-2, tup.max));
assert(std::cmp_greater_equal(tup.max, -2));

114–115

Spurious newline here.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.fail.cpp

55–56 ↗

(On Diff #335859)

This style was... not what I wanted. :P I can fix the style post-commit, if need be.

[Mordante]

libcxx/include/utility

296

We recently added a macro to simplify this test. #if defined(__cpp_concepts) && __cpp_concepts >= 201811L -> #if !defined(_LIBCPP_HAS_NO_CONCEPTS), or better combine it with the #if the line above.

300

Can you also switch these to _Tp and _Up?

305

For consistency with the rest of our code-base please use _Tp, _Up, and _Args.

319

Please remove the byte.

326

I also like to remove the lines with using .... The code @Quuxplusone is easier to understand. Please also adjust cmp_less in the same fashion.

360

Minor nit, but it seems this is indented by 1 space. Please format the patch as described at https://llvm.org/docs/Contributing.html#how-to-submit-a-patch

[kamleshbhalui]

incorporated comments from @Quuxplusone, @Mordante and @curdeius

[kamleshbhalui]

fixed a typo.

[• Quuxplusone]

libcxx/include/utility

311

A type which is already known to be "integral" cannot also be cvref-qualified.
Please replace lines 296–318 with simply

template<class _Tp, class... _Up>
struct _IsSameAsAny : _Or<_IsSame<_Tp, _Up>...> {};

template<class _Tp>
concept __is_safe_integral_cmp = is_integral_v<_Tp> &&
                      !_IsSameAsAny<_Tp, bool, char,
#ifndef _LIBCPP_NO_HAS_CHAR8_T
                      char8_t,
#endif
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
                      char16_t, char32_t,
#endif
                      wchar_t>::value;

(Btw I've tested this against your tests and it passes them, so if anyone finds a bug in what I wrote, then you'll need more tests.)

349

You've got 1-space indents on lines 344, 346, 348. Please make them 2-space.
Ditto lines 325, 327, 329.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp

59–66

These tests also pass when !is_signed_v<T>, so you can remove line 58. (See also my unaddressed comment about the cmp_greater_equal test.)

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp

103

std::declval<int>() is a verbose way to write 0. Please write std::cmp_greater(0, 0) or std::cmp_greater(42, 42), your choice. (Ditto throughout. And then you can remove some clang-format-introduced linebreaks, too.)

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp

87

Bogus blank line on line 81.

[kamleshbhalui]

incorporated @Quuxplusone comments

[• Quuxplusone]

LGTM modulo these few last style notes.
I'd also appreciate better indentation in intcmp.fail.cpp — don't line-break in the middle of a qualified identifier! — but I know that'll be tedious to fix, and I still volunteer to go fix it later, if need be.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp

102–103

Nit: Please break this line in a sensible way. (Ditto throughout.) I suggest breaking before unsigned short.

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp

79

Sorry, I may have told you to do this initially, but am now revising it after seeing it in print. The functions test_cmp_greater1 and test_cmp_greater2 don't need to return bool because they already assert their own stuff. They should return void, and you should use (test_cmp_greater1<Ts>() , ...); instead of assert((test_cmp_greater1<Ts>() && ...));
(Style note: Prefer (xs , ...) in fold-expressions, not (xs, ...), to (subtly/obscurely) emphasize that it's the comma operator being folded and not somehow an ordinary comma-separated list of xs.)

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp

65–66

As above: test_in_range and test_in_range1 should just return void, and this should be a fold-expression over operator,.

[kamleshbhalui]

formatted the tests as per @Quuxplusone comments

[kamleshbhalui]

formatted intcmp.fail.cpp

[• Quuxplusone]

This continues to LGTM.
Can we get a second approver (@curdeius @Mordante @ldionne?), then let's land this, and then I'll update and land D100736 after that.

[Mordante]

There are still quite some formatting errors, for example () , instead of (),, please use the instructions here to format the patch https://llvm.org/docs/Contributing.html#how-to-submit-a-patch

Other than that is seems good now. I still like to see a fresh CI run, to make sure generate_feature_test_macro_components.py is updated properly.

libcxx/utils/generate_feature_test_macro_components.py

343 ↗

(On Diff #338486)

This should be "defined(__cpp_concepts) && __cpp_concepts >= 201907L", the guard below is correct.
(I'm sure wrote that before, but I can't find it anymore :-()

Make sure to run the script after updating.

[• Quuxplusone]

@Mordante wrote:

There are still quite some formatting errors, for example () , instead of (),, please use the instructions here to format the patch https://llvm.org/docs/Contributing.html#how-to-submit-a-patch

@Mordante: That's intentional; we write (x , ...) when we're folding over operator,. If clang-format can't tell the difference, that's a bug in clang-format.
(All: Please do not blindly clang-format; that just introduces whitespace errors that someone else will have to fix manually down the road.)

[kamleshbhalui]

In D94511#2698813, @Mordante wrote:

There are still quite some formatting errors, for example () , instead of (),, please use the instructions here to format the patch https://llvm.org/docs/Contributing.html#how-to-submit-a-patch

It's the case for fold expression, and it is done deliberately after @Quuxplusone suggestions.

Other than that is seems good now. I still like to see a fresh CI run, to make sure generate_feature_test_macro_components.py is updated properly.

ok, will update this.

[kamleshbhalui]

updated generate_feature_test_macro_components.py.

[curdeius]

LGTM.

[Mordante]

In D94511#2698917, @Quuxplusone wrote:

@Mordante wrote:

There are still quite some formatting errors, for example () , instead of (),, please use the instructions here to format the patch https://llvm.org/docs/Contributing.html#how-to-submit-a-patch

@Mordante: That's intentional; we write (x , ...) when we're folding over operator,. If clang-format can't tell the difference, that's a bug in clang-format.
(All: Please do not blindly clang-format; that just introduces whitespace errors that someone else will have to fix manually down the road.)

I was mainly concerned since a previous iteration had indention errors. I still prefer to leave the formatting to clang-format and be happy with it. But I know you have a different opinion. But since you asked for this formatting change I'm not objecting. So LGTM, even if it already landed.

libcxx/include/utility

 }
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp> constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; }
 template <class _Tp>                        void as_const(const _Tp&&) = delete;
 #endif
 
 #if _LIBCPP_STD_VER > 17
 #if defined(__cpp_concepts) && __cpp_concepts >= 201811L
 template<class...>
 struct __is_any_of;
 
 template<class _Ty1, class _Ty2>
 struct __is_any_of<_Ty1, _Ty2> {
 constexpr bool static value = is_same_v<_Ty1, _Ty2>;
 };
 
 template<class _Ty, class _Ty1, class..._Tyn>
 struct __is_any_of<_Ty, _Ty1, _Tyn...> {
 constexpr bool static value = is_same_v<_Ty, _Ty1> || __is_any_of<_Ty, _Tyn...>::value;
 };
 
 template<class _Ty>
 concept __is_safe_integral_cmp = is_integral_v<_Ty> &&
                       !__is_any_of<remove_cvref_t<_Ty>, bool, char,
 #ifndef _LIBCPP_NO_HAS_CHAR8_T
                       char8_t,
 #endif // !_LIBCPP_NO_HAS_CHAR8_T
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
                       char16_t, char32_t,
 #endif // !_LIBCPP_HAS_NO_UNICODE_CHARS
                       wchar_t, byte>::value;
 
 template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
-constexpr bool cmp_equal(const _T1 __t1, const _T2 __t2) noexcept
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_equal(const _T1 __t1, const _T2 __t2) noexcept
 {
   using T1U = make_unsigned_t<_T1>;
   using T2U = make_unsigned_t<_T2>;
   if constexpr (is_signed_v<_T1> == is_signed_v<_T2>)
    return __t1 == __t2;
   else if constexpr (is_signed_v<_T1>)
    return __t1 < 0 ? false : T1U(__t1) == __t2;
   else
    return __t2 < 0 ? false : __t1 == T2U(__t2);
 }
 
-template<class _T1, class _T2>
-constexpr bool cmp_not_equal(const _T1 __t1, const _T2 __t2) noexcept
+template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_not_equal(const _T1 __t1, const _T2 __t2) noexcept
 {
   return !cmp_equal(__t1, __t2);
 }
 
 template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
-constexpr bool cmp_less(const _T1 __t1, const _T2 __t2) noexcept
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_less(const _T1 __t1, const _T2 __t2) noexcept
 {
   using T1U = make_unsigned_t<_T1>;
   using T2U = make_unsigned_t<_T2>;
   if constexpr (is_signed_v<_T1> == is_signed_v<_T2>)
    return __t1 < __t2;
   else if constexpr (is_signed_v<_T1>)
    return __t1 < 0 ? true : T1U(__t1) < __t2;
   else
    return __t2 < 0 ? false : __t1 < T2U(__t2);
 }
 
-template<class _T1, class _T2>
-constexpr bool cmp_greater(const _T1 __t1, const _T2 __t2) noexcept
+template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_greater(const _T1 __t1, const _T2 __t2) noexcept
 {
  return cmp_less(__t2, __t1);
 }
 
-template<class _T1, class _T2>
-constexpr bool cmp_less_equal(const _T1 __t1, const _T2 __t2) noexcept
+template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_less_equal(const _T1 __t1, const _T2 __t2) noexcept
 {
   return !cmp_greater(__t1, __t2);
 }
 
-template<class _T1, class _T2>
-constexpr bool cmp_greater_equal(const _T1 __t1, const _T2 __t2) noexcept
+template<__is_safe_integral_cmp _T1, __is_safe_integral_cmp _T2>
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool cmp_greater_equal(const _T1 __t1, const _T2 __t2) noexcept
 {
  return !cmp_less(__t1, __t2);
 }
 
 template<__is_safe_integral_cmp _Rt, __is_safe_integral_cmp _Ty>
-constexpr bool in_range(const _Ty __t) noexcept
+_LIBCPP_INLINE_VISIBILITY constexpr
+bool in_range(const _Ty __t) noexcept
 {
   return cmp_less_equal(__t, numeric_limits<_Rt>::max()) &&
          cmp_greater_equal(__t, numeric_limits<_Rt>::min());
 }
 #endif
 #endif
 
 struct _LIBCPP_TEMPLATE_VIS piecewise_construct_t { explicit piecewise_construct_t() = default; };

libcxx/test/std/utilities/utility/intcmp/intcmp.fail.cpp

 
 // template<class R, class T>
 //   constexpr bool in_range(T t) noexcept;      // C++20
 
 #include <utility>
 
 #include "test_macros.h"
 
+struct NonEmptyT {
+  static int foo;
+  void func(int);
+};
+
+struct EmptyT {};
+
 template<class T>
 constexpr void test() {
-  std::cmp_equal(T(), T());   // expected-error10{{no matching function for call to 'cmp_equal'}}
-  std::cmp_equal(T(), int()); // expected-error10{{no matching function for call to 'cmp_equal'}}
-  std::cmp_equal(int(), T()); // expected-error10{{no matching function for call to 'cmp_equal'}}
-  std::cmp_less(T(), T());    // expected-error10{{no matching function for call to 'cmp_less'}}
-  std::cmp_less(T(), int());  // expected-error10{{no matching function for call to 'cmp_less'}}
-  std::cmp_less(int(), T());  // expected-error10{{no matching function for call to 'cmp_less'}}
-  std::in_range<T>(int());    // expected-error10{{no matching function for call to 'in_range'}}
-  std::in_range<int>(T());    // expected-error10{{no matching function for call to 'in_range'}}
+  std::cmp_equal(
+      T(),
+      T()); // expected-error7{{no matching function for call to 'cmp_equal'}}
+  std::cmp_equal(
+      T(),
+      int()); // expected-error7{{no matching function for call to 'cmp_equal'}}
+  std::cmp_equal(
+      int(),
+      T()); // expected-error7{{no matching function for call to 'cmp_equal'}}
+  std::cmp_less(
+      T(),
+      T()); // expected-error7{{no matching function for call to 'cmp_less'}}
+  std::cmp_less(
+      T(),
+      int()); // expected-error7{{no matching function for call to 'cmp_less'}}
+  std::cmp_less(
+      int(),
+      T()); // expected-error7{{no matching function for call to 'cmp_less'}}
+  std::in_range<T>(
+      int()); // expected-error7{{no matching function for call to 'in_range'}}
+  std::in_range<int>(
+      T()); // expected-error7{{no matching function for call to 'in_range'}}
+}
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+template <class T>
+constexpr void test_char8t() {
+  std::cmp_equal(
+      T(),
+      T()); // expected-error{{no matching function for call to 'cmp_equal'}}
+  std::cmp_equal(
+      T(),
+      int()); // expected-error{{no matching function for call to 'cmp_equal'}}
+  std::cmp_equal(
+      int(),
+      T()); // expected-error{{no matching function for call to 'cmp_equal'}}
+  std::cmp_less(
+      T(),
+      T()); // expected-error{{no matching function for call to 'cmp_less'}}
+  std::cmp_less(
+      T(),
+      int()); // expected-error{{no matching function for call to 'cmp_less'}}
+  std::cmp_less(
+      int(),
+      T()); // expected-error{{no matching function for call to 'cmp_less'}}
+  std::in_range<T>(
+      int()); // expected-error{{no matching function for call to 'in_range'}}
+  std::in_range<int>(
+      T()); // expected-error{{no matching function for call to 'in_range'}}
+}
+#endif // _LIBCPP_NO_HAS_CHAR8_T
+
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+template <class T>
+constexpr void test_uchars() {
+  std::cmp_equal(
+      T(),
+      T()); // expected-error2{{no matching function for call to 'cmp_equal'}}
+  std::cmp_equal(
+      T(),
+      int()); // expected-error2{{no matching function for call to 'cmp_equal'}}
+  std::cmp_equal(
+      int(),
+      T()); // expected-error2{{no matching function for call to 'cmp_equal'}}
+  std::cmp_less(
+      T(),
+      T()); // expected-error2{{no matching function for call to 'cmp_less'}}
+  std::cmp_less(
+      T(),
+      int()); // expected-error2{{no matching function for call to 'cmp_less'}}
+  std::cmp_less(
+      int(),
+      T()); // expected-error2{{no matching function for call to 'cmp_less'}}
+  std::in_range<T>(
+      int()); // expected-error2{{no matching function for call to 'in_range'}}
+  std::in_range<int>(
+      T()); // expected-error2{{no matching function for call to 'in_range'}}
 }
+#endif // _LIBCPP_HAS_NO_UNICODE_CHARS
 
 int main() {
   test<bool>();
   test<char>();
   test<wchar_t>();
   test<float>();
   test<double>();
   test<long double>();
   test<std::byte>();
+  test<NonEmptyT>();
+  test<EmptyT>();
 #ifndef _LIBCPP_NO_HAS_CHAR8_T
-  test<char8_t>();
+  test_char8t<char8_t>();
 #endif // !_LIBCPP_NO_HAS_CHAR8_T
 
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
-  test<char16_t>();
-  test<char32_t>();
+  test_uchars<char16_t>();
+  test_uchars<char32_t>();
 #endif // !_LIBCPP_HAS_NO_UNICODE_CHARS
 return 0;
 }

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_equal/cmp_equal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// <utility>
+
+// template<class T, class U>
+//   constexpr bool cmp_equal(T t, U u) noexcept;         // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr static bool test_cmp_equal1() {
+  constexpr Tuple<T> tup;
+  assert(std::cmp_equal(T(0), T(0)));
+  assert(std::cmp_equal(T(10), T(10)));
+  assert(std::cmp_equal(tup.min, tup.min));
+  assert(std::cmp_equal(tup.max, tup.max));
+
+  assert(!std::cmp_equal(T(0), T(1)));
+  assert(!std::cmp_equal(T(1), T(0)));
+  assert(!std::cmp_equal(T(5), T(10)));
+  assert(!std::cmp_equal(T(10), T(5)));
+
+  assert(!std::cmp_equal(tup.min, tup.max));
+  assert(!std::cmp_equal(tup.max, tup.min));
+
+  assert(!std::cmp_equal(1, tup.max));
+  assert(!std::cmp_equal(tup.max, 1));
+  assert(!std::cmp_equal(1, tup.min));
+  assert(!std::cmp_equal(tup.min, 1));
+
+  if constexpr (std::is_signed_v<T>) {
+    assert(std::cmp_equal(T(-5), T(-5)));
+
+    assert(!std::cmp_equal(-2, tup.min));
+    assert(!std::cmp_equal(tup.min, -2));
+    assert(!std::cmp_equal(-2, tup.max));
+    assert(!std::cmp_equal(tup.max, -2));
+  }
+  return true;
+}
+
+template <typename T, typename U>
+constexpr static bool test_cmp_equal2() {
+  constexpr Tuple<T> ttup;
+  constexpr Tuple<U> utup;
+  assert(std::cmp_equal(T(0), U(0)));
+  assert(std::cmp_equal(T(10), U(10)));
+  assert(!std::cmp_equal(T(0), U(1)));
+  assert(!std::cmp_equal(T(1), U(0)));
+  assert(!std::cmp_equal(T(5), U(10)));
+  assert(!std::cmp_equal(T(10), U(5)));
+  assert(!std::cmp_equal(ttup.min, utup.max));
+  assert(!std::cmp_equal(utup.min, ttup.max));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_cmp_equal1<T>());
+}
+
+template <typename... T, typename... U>
+constexpr bool test2(const std::tuple<T...>&, const std::tuple<U...>&) {
+  static_assert(sizeof...(T) == sizeof...(U));
+  return (... && test_cmp_equal2<T, U>()) && (... && test_cmp_equal2<U, T>());
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  using Types2 = std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, uint64_t, int64_t, unsigned long, long,
+      uint32_t, int32_t, unsigned int, int, uint16_t, int16_t, unsigned short,
+      short, uint8_t, int8_t, unsigned char, signed char>;
+  assert(test1(Types1{}) && test2(Types1{}, Types1{}) &&
+         test2(Types1{}, Types2{}));
+  return true;
+}
+
+int main() {
+
+  ASSERT_NOEXCEPT(std::cmp_equal(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater/cmp_greater.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// <utility>
+
+//   constexpr bool cmp_greater(T t, U u) noexcept;       // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr bool test_cmp_greater1() {
+  constexpr Tuple<T> tup;
+  assert(!std::cmp_greater(T(0), T(1)));
+  assert(!std::cmp_greater(T(1), T(2)));
+  assert(!std::cmp_greater(tup.min, tup.max));
+  assert(!std::cmp_greater(tup.min, tup.mid));
+  assert(!std::cmp_greater(tup.mid, tup.max));
+
+  assert(std::cmp_greater(T(1), T(0)));
+  assert(std::cmp_greater(T(10), T(5)));
+  assert(std::cmp_greater(tup.max, tup.min));
+  assert(std::cmp_greater(tup.mid, tup.min));
+  assert(!std::cmp_greater(tup.mid, tup.mid));
+  assert(!std::cmp_greater(tup.min, tup.min));
+  assert(!std::cmp_greater(tup.max, tup.max));
+
+  assert(std::cmp_greater(tup.max, 1));
+  assert(std::cmp_greater(1, tup.min));
+
+  if constexpr (std::is_signed_v<T>) {
+    assert(!std::cmp_greater(T(-1), T(-1)));
+    assert(std::cmp_greater(-2, tup.min));
+    assert(!std::cmp_greater(tup.min, -2));
+    assert(!std::cmp_greater(-2, tup.max));
+    assert(std::cmp_greater(tup.max, -2));
+  }
+
+  return true;
+}
+
+template <typename T, typename U>
+constexpr bool test_cmp_greater2() {
+  assert(!std::cmp_greater(T(0), U(1)));
+  assert(std::cmp_greater(T(1), U(0)));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_cmp_greater1<T>());
+}
+
+template <typename... T, typename... U>
+constexpr bool test2(const std::tuple<T...>&, const std::tuple<U...>&) {
+  static_assert(sizeof...(T) == sizeof...(U));
+  return (... && test_cmp_greater2<T, U>()) &&
+         (... && test_cmp_greater2<U, T>());
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  using Types2 = std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, uint64_t, int64_t, unsigned long, long,
+      uint32_t, int32_t, unsigned int, int, uint16_t, int16_t, unsigned short,
+      short, uint8_t, int8_t, unsigned char, signed char>;
+  assert(test1(Types1{}) && test2(Types1{}, Types1{}) &&
+         test2(Types1{}, Types2{}));
+  return true;
+}
+
+int main() {
+
+  ASSERT_NOEXCEPT(std::cmp_greater(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_greater_equal/cmp_greater_equal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// <utility>
+
+//   constexpr bool cmp_greater_equal(T t, U u) noexcept; // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr bool test_cmp_greater_equal1() {
+  constexpr Tuple<T> tup;
+  assert(!std::cmp_greater_equal(T(0), T(1)));
+  assert(!std::cmp_greater_equal(T(1), T(2)));
+  assert(!std::cmp_greater_equal(tup.min, tup.max));
+  assert(!std::cmp_greater_equal(tup.min, tup.mid));
+  assert(!std::cmp_greater_equal(tup.mid, tup.max));
+
+  assert(std::cmp_greater_equal(T(1), T(0)));
+  assert(std::cmp_greater_equal(T(10), T(5)));
+  assert(std::cmp_greater_equal(tup.max, tup.min));
+  assert(std::cmp_greater_equal(tup.mid, tup.min));
+  assert(std::cmp_greater_equal(tup.mid, tup.mid));
+  assert(std::cmp_greater_equal(tup.min, tup.min));
+  assert(std::cmp_greater_equal(tup.max, tup.max));
+
+  assert(std::cmp_greater_equal(tup.max, 1));
+  assert(std::cmp_greater_equal(1, tup.min));
+
+  if constexpr (std::is_signed_v<T>) {
+    assert(std::cmp_greater_equal(T(-1), T(-1)));
+
+    assert(std::cmp_greater_equal(-2, tup.min));
+    assert(!std::cmp_greater_equal(tup.min, -2));
+    assert(!std::cmp_greater_equal(-2, tup.max));
+    assert(std::cmp_greater_equal(tup.max, -2));
+  }
+  return true;
+}
+
+template <typename T, typename U>
+constexpr bool test_cmp_greater_equal2() {
+  assert(!std::cmp_greater_equal(T(0), U(1)));
+  assert(std::cmp_greater_equal(T(1), U(0)));
+  assert(std::cmp_greater_equal(T(0), U(0)));
+  assert(std::cmp_greater_equal(T(1), U(1)));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_cmp_greater_equal1<T>());
+}
+
+template <typename... T, typename... U>
+constexpr bool test2(const std::tuple<T...>&, const std::tuple<U...>&) {
+  static_assert(sizeof...(T) == sizeof...(U));
+  return (... && test_cmp_greater_equal2<T, U>()) &&
+         (... && test_cmp_greater_equal2<U, T>());
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  using Types2 = std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, uint64_t, int64_t, unsigned long, long,
+      uint32_t, int32_t, unsigned int, int, uint16_t, int16_t, unsigned short,
+      short, uint8_t, int8_t, unsigned char, signed char>;
+  assert(test1(Types1{}) && test2(Types1{}, Types1{}) &&
+         test2(Types1{}, Types2{}));
+  return true;
+}
+
+int main() {
+
+  ASSERT_NOEXCEPT(
+      std::cmp_greater_equal(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less/cmp_less.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// <utility>
+
+// template<class T, class U>
+//   constexpr bool cmp_less(T t, U u) noexcept;          // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr bool test_cmp_less1() {
+  constexpr Tuple<T> tup;
+  assert(std::cmp_less(T(0), T(1)));
+  assert(std::cmp_less(T(1), T(2)));
+  assert(std::cmp_less(tup.min, tup.max));
+  assert(std::cmp_less(tup.min, tup.mid));
+  assert(std::cmp_less(tup.mid, tup.max));
+
+  assert(!std::cmp_less(T(1), T(0)));
+  assert(!std::cmp_less(T(10), T(5)));
+  assert(!std::cmp_less(tup.max, tup.min));
+  assert(!std::cmp_less(tup.mid, tup.min));
+  assert(!std::cmp_less(tup.mid, tup.mid));
+  assert(!std::cmp_less(tup.min, tup.min));
+  assert(!std::cmp_less(tup.max, tup.max));
+
+  assert(!std::cmp_less(tup.max, 1));
+  assert(!std::cmp_less(1, tup.min));
+
+  if constexpr (std::is_signed_v<T>) {
+    assert(!std::cmp_less(T(-1), T(-1)));
+
+    assert(!std::cmp_less(-2, tup.min));
+    assert(std::cmp_less(tup.min, -2));
+    assert(std::cmp_less(-2, tup.max));
+    assert(!std::cmp_less(tup.max, -2));
+  }
+
+  return true;
+}
+
+template <typename T, typename U>
+constexpr bool test_cmp_less2() {
+  assert(std::cmp_less(T(0), U(1)));
+  assert(!std::cmp_less(T(1), U(0)));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_cmp_less1<T>());
+}
+
+template <typename... T, typename... U>
+constexpr bool test2(const std::tuple<T...>&, const std::tuple<U...>&) {
+  static_assert(sizeof...(T) == sizeof...(U));
+  return (... && test_cmp_less2<T, U>()) && (... && test_cmp_less2<U, T>());
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  using Types2 = std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, uint64_t, int64_t, unsigned long, long,
+      uint32_t, int32_t, unsigned int, int, uint16_t, int16_t, unsigned short,
+      short, uint8_t, int8_t, unsigned char, signed char>;
+  assert(test1(Types1{}) && test2(Types1{}, Types1{}) &&
+         test2(Types1{}, Types2{}));
+  return true;
+}
+
+int main() {
+  ASSERT_NOEXCEPT(std::cmp_less(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_less_equal/cmp_less_equal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// <utility>
+
+//   constexpr bool cmp_less_equal(T t, U u) noexcept;    // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr bool test_cmp_less_equal1() {
+  constexpr Tuple<T> tup;
+  assert(std::cmp_less_equal(T(0), T(0)));
+  assert(std::cmp_less_equal(T(0), T(1)));
+  assert(std::cmp_less_equal(tup.min, tup.max));
+  assert(std::cmp_less_equal(tup.min, tup.mid));
+  assert(std::cmp_less_equal(tup.mid, tup.max));
+  assert(std::cmp_less_equal(tup.max, tup.max));
+  assert(std::cmp_less_equal(tup.mid, tup.mid));
+  assert(std::cmp_less_equal(tup.min, tup.min));
+
+  assert(!std::cmp_less_equal(T(1), T(0)));
+  assert(!std::cmp_less_equal(T(10), T(5)));
+  assert(!std::cmp_less_equal(tup.max, tup.min));
+  assert(!std::cmp_less_equal(tup.mid, tup.min));
+  assert(!std::cmp_less_equal(tup.max, 1));
+  assert(!std::cmp_less_equal(1, tup.min));
+
+  if constexpr (std::is_signed_v<T>) {
+    assert(std::cmp_less_equal(T(-1), T(-1)));
+    assert(!std::cmp_less_equal(-2, tup.min));
+    assert(std::cmp_less_equal(tup.min, -2));
+    assert(std::cmp_less_equal(-2, tup.max));
+    assert(!std::cmp_less_equal(tup.max, -2));
+  }
+  return true;
+}
+
+template <typename T, typename U>
+constexpr bool test_cmp_less_equal2() {
+  assert(std::cmp_less_equal(T(0), U(1)));
+  assert(std::cmp_less_equal(T(0), U(0)));
+  assert(!std::cmp_less_equal(T(1), U(0)));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_cmp_less_equal1<T>());
+}
+
+template <typename... T, typename... U>
+constexpr bool test2(const std::tuple<T...>&, const std::tuple<U...>&) {
+  static_assert(sizeof...(T) == sizeof...(U));
+  return (... && test_cmp_less_equal2<T, U>()) &&
+         (... && test_cmp_less_equal2<U, T>());
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  using Types2 = std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, uint64_t, int64_t, unsigned long, long,
+      uint32_t, int32_t, unsigned int, int, uint16_t, int16_t, unsigned short,
+      short, uint8_t, int8_t, unsigned char, signed char>;
+  assert(test1(Types1{}) && test2(Types1{}, Types1{}) &&
+         test2(Types1{}, Types2{}));
+  return true;
+}
+int main() {
+
+  ASSERT_NOEXCEPT(
+      std::cmp_less_equal(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.cmp_not_equal/cmp_not_equal.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// <utility>
+
+// template<class T, class U>
+//   constexpr bool cmp_not_equal(T t, U u) noexcept;     // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr bool test_cmp_not_equal1() {
+  constexpr Tuple<T> tup;
+  assert(!std::cmp_not_equal(T(0), T(0)));
+  assert(!std::cmp_not_equal(T(10), T(10)));
+  assert(!std::cmp_not_equal(tup.min, tup.min));
+  assert(!std::cmp_not_equal(tup.max, tup.max));
+
+  assert(std::cmp_not_equal(T(0), T(1)));
+  assert(std::cmp_not_equal(T(1), T(0)));
+  assert(std::cmp_not_equal(T(5), T(10)));
+  assert(std::cmp_not_equal(T(10), T(5)));
+
+  assert(std::cmp_not_equal(tup.min, tup.max));
+  assert(std::cmp_not_equal(tup.max, tup.min));
+
+  assert(std::cmp_not_equal(1, tup.max));
+  assert(std::cmp_not_equal(tup.max, 1));
+  assert(std::cmp_not_equal(1, tup.min));
+  assert(std::cmp_not_equal(tup.min, 1));
+
+  if constexpr (std::is_signed_v<T>) {
+    assert(std::cmp_not_equal(-2, tup.min));
+    assert(std::cmp_not_equal(tup.min, -2));
+    assert(std::cmp_not_equal(-2, tup.max));
+    assert(std::cmp_not_equal(tup.max, -2));
+  }
+
+  return true;
+}
+
+template <typename T, typename U>
+constexpr bool test_cmp_not_equal2() {
+  constexpr Tuple<T> ttup;
+  constexpr Tuple<U> utup;
+  assert(!std::cmp_not_equal(T(0), U(0)));
+  assert(!std::cmp_not_equal(T(10), U(10)));
+
+  assert(std::cmp_not_equal(T(0), U(1)));
+  assert(std::cmp_not_equal(T(1), U(0)));
+  assert(std::cmp_not_equal(T(5), U(10)));
+  assert(std::cmp_not_equal(T(10), U(5)));
+  assert(std::cmp_not_equal(ttup.min, utup.max));
+  assert(std::cmp_not_equal(utup.min, ttup.max));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_cmp_not_equal1<T>());
+}
+
+template <typename... T, typename... U>
+constexpr bool test2(const std::tuple<T...>&, const std::tuple<U...>&) {
+  static_assert(sizeof...(T) == sizeof...(U));
+  return (... && test_cmp_not_equal2<T, U>()) &&
+         (... && test_cmp_not_equal2<U, T>());
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  using Types2 = std::tuple<
+#ifndef _LIBCPP_HAS_NO_INT128
+      __int128_t, __uint128_t,
+#endif
+      unsigned long long, long long, uint64_t, int64_t, unsigned long, long,
+      uint32_t, int32_t, unsigned int, int, uint16_t, int16_t, unsigned short,
+      short, uint8_t, int8_t, unsigned char, signed char>;
+  assert(test1(Types1{}) && test2(Types1{}, Types2{}) &&
+         test2(Types1{}, Types2{}) && test2(Types2{}, Types1{}));
+  return true;
+}
+
+int main() {
+
+  ASSERT_NOEXCEPT(std::cmp_not_equal(std::declval<int>(), std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+
+// <utility>
+
+// template<class R, class T>
+//   constexpr bool in_range(T t) noexcept;               // C++20
+
+#include <utility>
+#include <limits>
+#include <numeric>
+#include <tuple>
+#include <cassert>
+
+#include "test_macros.h"
+
+template <typename T>
+struct Tuple {
+  T min;
+  T max;
+  T mid;
+  constexpr Tuple() {
+    min = std::numeric_limits<T>::min();
+    max = std::numeric_limits<T>::max();
+    mid = std::midpoint(min, max);
+  }
+};
+
+template <typename T>
+constexpr static bool test_in_range() {
+  constexpr Tuple<T> tup;
+  assert(std::in_range<T>(tup.min));
+  assert(std::in_range<T>(tup.min + 1));
+  assert(std::in_range<T>(tup.max));
+  assert(std::in_range<T>(tup.max - 1));
+  assert(std::in_range<T>(tup.mid));
+  assert(std::in_range<T>(tup.mid - 1));
+  assert(std::in_range<T>(tup.mid + 1));
+  return true;
+}
+
+constexpr static bool test_in_range1() {
+  constexpr Tuple<uint8_t> utup8;
+  constexpr Tuple<int8_t> stup8;
+  assert(!std::in_range<int8_t>(utup8.max));
+  assert(std::in_range<short>(utup8.max));
+  assert(!std::in_range<uint8_t>(stup8.min));
+  assert(std::in_range<int8_t>(utup8.mid));
+  assert(!std::in_range<uint8_t>(stup8.mid));
+  assert(!std::in_range<uint8_t>(-1));
+  return true;
+}
+
+template <typename... T>
+constexpr bool test1(const std::tuple<T...>&) {
+  return (... && test_in_range<T>()) && test_in_range1();
+}
+
+constexpr bool test() {
+  using Types1 =
+      std::tuple<signed char, unsigned char, int8_t, uint8_t, short,
+                 unsigned short, int16_t, uint16_t, int, unsigned int, int32_t,
+                 uint32_t, long, unsigned long, int64_t, uint64_t, long long,
+                 unsigned long long
+#ifndef _LIBCPP_HAS_NO_INT128
+                 ,
+                 __int128_t, __uint128_t
+#endif
+                 >;
+  assert(test1(Types1{}));
+  return true;
+}
+
+int main() {
+
+  ASSERT_NOEXCEPT(std::in_range<int>(std::declval<int>()));
+  test();
+  static_assert(test());
+  return 0;
+}