[libc++][test] Uses qualified std::uint32_t.

[Mordante]

Summary

The module std does not provide c-types in the global namespace. This
means all these types need to be fully qualified. This is a first step
to convert them by using sed.

Since this is an automated conversion other types like uint64_t are kept
as is.

Note that tests in the directory libcxx/test/std/depr/depr.c.headers
should not be converted automatically. This requires manual attention,
there some test require testing uint32_t in the global namespace. These
test should fail when using the std module, and pass when using the
std.compat module.

A similar issue occurs with atomic, atomic_uint32_t is specified as

using atomic_uint32_t = atomic<uint32_t>; // freestanding

So here too we need to keep the name in the global namespace in the
tests.

[Mordante]

libcxx/test/libcxx/type_traits/convert_to_integral.pass.cpp

97

Comments are not really required, but since the conversion will be quite some work I prefer to make no exception for the comments.

libcxx/test/std/atomics/atomics.types.generic/integral.pass.cpp

191 ↗

(On Diff #503111)

I thought I had reverted this change locally, but seems I didn't.

libcxx/test/std/atomics/types.pass.cpp

145

I didn't fix the alignment:

• it will correct itself in this case when the other types are done.
• I really don't want to manually format over 1000 places manually.

[philnik]

Is there a reason you don't qualify all the integer aliases in a single patch? Also, should we maybe start to enforce a few clang-tidy checks on the tests, so we can avoid regressing on this? It's probably not too hard to add a check.

[ldionne]

In D145520#4175977, @philnik wrote:

Is there a reason you don't qualify all the integer aliases in a single patch? Also, should we maybe start to enforce a few clang-tidy checks on the tests, so we can avoid regressing on this? It's probably not too hard to add a check.

Mark and I discussed this offline and we decided to start with a small patch to evaluate how that was going to behave with downstream merging. Other patches will touch things like size_t (so 1000+ files in the test suite). Seeing the reasonable impact of this one, I wouldn't be opposed to doing this for other types like int64_t & friends in this patch, if it keeps the scope similar. But I'm also OK with separate patches.

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp

19

Technically, I think this doesn't need to change since the synopsis in the standard is based on the fact that we're already inside namespace std.

[Mordante]

Rebased to CI and addresses review comments.

[Mordante]

Thanks for the quick reviews!

In D145520#4175998, @ldionne wrote:

In D145520#4175977, @philnik wrote:

Is there a reason you don't qualify all the integer aliases in a single patch? Also, should we maybe start to enforce a few clang-tidy checks on the tests, so we can avoid regressing on this? It's probably not too hard to add a check.

Mark and I discussed this offline and we decided to start with a small patch to evaluate how that was going to behave with downstream merging. Other patches will touch things like size_t (so 1000+ files in the test suite). Seeing the reasonable impact of this one, I wouldn't be opposed to doing this for other types like int64_t & friends in this patch, if it keeps the scope similar. But I'm also OK with separate patches.

As discussed with Louis we don't need to check it. Once we have the module std the CI will check it. So yes we might regress between now and that time, but at least then the changes will be small.

For the first patch I think this is a nice size, for the first step. I feel that doing all other 'u?int(_least|_fast|)\d\d?_t` types can be done in the one patch.

PS I wouldn't mind to clang-tidy our tests too.

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp

19

Maybe I should look at avoiding updating comments. For the synopsis it indeed feels wrong.

libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp

int main(int, char**)
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
 
 #ifndef TEST_HAS_NO_INT128
     test<__int128_t>();
     test<__uint128_t>();
 #endif
 
     test<char>();
     test<ptrdiff_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/libcxx/type_traits/convert_to_integral.pass.cpp

int main(int, char**)
   check_integral_types<char, int>();
   check_integral_types<signed char, int>();
   check_integral_types<unsigned char, int>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   check_integral_types<wchar_t, decltype(((wchar_t)1) + 1)>();
 #endif
   check_integral_types<char16_t, int>();
   // On some platforms, unsigned int and long are the same size.  These
-  // platforms have a choice of making uint32_t an int or a long.  However
+  // platforms have a choice of making std::uint32_t an int or a long.  However
   // char32_t must promote to an unsigned int on these platforms [conv.prom].
   // Use the following logic to make the test work on such platforms.
-  // (sizeof(uint32_t) == sizeof(unsigned int)) ? unsigned int : uint32_t;
-  typedef std::conditional<sizeof(uint32_t) == sizeof(unsigned int),
-                           unsigned int, uint32_t>::type char_integral;
+  // (sizeof(std::uint32_t) == sizeof(unsigned int)) ? unsigned int : std::uint32_t;
+  typedef std::conditional<sizeof(std::uint32_t) == sizeof(unsigned int),
+                           unsigned int, std::uint32_t>::type char_integral;
   check_integral_types<char32_t, char_integral>();
   check_integral_types<short, int>();
   check_integral_types<unsigned short, int>();
   check_integral_types<int, int>();
   check_integral_types<unsigned, unsigned>();
   check_integral_types<long, long>();
   check_integral_types<unsigned long, unsigned long>();
   check_integral_types<long long, long long>();

libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp

#endif
     using integral_16 = types::type_list<char16_t, int16_t, uint16_t>;
 #if !defined(TEST_HAS_NO_WIDE_CHARACTERS) && __WCHAR_WIDTH__ == 16
     check<true, types::concatenate_t<integral_16, types::type_list<wchar_t>>>();
 #else
     check<true, integral_16>();
 #endif
 
     // 32-bit types.
-    using integral_32 = types::type_list<char32_t, int32_t, uint32_t>;
+    using integral_32 = types::type_list<char32_t, int32_t, std::uint32_t>;
 #if !defined(TEST_HAS_NO_WIDE_CHARACTERS) && __WCHAR_WIDTH__ == 32
     check<true, types::concatenate_t<integral_32, types::type_list<wchar_t>>>();
 #else
     check<true, integral_32>();
 #endif
 
     // 64-bit types.
     using integral_64 = types::type_list<int64_t, uint64_t>;

libcxx/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp

 #include <cstdint>
 #include <functional>
 #include <limits>
 #include <string>
 #include <utility>
 
 #include "test_macros.h"
 
-typedef std::__murmur2_or_cityhash<uint32_t> Hash32;
+typedef std::__murmur2_or_cityhash<std::uint32_t> Hash32;
 typedef std::__murmur2_or_cityhash<uint64_t> Hash64;
 
 void test(const void* key, int len) {
   for (int i=1; i <= len; ++i) {
     Hash32 h1;
     Hash64 h2;
     DoNotOptimize(h1(key, i));
     DoNotOptimize(h2(key, i));

libcxx/test/std/atomics/types.pass.cpp

#endif
     test<int_fast64_t>  ();
     test<uint_fast64_t> ();
 
     test< int8_t>  ();
     test<uint8_t>  ();
     test< int16_t> ();
     test<uint16_t> ();
     test< int32_t> ();
-    test<uint32_t> ();
+    test<std::uint32_t> ();
     test< int64_t> ();
     test<uint64_t> ();
 
     test<intptr_t>  ();
     test<uintptr_t> ();
     test<size_t>    ();
     test<ptrdiff_t> ();
     test<intmax_t>  ();

libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp

TEST_CONSTEXPR_CXX20 void test_ctor_with_different_value_type() {
     // Though the types Der* and B2* are very similar, initialization still cannot
     // be done with `memcpy`.
     std::vector<B2*> v(array, array + 1);
     assert(v[0] == &z);
   }
   {
     // Though the types are different, initialization can be done with `memcpy`.
     int32_t array[1] = { -1 };
-    std::vector<uint32_t> v(array, array + 1);
+    std::vector<std::uint32_t> v(array, array + 1);
     assert(v[0] == 4294967295U);
   }
 }
 
 TEST_CONSTEXPR_CXX20 bool tests() {
   basic_test_cases();
   emplaceable_concept_tests(); // See PR34898
   test_ctor_with_different_value_type();

libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp

 
 void compile_narrowing_conversion() {
   supported_native_simd_ctor<int8_t>(3);
   supported_native_simd_ctor<int16_t>(3);
   supported_native_simd_ctor<int32_t>(3);
   supported_native_simd_ctor<int64_t>(3);
   supported_native_simd_ctor<uint8_t>(3);
   supported_native_simd_ctor<uint16_t>(3);
-  supported_native_simd_ctor<uint32_t>(3);
+  supported_native_simd_ctor<std::uint32_t>(3);
   supported_native_simd_ctor<uint64_t>(3);
   supported_native_simd_ctor<float>(3.f);
   supported_native_simd_ctor<double>(3.);
   supported_native_simd_ctor<long double>(3.);
 
   not_supported_native_simd_ctor<float>(3.);
   not_supported_native_simd_ctor<int8_t>(long(3));
   not_supported_native_simd_ctor<float>(long(3));

libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp

 auto supported_native_simd_ctor(Args&&... args)
     -> decltype(ex::native_simd<T>(std::forward<Args>(args)...), void()) {}
 
 template <class T>
 void supported_native_simd_ctor(...) = delete;
 
 void compile_load_ctor() {
   supported_native_simd_ctor<int>((int*)nullptr, ex::element_aligned_tag());
-  supported_native_simd_ctor<uint32_t>((int*)nullptr,
+  supported_native_simd_ctor<std::uint32_t>((int*)nullptr,
                                        ex::element_aligned_tag());
   supported_native_simd_ctor<double>((float*)nullptr,
                                      ex::element_aligned_tag());
   supported_native_simd_ctor<uint16_t>((unsigned int*)nullptr,
                                        ex::element_aligned_tag());
-  supported_native_simd_ctor<uint32_t>((float*)nullptr,
+  supported_native_simd_ctor<std::uint32_t>((float*)nullptr,
                                        ex::element_aligned_tag());
 
   not_supported_native_simd_ctor<int>((int*)nullptr, int());
 }
 
 template <typename SimdType>
 void test_load_ctor() {
   alignas(32) int32_t buffer[] = {4, 3, 2, 1};

libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp

auto supported_load(Args&&... args) -> decltype(
     std::declval<ex::native_simd<T>>().copy_from(std::forward<Args>(args)...),
     void()) {}
 
 template <class T>
 void supported_load(...) = delete;
 
 void compile_load() {
   supported_load<int>((int*)nullptr, ex::element_aligned_tag());
-  supported_load<uint32_t>((int*)nullptr, ex::element_aligned_tag());
+  supported_load<std::uint32_t>((int*)nullptr, ex::element_aligned_tag());
   supported_load<double>((float*)nullptr, ex::element_aligned_tag());
   supported_load<uint16_t>((unsigned int*)nullptr, ex::element_aligned_tag());
-  supported_load<uint32_t>((float*)nullptr, ex::element_aligned_tag());
+  supported_load<std::uint32_t>((float*)nullptr, ex::element_aligned_tag());
 
   not_supported_load<int>((int*)nullptr, int());
 }
 
 template <typename SimdType>
 void test_load() {
   alignas(32) int32_t buffer[] = {4, 3, 2, 1};
   {

libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp

 struct UserType {};
 
 static_assert(ex::is_abi_tag<ex::simd_abi::native<int8_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::native<int16_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::native<int32_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::native<int64_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::native<uint8_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::native<uint16_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::native<uint32_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::native<std::uint32_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::native<uint64_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::native<float>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::native<double>>::value, "");
 
 static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int8_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int16_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int32_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::compatible<int64_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint8_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint16_t>>::value, "");
-static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint32_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::uint32_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::compatible<uint64_t>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::compatible<float>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::compatible<double>>::value, "");
 
 static_assert(ex::is_abi_tag<ex::simd_abi::scalar>::value, "");
 static_assert(
     !std::is_same<ex::simd_abi::scalar, ex::simd_abi::fixed_size<1>>::value,
     "");

 static_assert(!ex::is_abi_tag<ex::simd_mask<float>>::value, "");
 
 static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int8_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int16_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int32_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::native<int64_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint8_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint16_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint32_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::uint32_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::native<uint64_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::native<float>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::native<double>>, "");
 
 static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int8_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int16_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int32_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<int64_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint8_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint16_t>>, "");
-static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint32_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::uint32_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<uint64_t>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<float>>, "");
 static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<double>>, "");
 
 static_assert(ex::is_abi_tag_v<ex::simd_abi::scalar>, "");
 static_assert(
     !std::is_same<ex::simd_abi::scalar, ex::simd_abi::fixed_size<1>>::value,
     "");

libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp

 struct UserType {};
 
 static_assert(ex::is_simd<ex::native_simd<int8_t>>::value, "");
 static_assert(ex::is_simd<ex::native_simd<int16_t>>::value, "");
 static_assert(ex::is_simd<ex::native_simd<int32_t>>::value, "");
 static_assert(ex::is_simd<ex::native_simd<int64_t>>::value, "");
 static_assert(ex::is_simd<ex::native_simd<uint8_t>>::value, "");
 static_assert(ex::is_simd<ex::native_simd<uint16_t>>::value, "");
-static_assert(ex::is_simd<ex::native_simd<uint32_t>>::value, "");
+static_assert(ex::is_simd<ex::native_simd<std::uint32_t>>::value, "");
 static_assert(ex::is_simd<ex::native_simd<uint64_t>>::value, "");
 static_assert(ex::is_simd<ex::native_simd<float>>::value, "");
 static_assert(ex::is_simd<ex::native_simd<double>>::value, "");
 
 static_assert(ex::is_simd<ex::fixed_size_simd<int8_t, 1>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<int16_t, 1>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<int32_t, 1>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<int64_t, 1>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<uint8_t, 1>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<uint16_t, 1>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint32_t, 1>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint32_t, 1>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<uint64_t, 1>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<float, 1>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<double, 1>>::value, "");
 
 static_assert(ex::is_simd<ex::fixed_size_simd<int8_t, 3>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<int16_t, 3>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<int32_t, 3>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<int64_t, 3>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<uint8_t, 3>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<uint16_t, 3>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint32_t, 3>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint32_t, 3>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<uint64_t, 3>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<float, 3>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<double, 3>>::value, "");
 
 static_assert(ex::is_simd<ex::fixed_size_simd<int8_t, 32>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<int16_t, 32>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<int32_t, 32>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<int64_t, 32>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<uint8_t, 32>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<uint16_t, 32>>::value, "");
-static_assert(ex::is_simd<ex::fixed_size_simd<uint32_t, 32>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint32_t, 32>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<uint64_t, 32>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<float, 32>>::value, "");
 static_assert(ex::is_simd<ex::fixed_size_simd<double, 32>>::value, "");
 
 static_assert(!ex::is_simd<void>::value, "");
 static_assert(!ex::is_simd<int>::value, "");
 static_assert(!ex::is_simd<float>::value, "");
 static_assert(!ex::is_simd<ex::simd_mask<int>>::value, "");
 static_assert(!ex::is_simd<ex::simd_mask<float>>::value, "");
 static_assert(!ex::is_simd<UserType>::value, "");
 
 static_assert(ex::is_simd_v<ex::native_simd<int8_t>>, "");
 static_assert(ex::is_simd_v<ex::native_simd<int16_t>>, "");
 static_assert(ex::is_simd_v<ex::native_simd<int32_t>>, "");
 static_assert(ex::is_simd_v<ex::native_simd<int64_t>>, "");
 static_assert(ex::is_simd_v<ex::native_simd<uint8_t>>, "");
 static_assert(ex::is_simd_v<ex::native_simd<uint16_t>>, "");
-static_assert(ex::is_simd_v<ex::native_simd<uint32_t>>, "");
+static_assert(ex::is_simd_v<ex::native_simd<std::uint32_t>>, "");
 static_assert(ex::is_simd_v<ex::native_simd<uint64_t>>, "");
 static_assert(ex::is_simd_v<ex::native_simd<float>>, "");
 static_assert(ex::is_simd_v<ex::native_simd<double>>, "");
 
 static_assert(ex::is_simd_v<ex::fixed_size_simd<int8_t, 1>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<int16_t, 1>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<int32_t, 1>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<int64_t, 1>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<uint8_t, 1>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<uint16_t, 1>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint32_t, 1>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint32_t, 1>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<uint64_t, 1>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<float, 1>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 1>>, "");
 
 static_assert(ex::is_simd_v<ex::fixed_size_simd<int8_t, 3>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<int16_t, 3>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<int32_t, 3>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<int64_t, 3>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<uint8_t, 3>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<uint16_t, 3>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint32_t, 3>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint32_t, 3>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<uint64_t, 3>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<float, 3>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 3>>, "");
 
 static_assert(ex::is_simd_v<ex::fixed_size_simd<int8_t, 32>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<int16_t, 32>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<int32_t, 32>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<int64_t, 32>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<uint8_t, 32>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<uint16_t, 32>>, "");
-static_assert(ex::is_simd_v<ex::fixed_size_simd<uint32_t, 32>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint32_t, 32>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<uint64_t, 32>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<float, 32>>, "");
 static_assert(ex::is_simd_v<ex::fixed_size_simd<double, 32>>, "");
 
 static_assert(!ex::is_simd_v<void>, "");
 static_assert(!ex::is_simd_v<int>, "");
 static_assert(!ex::is_simd_v<float>, "");
 static_assert(!ex::is_simd_v<ex::simd_mask<int>>, "");
 static_assert(!ex::is_simd_v<ex::simd_mask<float>>, "");
 static_assert(!ex::is_simd_v<UserType>, "");
 
 int main(int, char**) {
   return 0;
 }

libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp

 struct UserType {};
 
 static_assert(ex::is_simd_mask<ex::native_simd_mask<int8_t>>::value, "");
 static_assert(ex::is_simd_mask<ex::native_simd_mask<int16_t>>::value, "");
 static_assert(ex::is_simd_mask<ex::native_simd_mask<int32_t>>::value, "");
 static_assert(ex::is_simd_mask<ex::native_simd_mask<int64_t>>::value, "");
 static_assert(ex::is_simd_mask<ex::native_simd_mask<uint8_t>>::value, "");
 static_assert(ex::is_simd_mask<ex::native_simd_mask<uint16_t>>::value, "");
-static_assert(ex::is_simd_mask<ex::native_simd_mask<uint32_t>>::value, "");
+static_assert(ex::is_simd_mask<ex::native_simd_mask<std::uint32_t>>::value, "");
 static_assert(ex::is_simd_mask<ex::native_simd_mask<uint64_t>>::value, "");
 static_assert(ex::is_simd_mask<ex::native_simd_mask<float>>::value, "");
 static_assert(ex::is_simd_mask<ex::native_simd_mask<double>>::value, "");
 
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int8_t, 1>>::value, "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int16_t, 1>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int32_t, 1>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int64_t, 1>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint8_t, 1>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint16_t, 1>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint32_t, 1>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint32_t, 1>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint64_t, 1>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<float, 1>>::value, "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<double, 1>>::value, "");
 
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int8_t, 3>>::value, "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int16_t, 3>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int32_t, 3>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int64_t, 3>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint8_t, 3>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint16_t, 3>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint32_t, 3>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint32_t, 3>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint64_t, 3>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<float, 3>>::value, "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<double, 3>>::value, "");
 
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int8_t, 32>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int16_t, 32>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int32_t, 32>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<int64_t, 32>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint8_t, 32>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint16_t, 32>>::value,
               "");
-static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint32_t, 32>>::value,
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::uint32_t, 32>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<uint64_t, 32>>::value,
               "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<float, 32>>::value, "");
 static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<double, 32>>::value,
               "");
 
 static_assert(!ex::is_simd_mask<void>::value, "");
 static_assert(!ex::is_simd_mask<int>::value, "");
 static_assert(!ex::is_simd_mask<float>::value, "");
 static_assert(!ex::is_simd_mask<ex::simd<int>>::value, "");
 static_assert(!ex::is_simd_mask<ex::simd<float>>::value, "");
 static_assert(!ex::is_simd_mask<UserType>::value, "");
 
 static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int8_t>>, "");
 static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int16_t>>, "");
 static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int32_t>>, "");
 static_assert(ex::is_simd_mask_v<ex::native_simd_mask<int64_t>>, "");
 static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint8_t>>, "");
 static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint16_t>>, "");
-static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint32_t>>, "");
+static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::uint32_t>>, "");
 static_assert(ex::is_simd_mask_v<ex::native_simd_mask<uint64_t>>, "");
 static_assert(ex::is_simd_mask_v<ex::native_simd_mask<float>>, "");
 static_assert(ex::is_simd_mask_v<ex::native_simd_mask<double>>, "");
 
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int8_t, 1>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int16_t, 1>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int32_t, 1>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int64_t, 1>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint8_t, 1>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint16_t, 1>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint32_t, 1>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint32_t, 1>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint64_t, 1>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<float, 1>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 1>>, "");
 
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int8_t, 3>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int16_t, 3>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int32_t, 3>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int64_t, 3>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint8_t, 3>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint16_t, 3>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint32_t, 3>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint32_t, 3>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint64_t, 3>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<float, 3>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 3>>, "");
 
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int8_t, 32>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int16_t, 32>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int32_t, 32>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<int64_t, 32>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint8_t, 32>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint16_t, 32>>, "");
-static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint32_t, 32>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint32_t, 32>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<uint64_t, 32>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<float, 32>>, "");
 static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<double, 32>>, "");
 
 static_assert(!ex::is_simd_mask_v<void>, "");
 static_assert(!ex::is_simd_mask_v<int>, "");
 static_assert(!ex::is_simd_mask_v<float>, "");
 static_assert(!ex::is_simd_mask_v<ex::simd<int>>, "");
 static_assert(!ex::is_simd_mask_v<ex::simd<float>>, "");
 static_assert(!ex::is_simd_mask_v<UserType>, "");
 
 int main(int, char**) {
   return 0;
 }

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp

 // <ostream>
 
 // template <class charT, class traits = char_traits<charT> >
 //   class basic_ostream;
 
 // operator<<( int16_t val);
 // operator<<(uint16_t val);
 // operator<<( int32_t val);
 // operator<<(uint32_t val);
 // operator<<( int64_t val);
 // operator<<(uint64_t val);
 
 //  Testing to make sure that the max length values are correctly inserted
 
 #include <sstream>
 #include <ios>
 #include <type_traits>
void test_hex(const char *expected)
     assert(str == expected);
 }
 
 int main(int, char**)
 {
 
     test_octal<uint16_t>(                "177777");
     test_octal< int16_t>(                "177777");
-    test_octal<uint32_t>(           "37777777777");
+    test_octal<std::uint32_t>(           "37777777777");
     test_octal< int32_t>(           "37777777777");
     test_octal<uint64_t>("1777777777777777777777");
     test_octal< int64_t>("1777777777777777777777");
     test_octal<uint64_t>("1777777777777777777777");
 
     const bool long_is_64 = std::integral_constant<bool, sizeof(long) == sizeof(int64_t)>::value; // avoid compiler warnings
     const bool long_long_is_64 = std::integral_constant<bool, sizeof(long long) == sizeof(int64_t)>::value; // avoid compiler warnings
 
     if (long_is_64) {
         test_octal< unsigned long>("1777777777777777777777");
         test_octal<          long>("1777777777777777777777");
     }
     if (long_long_is_64) {
         test_octal< unsigned long long>("1777777777777777777777");
         test_octal<          long long>("1777777777777777777777");
     }
 
     test_dec<uint16_t>(               "65535");
     test_dec< int16_t>(                  "-1");
-    test_dec<uint32_t>(          "4294967295");
+    test_dec<std::uint32_t>(          "4294967295");
     test_dec< int32_t>(                  "-1");
     test_dec<uint64_t>("18446744073709551615");
     test_dec< int64_t>(                  "-1");
     if (long_is_64) {
         test_dec<unsigned long>("18446744073709551615");
         test_dec<         long>(                  "-1");
     }
     if (long_long_is_64) {
         test_dec<unsigned long long>("18446744073709551615");
         test_dec<         long long>(                  "-1");
     }
 
     test_hex<uint16_t>(            "FFFF");
     test_hex< int16_t>(            "FFFF");
-    test_hex<uint32_t>(        "FFFFFFFF");
+    test_hex<std::uint32_t>(        "FFFFFFFF");
     test_hex< int32_t>(        "FFFFFFFF");
     test_hex<uint64_t>("FFFFFFFFFFFFFFFF");
     test_hex< int64_t>("FFFFFFFFFFFFFFFF");
     if (long_is_64) {
         test_hex<unsigned long>("FFFFFFFFFFFFFFFF");
         test_hex<         long>("FFFFFFFFFFFFFFFF");
     }
     if (long_long_is_64) {
         test_hex<unsigned long long>("FFFFFFFFFFFFFFFF");
         test_hex<         long long>("FFFFFFFFFFFFFFFF");
     }
 
   return 0;
 }

libcxx/test/std/numerics/bit/bit.endian/endian.pass.cpp

// test that the enumeration values exist
     static_assert( std::endian::little != std::endian::big );
 
 //  Technically not required, but true on all existing machines
     static_assert( std::endian::native == std::endian::little ||
                    std::endian::native == std::endian::big );
 
 //  Try to check at runtime
     {
-    uint32_t i = 0x01020304;
+    std::uint32_t i = 0x01020304;
     char c[4];
     static_assert(sizeof(i) == sizeof(c));
     std::memcpy(c, &i, sizeof(c));
 
     assert ((c[0] == 1) == (std::endian::native == std::endian::big));
     }
 
   return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp

int main(int, char**)
     static_assert(toobig<unsigned char>(),      ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<unsigned short>(),     ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<unsigned>(),           ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<unsigned long>(),      ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<unsigned long long>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
 
     static_assert(toobig<uint8_t>(), "");   // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<uint16_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
-    static_assert(toobig<uint32_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<std::uint32_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<uint64_t>(), "");  // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<size_t>(), "");    // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<uintmax_t>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
     static_assert(toobig<uintptr_t>(), ""); // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp

#endif
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp

#endif
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
 
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
 
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp

#endif
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp

#endif
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp

#endif
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp

#endif
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp

#endif
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp

#endif
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp

#endif
     static_assert(test<unsigned int>());
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp

#endif
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
 
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
 
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp

#endif
     static_assert(test<unsigned long>());
     static_assert(test<unsigned long long>());
 #ifndef TEST_HAS_NO_INT128
     static_assert(test<__uint128_t>());
 #endif
 
     static_assert(test<uint8_t>());
     static_assert(test<uint16_t>());
-    static_assert(test<uint32_t>());
+    static_assert(test<std::uint32_t>());
     static_assert(test<uint64_t>());
     static_assert(test<uintmax_t>());
     static_assert(test<uintptr_t>());
     static_assert(test<size_t>());
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 #ifndef TEST_HAS_NO_INT128
     test<__uint128_t>();
 #endif
 
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

libcxx/test/std/numerics/bit/byteswap.pass.cpp

 constexpr void test_implementation_defined_size() {
   const auto [in, expected] = get_test_data<T>();
   test_num<T>(in, expected);
 }
 
 constexpr bool test() {
   test_num<uint8_t>(0xAB, 0xAB);
   test_num<uint16_t>(0xCDEF, 0xEFCD);
-  test_num<uint32_t>(0x01234567, 0x67452301);
+  test_num<std::uint32_t>(0x01234567, 0x67452301);
   test_num<uint64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
 
   test_num<int8_t>(static_cast<int8_t>(0xAB), static_cast<int8_t>(0xAB));
   test_num<int16_t>(static_cast<int16_t>(0xCDEF), static_cast<int16_t>(0xEFCD));
   test_num<int32_t>(0x01234567, 0x67452301);
   test_num<int64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
 
 #ifndef TEST_HAS_NO_INT128

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp

 // _Tp midpoint(_Tp __a, _Tp __b) noexcept
 //
 
 #include <stdint.h>
 #include <limits>
 #include <numeric>
 #include <cassert>
 #include <cstddef>
+#include <cstdint>
 #include "test_macros.h"
 
 template <typename T>
 void signed_test()
 {
     constexpr T zero{0};
     constexpr T one{1};
     constexpr T two{2};
int main(int, char**)
     unsigned_test<unsigned char>();
     unsigned_test<unsigned short>();
     unsigned_test<unsigned int>();
     unsigned_test<unsigned long>();
     unsigned_test<unsigned long long>();
 
     unsigned_test<uint8_t>();
     unsigned_test<uint16_t>();
-    unsigned_test<uint32_t>();
+    unsigned_test<std::uint32_t>();
     unsigned_test<uint64_t>();
 
 #ifndef TEST_HAS_NO_INT128
     unsigned_test<__uint128_t>();
     signed_test<__int128_t>();
 #endif
 
 //     int_test<char>();
     signed_test<ptrdiff_t>();
     unsigned_test<size_t>();
 
     return 0;
 }

libcxx/test/std/utilities/charconv/charconv.msvc/floating_point_test_cases.hpp

constexpr std::pair<const char*, uint64_t> floating_point_test_cases_double[] = {
     {"9.9538452227e-280", 0x0602117AE45CDE43ULL},
     {"6.47660115e-260", 0x0A1FDD9E333BADADULL},
     {"7.4e+47", 0x49E033D7ECA0ADEFULL},
     {"5.92e+48", 0x4A1033D7ECA0ADEFULL},
     {"7.35e+66", 0x4DD172B70EABABA9ULL},
     {"8.32116e+55", 0x4B8B2628393E02CDULL},
 };
 
-constexpr std::pair<const char*, uint32_t> floating_point_test_cases_float[] = {
+constexpr std::pair<const char*, std::uint32_t> floating_point_test_cases_float[] = {
     // Verify small exactly-representable integers:
     {"1", 0x3F800000U},
     {"2", 0x40000000U},
     {"3", 0x40400000U},
     {"4", 0x40800000U},
     {"5", 0x40A00000U},
     {"6", 0x40C00000U},
     {"7", 0x40E00000U},

libcxx/test/std/utilities/charconv/charconv.msvc/test.cpp

 using namespace std;
 
 void initialize_randomness(mt19937_64& mt64, const int argc, char** const /*argv*/) {
     constexpr size_t n = mt19937_64::state_size;
     constexpr size_t w = mt19937_64::word_size;
     static_assert(w % 32 == 0);
     constexpr size_t k = w / 32;
 
-    vector<uint32_t> vec(n * k);
+    vector<std::uint32_t> vec(n * k);
 
     puts("USAGE:");
     puts("test.exe              : generates seed data from random_device.");
 
     if (argc == 1) {
         random_device rd;
         generate(vec.begin(), vec.end(), ref(rd));
         puts("Generated seed data.");
void test_from_chars(const string_view input, const BaseOrFmt base_or_fmt, const size_t correct_idx,
     const from_chars_result result = from_chars(input.data(), input.data() + input.size(), dest, base_or_fmt);
 
     assert(result.ptr == input.data() + correct_idx);
     assert(result.ec == correct_ec);
 
     if (correct_ec == errc{} || (is_floating_point_v<T> && correct_ec == errc::result_out_of_range)) {
         if constexpr (is_floating_point_v<T>) {
             if (mode == TestFromCharsMode::Normal) {
-                using Uint = conditional_t<is_same_v<T, float>, uint32_t, uint64_t>;
+                using Uint = conditional_t<is_same_v<T, float>, std::uint32_t, uint64_t>;
                 assert(opt_correct.has_value());
                 assert(_Bit_cast<Uint>(dest) == _Bit_cast<Uint>(opt_correct.value()));
             } else {
                 assert(mode == TestFromCharsMode::SignalingNaN);
                 assert(!opt_correct.has_value());
                 assert(isnan(dest));
             }
         } else {
void all_integer_tests() {
 
     test_from_chars<int>("-2147483639", 10, 11, errc{}, -2147483639); // not risky
     test_from_chars<int>("-2147483647", 10, 11, errc{}, -2147483647); // risky with good digit
     test_from_chars<int>("-2147483648", 10, 11, errc{}, -2147483647 - 1); // risky with max digit
     test_from_chars<int>("-2147483649", 10, 11, out_ran); // risky with bad digit
     test_from_chars<int>("-2147483650", 10, 11, out_ran); // beyond risky
 }
 
-void assert_message_bits(const bool b, const char* const msg, const uint32_t bits) {
+void assert_message_bits(const bool b, const char* const msg, const std::uint32_t bits) {
     if (!b) {
         fprintf(stderr, "%s failed for 0x%08zX\n", msg, static_cast<size_t>(bits));
         fprintf(stderr, "This is a randomized test.\n");
         fprintf(stderr, "DO NOT IGNORE/RERUN THIS FAILURE.\n");
         fprintf(stderr, "You must report it to the STL maintainers.\n");
         abort();
     }
 }
 
 void assert_message_bits(const bool b, const char* const msg, const uint64_t bits) {
     if (!b) {
         // libc++ uses long for 64-bit values.
         fprintf(stderr, "%s failed for 0x%016llX\n", msg, static_cast<unsigned long long>(bits));
         fprintf(stderr, "This is a randomized test.\n");
         fprintf(stderr, "DO NOT IGNORE/RERUN THIS FAILURE.\n");
         fprintf(stderr, "You must report it to the STL maintainers.\n");
         abort();
     }
 }
 
-constexpr uint32_t FractionBits = 10; // Tunable for test coverage vs. performance.
+constexpr std::uint32_t FractionBits = 10; // Tunable for test coverage vs. performance.
 static_assert(FractionBits >= 1, "Must test at least 1 fraction bit.");
 static_assert(FractionBits <= 23, "There are only 23 fraction bits in a float.");
 
-constexpr uint32_t Fractions = 1U << FractionBits;
-constexpr uint32_t Mask32    = ~((1U << FractionBits) - 1U);
+constexpr std::uint32_t Fractions = 1U << FractionBits;
+constexpr std::uint32_t Mask32    = ~((1U << FractionBits) - 1U);
 constexpr uint64_t Mask64    = ~((1ULL << FractionBits) - 1ULL);
 
-constexpr uint32_t PrefixesToTest = 100; // Tunable for test coverage vs. performance.
+constexpr std::uint32_t PrefixesToTest = 100; // Tunable for test coverage vs. performance.
 static_assert(PrefixesToTest >= 1, "Must test at least 1 prefix.");
 
-constexpr uint32_t PrefixLimit = 2 // sign bit
+constexpr std::uint32_t PrefixLimit = 2 // sign bit
                                * 255 // non-INF/NAN exponents for float
                                * (1U << (23 - FractionBits)); // fraction bits in prefix
 static_assert(PrefixesToTest <= PrefixLimit, "Too many prefixes.");
 
 template <bool IsDouble>
-void test_floating_prefix(const conditional_t<IsDouble, uint64_t, uint32_t> prefix) {
+void test_floating_prefix(const conditional_t<IsDouble, uint64_t, std::uint32_t> prefix) {
 
-    using UIntType     = conditional_t<IsDouble, uint64_t, uint32_t>;
+    using UIntType     = conditional_t<IsDouble, uint64_t, std::uint32_t>;
     using FloatingType = conditional_t<IsDouble, double, float>;
 
     // "-1.2345678901234567e-100" or "-1.23456789e-10"
     constexpr size_t buffer_size = IsDouble ? 24 : 15;
     char buffer[buffer_size];
 // TODO Enable once std::from_chars has floating point support.
 #if 0
     FloatingType val;
 #endif
 
     // Exact sizes are difficult to prove for fixed notation.
     // This must be at least (IsDouble ? 327 : 48), and I suspect that that's exact.
     // Here's a loose upper bound:
     // 1 character for a negative sign
     // + 325 (for double; 46 for float) characters in the "0.000~~~000" prefix of the min subnormal
     // + 17 (for double; 9 for float) characters for round-trip digits
     constexpr size_t fixed_buffer_size = IsDouble ? 1 + 325 + 17 : 1 + 46 + 9;
     char fixed_buffer[fixed_buffer_size];
 
     // worst case: negative sign + max normal + null terminator
     constexpr size_t stdio_buffer_size = 1 + (IsDouble ? 309 : 39) + 1;
     char stdio_buffer[stdio_buffer_size];
 
-    for (uint32_t frac = 0; frac < Fractions; ++frac) {
+    for (std::uint32_t frac = 0; frac < Fractions; ++frac) {
         const UIntType bits      = prefix + frac;
         const FloatingType input = _Bit_cast<FloatingType>(bits);
 
         {
             const auto to_result = to_chars(buffer, end(buffer), input, chars_format::scientific);
             assert_message_bits(to_result.ec == errc{}, "to_result.ec", bits);
 // TODO Enable once std::from_chars has floating point support.
 #if 0
#endif
                 const string_view stdio_sv(stdio_buffer);
                 assert_message_bits(fixed_sv == stdio_sv, "fixed_sv", bits);
             }
         }
     }
 }
 
 template <bool IsDouble>
-void test_floating_hex_prefix(const conditional_t<IsDouble, uint64_t, uint32_t> prefix) {
+void test_floating_hex_prefix(const conditional_t<IsDouble, uint64_t, std::uint32_t> prefix) {
 
-    using UIntType     = conditional_t<IsDouble, uint64_t, uint32_t>;
+    using UIntType     = conditional_t<IsDouble, uint64_t, std::uint32_t>;
     using FloatingType = conditional_t<IsDouble, double, float>;
 
     // The precision is the number of hexits after the decimal point.
     // These hexits correspond to the explicitly stored fraction bits.
     // double explicitly stores 52 fraction bits. 52 / 4 == 13, so we need 13 hexits.
     // float explicitly stores 23 fraction bits. 23 / 4 == 5.75, so we need 6 hexits.
 
     // "-1.fffffffffffffp+1023" or "-1.fffffep+127"
     constexpr size_t buffer_size = IsDouble ? 22 : 14;
     char buffer[buffer_size];
 // TODO Enable once std::from_chars has floating point support.
 #if 0
     FloatingType val;
 #endif
 
-    for (uint32_t frac = 0; frac < Fractions; ++frac) {
+    for (std::uint32_t frac = 0; frac < Fractions; ++frac) {
         const UIntType bits      = prefix + frac;
         const FloatingType input = _Bit_cast<FloatingType>(bits);
 
         const auto to_result = to_chars(buffer, end(buffer), input, chars_format::hex);
         assert_message_bits(to_result.ec == errc{}, "(hex) to_result.ec", bits);
 // TODO Enable once std::from_chars has floating point support.
 #if 0
         const char* const last = to_result.ptr;
 
         const auto from_result = from_chars(buffer, last, val, chars_format::hex);
 
         assert_message_bits(from_result.ptr == last, "(hex) from_result.ptr", bits);
         assert_message_bits(from_result.ec == errc{}, "(hex) from_result.ec", bits);
         assert_message_bits(_Bit_cast<UIntType>(val) == bits, "(hex) round-trip", bits);
 #endif
     }
 }
 
 template <bool IsDouble>
-void test_floating_precision_prefix(const conditional_t<IsDouble, uint64_t, uint32_t> prefix) {
+void test_floating_precision_prefix(const conditional_t<IsDouble, uint64_t, std::uint32_t> prefix) {
 
-    using UIntType     = conditional_t<IsDouble, uint64_t, uint32_t>;
+    using UIntType     = conditional_t<IsDouble, uint64_t, std::uint32_t>;
     using FloatingType = conditional_t<IsDouble, double, float>;
 
     // Precision for min subnormal in fixed notation. (More than enough for scientific notation.)
     constexpr int precision = IsDouble ? 1074 : 149;
 
     // Number of digits for max normal in fixed notation.
     constexpr int max_integer_length = IsDouble ? 309 : 39;
 
     // Size for fixed notation. (More than enough for scientific notation.)
     constexpr size_t charconv_buffer_size = 1 // negative sign
                                           + max_integer_length // integer digits
                                           + 1 // decimal point
                                           + precision; // fractional digits
     char charconv_buffer[charconv_buffer_size];
 
     constexpr size_t stdio_buffer_size = charconv_buffer_size + 1; // null terminator
     char stdio_buffer[stdio_buffer_size];
 
     // 1 character for a negative sign
     // + worst cases: 0x1.fffffffffffffp-1022 and 0x1.fffffep-126f
     constexpr size_t general_buffer_size = 1 + (IsDouble ? 773 : 117);
     char general_buffer[general_buffer_size];
     char general_stdio_buffer[general_buffer_size + 1]; // + null terminator
 
-    for (uint32_t frac = 0; frac < Fractions; ++frac) {
+    for (std::uint32_t frac = 0; frac < Fractions; ++frac) {
         const UIntType bits      = prefix + frac;
         const FloatingType input = _Bit_cast<FloatingType>(bits);
 
         auto result = to_chars(charconv_buffer, end(charconv_buffer), input, chars_format::fixed, precision);
         assert_message_bits(result.ec == errc{}, "to_chars fixed precision", bits);
         string_view charconv_sv(charconv_buffer, static_cast<size_t>(result.ptr - charconv_buffer));
 
         int stdio_ret = sprintf_s(stdio_buffer, size(stdio_buffer), "%.*f", precision, input);
void test_floating_prefixes(mt19937_64& mt64) {
             test_floating_prefix<true>(prefix);
             test_floating_precision_prefix<true>(prefix);
         }
 
         test_floating_hex_prefix<true>(*prefixes64.begin()); // save time by testing fewer hexfloats
     }
 
     {
-        set<uint32_t> prefixes32;
+        set<std::uint32_t> prefixes32;
 
         while (prefixes32.size() < PrefixesToTest) {
-            const uint32_t val = static_cast<uint32_t>(mt64());
+            const std::uint32_t val = static_cast<std::uint32_t>(mt64());
 
             if ((val & 0x7F800000U) != 0x7F800000U) { // skip INF/NAN
                 prefixes32.insert(val & Mask32);
             }
         }
 
         for (const auto& prefix : prefixes32) {
             test_floating_prefix<false>(prefix);

libcxx/test/std/utilities/format/format.functions/escaped_output.ascii.pass.cpp

if constexpr (sizeof(CharT) > 1) {
     test_format(V{L"'\xfe20'"}, L"{:?}", L'\xfe20'); // VARIATION SELECTOR-1
   }
 #  ifndef TEST_SHORT_WCHAR
   if constexpr (sizeof(CharT) > 2) {
     static_assert(sizeof(CharT) == 4, "add support for unexpected size");
     // Unicode fitting in a 32-bit wchar_t
 
     constexpr wchar_t x  = 0x1ffff;
-    constexpr uint32_t y = 0x1ffff;
+    constexpr std::uint32_t y = 0x1ffff;
     static_assert(x == y);
 
     using V = std::basic_string_view<CharT>;
 
     // *** Non-printable ***
     // Format
     test_format(V{L"'\x110bd'"}, L"{:?}", L'\x110bd'); // KAITHI NUMBER SIGN
     test_format(V{L"'\xe007f'"}, L"{:?}", L'\xe007f'); // CANCEL TAG

libcxx/test/std/utilities/format/format.functions/escaped_output.unicode.pass.cpp

if constexpr (sizeof(CharT) > 1) {
     test_format(V{L"'\\u{fe20}'"}, L"{:?}", L'\xfe20'); // VARIATION SELECTOR-1
   }
 #  ifndef TEST_SHORT_WCHAR
   if constexpr (sizeof(CharT) > 2) {
     static_assert(sizeof(CharT) == 4, "add support for unexpected size");
     // Unicode fitting in a 32-bit wchar_t
 
     constexpr wchar_t x  = 0x1ffff;
-    constexpr uint32_t y = 0x1ffff;
+    constexpr std::uint32_t y = 0x1ffff;
     static_assert(x == y);
 
     using V = std::basic_string_view<CharT>;
 
     // *** Non-printable ***
     // Format
     test_format(V{L"'\\u{110bd}'"}, L"{:?}", L'\x110bd'); // KAITHI NUMBER SIGN
     test_format(V{L"'\\u{e007f}'"}, L"{:?}", L'\xe007f'); // CANCEL TAG
if constexpr (sizeof(CharT) > 1) {
     test_format(V{LR"("\u{300}\u{fe20}")"}, L"{:?}", L"\x300\xfe20");
   }
 #  ifndef TEST_SHORT_WCHAR
   if constexpr (sizeof(CharT) > 2) {
     static_assert(sizeof(CharT) == 4, "add support for unexpected size");
     // Unicode fitting in a 32-bit wchar_t
 
     constexpr wchar_t x  = 0x1ffff;
-    constexpr uint32_t y = 0x1ffff;
+    constexpr std::uint32_t y = 0x1ffff;
     static_assert(x == y);
 
     using V = std::basic_string_view<CharT>;
 
     // *** Non-printable ***
     // Format
     test_format(V{LR"("\u{110bd}\u{e007f}")"}, L"{:?}", L"\x110bd\xe007f");
 

libcxx/test/std/utilities/format/format.functions/format_tests.h

#endif
   check(SV("255"), SV("{:#}"), std::numeric_limits<uint8_t>::max());
   check(SV("0xff"), SV("{:#x}"), std::numeric_limits<uint8_t>::max());
 
   check(SV("0b1111111111111111"), SV("{:#b}"), std::numeric_limits<uint16_t>::max());
   check(SV("0177777"), SV("{:#o}"), std::numeric_limits<uint16_t>::max());
   check(SV("65535"), SV("{:#}"), std::numeric_limits<uint16_t>::max());
   check(SV("0xffff"), SV("{:#x}"), std::numeric_limits<uint16_t>::max());
 
-  check(SV("0b11111111111111111111111111111111"), SV("{:#b}"), std::numeric_limits<uint32_t>::max());
-  check(SV("037777777777"), SV("{:#o}"), std::numeric_limits<uint32_t>::max());
-  check(SV("4294967295"), SV("{:#}"), std::numeric_limits<uint32_t>::max());
-  check(SV("0xffffffff"), SV("{:#x}"), std::numeric_limits<uint32_t>::max());
+  check(SV("0b11111111111111111111111111111111"), SV("{:#b}"), std::numeric_limits<std::uint32_t>::max());
+  check(SV("037777777777"), SV("{:#o}"), std::numeric_limits<std::uint32_t>::max());
+  check(SV("4294967295"), SV("{:#}"), std::numeric_limits<std::uint32_t>::max());
+  check(SV("0xffffffff"), SV("{:#x}"), std::numeric_limits<std::uint32_t>::max());
 
   check(SV("0b1111111111111111111111111111111111111111111111111111111111111111"),
         SV("{:#b}"),
         std::numeric_limits<uint64_t>::max());
   check(SV("01777777777777777777777"), SV("{:#o}"), std::numeric_limits<uint64_t>::max());
   check(SV("18446744073709551615"), SV("{:#}"), std::numeric_limits<uint64_t>::max());
   check(SV("0xffffffffffffffff"), SV("{:#x}"), std::numeric_limits<uint64_t>::max());
 

libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp

//  LWG #2119
     test<int_least32_t>();
     test<int_least64_t>();
 
     test<intmax_t>();
     test<intptr_t>();
 
     test<uint8_t>();
     test<uint16_t>();
-    test<uint32_t>();
+    test<std::uint32_t>();
     test<uint64_t>();
 
     test<uint_fast8_t>();
     test<uint_fast16_t>();
     test<uint_fast32_t>();
     test<uint_fast64_t>();
 
     test<uint_least8_t>();

libcxx/test/support/atomic_helpers.h

 #endif
     TestFunctor<char16_t>()();
     TestFunctor<char32_t>()();
     TestFunctor<int8_t>()();
     TestFunctor<uint8_t>()();
     TestFunctor<int16_t>()();
     TestFunctor<uint16_t>()();
     TestFunctor<int32_t>()();
-    TestFunctor<uint32_t>()();
+    TestFunctor<std::uint32_t>()();
     TestFunctor<int64_t>()();
     TestFunctor<uint64_t>()();
   }
 };
 
 template <template <class TestArg> class TestFunctor>
 struct TestEachFloatingPointType {
   void operator()() const {