[libc++] Qualifies uint32_t and friends.

[Mordante]

Summary

This has been done using the following command

find libcxx/test -type f -exec perl -pi -e 's|^([^/]+?)((?<!::)(?<!::u)u?int(_[a-z]+)?[0-9]{1,2}_t)|\1std::\2|' \{} \;

And manually removed some false positives in std/depr/depr.c.headers.

[Mordante]

CI fixes.

libcxx/test/libcxx/containers/unord/next_pow2.pass.cpp

 }
 
 // Note: this is only really useful when run with -fsanitize=undefined.
 void
 fuzz_unordered_map_reserve(unsigned num_inserts,
                            unsigned num_reserve1,
                            unsigned num_reserve2)
 {
-    std::unordered_map<uint64_t, unsigned long> m;
+    std::unordered_map<std::uint64_t, unsigned long> m;
     m.reserve(num_reserve1);
     for (unsigned I = 0; I < num_inserts; ++I) m[I] = 0;
     m.reserve(num_reserve2);
     assert(m.bucket_count() >= num_reserve2);
 }
 
 int main(int, char**)
 {

libcxx/test/libcxx/fuzzing/random.pass.cpp

 }
 
 template <class Dist>
 struct ParamTypeHelper {
   using ParamT = typename Dist::param_type;
   using ResultT = typename Dist::result_type;
   static_assert(std::is_same<ResultT, typename ParamT::distribution_type::result_type>::value, "");
 
-  static ParamT Create(const uint8_t* data, std::size_t size, bool &OK) {
+  static ParamT Create(const std::uint8_t* data, std::size_t size, bool &OK) {
     constexpr bool select_vector_result = std::is_constructible<ParamT, ResultT*, ResultT*, ResultT*>::value;
     constexpr bool select_vector_double = std::is_constructible<ParamT, double*, double*>::value;
     constexpr int selector = select_vector_result ? 0 : (select_vector_double ? 1 : 2);
     return DispatchAndCreate(std::integral_constant<int, selector>{}, data, size, OK);
   }
 
   // Vector result
   static ParamT DispatchAndCreate(std::integral_constant<int, 0>, const std::uint8_t *data, std::size_t size, bool &OK) {

libcxx/test/libcxx/input.output/filesystems/convert_file_time.pass.cpp

 };
 
 template <class IntType, class Period = std::micro>
 using TestFileTimeT = time_point<TestClock<duration<IntType, Period> > >;
 
 int main(int, char**) {
   { assert((test_case<file_time_type, time_t, struct timespec>::test())); }
   {
-    assert((test_case<TestFileTimeT<int64_t>, int64_t,
-                      TestTimeSpec<int64_t, long> >::test()));
+    assert((test_case<TestFileTimeT<std::int64_t>, std::int64_t,
+                      TestTimeSpec<std::int64_t, long> >::test()));
   }
   {
-    assert((test_case<TestFileTimeT<long long>, int32_t,
-                      TestTimeSpec<int32_t, int32_t> >::test()));
+    assert((test_case<TestFileTimeT<long long>, std::int32_t,
+                      TestTimeSpec<std::int32_t, std::int32_t> >::test()));
   }
   {
     // Test that insane platforms like ppc64 linux, which use long double as time_t,
     // at least compile.
     assert((test_case<TestFileTimeT<long double>, double,
                       TestTimeSpec<long double, long> >::test()));
   }
 #ifndef TEST_HAS_NO_INT128_T
   {
-    assert((test_case<TestFileTimeT<__int128_t, std::nano>, int64_t,
-                      TestTimeSpec<int64_t, long> >::test()));
+    assert((test_case<TestFileTimeT<__int128_t, std::nano>, std::int64_t,
+                      TestTimeSpec<std::int64_t, long> >::test()));
   }
   {
-    assert((test_case<TestFileTimeT<__int128_t, std::nano>, int32_t,
-                      TestTimeSpec<int32_t, int32_t> >::test()));
+    assert((test_case<TestFileTimeT<__int128_t, std::nano>, std::int32_t,
+                      TestTimeSpec<std::int32_t, std::int32_t> >::test()));
   }
 #endif
 
   return 0;
 }

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

 int main(int, char**)
 {
     test<signed char>();
     test<short>();
     test<int>();
     test<long>();
     test<long long>();
 
-    test<int8_t>();
-    test<int16_t>();
-    test<int32_t>();
-    test<int64_t>();
+    test<std::int8_t>();
+    test<std::int16_t>();
+    test<std::int32_t>();
+    test<std::int64_t>();
 
     test<unsigned char>();
     test<unsigned short>();
     test<unsigned int>();
     test<unsigned long>();
     test<unsigned long long>();
 
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::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/strings/basic.string/alignof.compile.pass.cpp

 #include <string>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 
 template <class T>
 class small_pointer {
-  uint16_t offset;
+  std::uint16_t offset;
 };
 
 template <class T>
 class small_iter_allocator {
 public:
   using value_type = T;
   using pointer = small_pointer<T>;
-  using size_type = int16_t;
-  using difference_type = int16_t;
+  using size_type = std::int16_t;
+  using difference_type = std::int16_t;
 
   small_iter_allocator() TEST_NOEXCEPT {}
 
   template <class U>
   small_iter_allocator(small_iter_allocator<U>) TEST_NOEXCEPT {}
 
   T* allocate(std::size_t n);
   void deallocate(T* p, std::size_t);

libcxx/test/libcxx/strings/basic.string/sizeof.compile.pass.cpp

 #include <string>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 
 template <class T>
 class small_pointer {
-  uint16_t offset;
+  std::uint16_t offset;
 };
 
 template <class T>
 class small_iter_allocator {
 public:
   using value_type = T;
   using pointer = small_pointer<T>;
-  using size_type = int16_t;
-  using difference_type = int16_t;
+  using size_type = std::int16_t;
+  using difference_type = std::int16_t;
 
   small_iter_allocator() TEST_NOEXCEPT {}
 
   template <class U>
   small_iter_allocator(small_iter_allocator<U>) TEST_NOEXCEPT {}
 
   T* allocate(std::size_t n);
   void deallocate(T* p, std::size_t);

libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp

 
 #include <string>
 #include <cassert>
 
 #include "check_assertion.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
-  using T = decltype(uint8_t() - uint8_t());
+  using T = decltype(std::uint8_t() - std::uint8_t());
   {
     typedef std::string C;
     C c(1, '\0');
     C::iterator i = c.begin();
     assert(i[0] == 0);
     TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
   }
 

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

 }
 
 constexpr void test() {
   // Arithmetic types.
   {
     // Bit-castable arithmetic types.
 
     // 8-bit types.
-    using integral_8 = types::type_list<char8_t, int8_t, uint8_t>;
+    using integral_8 = types::type_list<char8_t, std::int8_t, std::uint8_t>;
     using chars = types::type_list<char, unsigned char, signed char>;
 #if CHAR_BIT == 8
     check<true, types::concatenate_t<integral_8, chars>>();
 #else
     check<true, integral_8>();
     check<true, chars>();
 #endif
 
     // 16-bit types.
-    using integral_16 = types::type_list<char16_t, int16_t, uint16_t>;
+    using integral_16 = types::type_list<char16_t, std::int16_t, std::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, std::uint32_t>;
+    using integral_32 = types::type_list<char32_t, std::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>;
+    using integral_64 = types::type_list<std::int64_t, std::uint64_t>;
     check<true, integral_64>();
 
     // 128-bit types.
 #ifndef TEST_HAS_NO_INT128
     check<true, types::type_list<__int128_t, __uint128_t>>();
 #endif
 
     // Bool.

libcxx/test/libcxx/utilities/format/format.arguments/format.arg/arg_t.compile.pass.cpp

 // namespace __format { enum class __arg_t : uint8_t{...}; }
 
 #include <format>
 
 #include <type_traits>
 
 #include "test_macros.h"
 
-static_assert(std::is_same_v<std::underlying_type_t<std::__format::__arg_t>, uint8_t>);
+static_assert(std::is_same_v<std::underlying_type_t<std::__format::__arg_t>, std::uint8_t>);
 
-static_assert(uint8_t(std::__format::__arg_t::__none) == 0);
-static_assert(uint8_t(std::__format::__arg_t::__boolean) == 1);
-static_assert(uint8_t(std::__format::__arg_t::__char_type) == 2);
-static_assert(uint8_t(std::__format::__arg_t::__int) == 3);
-static_assert(uint8_t(std::__format::__arg_t::__long_long) == 4);
-static_assert(uint8_t(std::__format::__arg_t::__i128) == 5);
-static_assert(uint8_t(std::__format::__arg_t::__unsigned) == 6);
-static_assert(uint8_t(std::__format::__arg_t::__unsigned_long_long) == 7);
-static_assert(uint8_t(std::__format::__arg_t::__u128) == 8);
-static_assert(uint8_t(std::__format::__arg_t::__float) == 9);
-static_assert(uint8_t(std::__format::__arg_t::__double) == 10);
-static_assert(uint8_t(std::__format::__arg_t::__long_double) == 11);
-static_assert(uint8_t(std::__format::__arg_t::__const_char_type_ptr) == 12);
-static_assert(uint8_t(std::__format::__arg_t::__string_view) == 13);
-static_assert(uint8_t(std::__format::__arg_t::__ptr) == 14);
-static_assert(uint8_t(std::__format::__arg_t::__handle) == 15);
+static_assert(std::uint8_t(std::__format::__arg_t::__none) == 0);
+static_assert(std::uint8_t(std::__format::__arg_t::__boolean) == 1);
+static_assert(std::uint8_t(std::__format::__arg_t::__char_type) == 2);
+static_assert(std::uint8_t(std::__format::__arg_t::__int) == 3);
+static_assert(std::uint8_t(std::__format::__arg_t::__long_long) == 4);
+static_assert(std::uint8_t(std::__format::__arg_t::__i128) == 5);
+static_assert(std::uint8_t(std::__format::__arg_t::__unsigned) == 6);
+static_assert(std::uint8_t(std::__format::__arg_t::__unsigned_long_long) == 7);
+static_assert(std::uint8_t(std::__format::__arg_t::__u128) == 8);
+static_assert(std::uint8_t(std::__format::__arg_t::__float) == 9);
+static_assert(std::uint8_t(std::__format::__arg_t::__double) == 10);
+static_assert(std::uint8_t(std::__format::__arg_t::__long_double) == 11);
+static_assert(std::uint8_t(std::__format::__arg_t::__const_char_type_ptr) == 12);
+static_assert(std::uint8_t(std::__format::__arg_t::__string_view) == 13);
+static_assert(std::uint8_t(std::__format::__arg_t::__ptr) == 14);
+static_assert(std::uint8_t(std::__format::__arg_t::__handle) == 15);

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

 #include <functional>
 #include <limits>
 #include <string>
 #include <utility>
 
 #include "test_macros.h"
 
 typedef std::__murmur2_or_cityhash<std::uint32_t> Hash32;
-typedef std::__murmur2_or_cityhash<uint64_t> Hash64;
+typedef std::__murmur2_or_cityhash<std::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/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v1.pass.cpp

 std::string CityHash[] = {
     {/* "abcdefgh" */ "\x61\x62\x63\x64\x65\x66\x67\x68"},
     {/* "abcDefgh" */ "\x61\x62\x63\x44\x65\x66\x67\x68"},
     {/* "CityHash" */ "\x43\x69\x74\x79\x48\x61\x73\x68"},
     {/* "CitYHash" */ "\x43\x69\x74\x59\x48\x61\x73\x68"},
 };
 
 int main(int, char**) {
-  const std::pair<std::string, uint64_t> TestCases[] = {
+  const std::pair<std::string, std::uint64_t> TestCases[] = {
       {CityHash[0], CHOOSE_BY_ENDIANESS(0x87c69099911bab7eULL, 0x297621d7fa436a3ULL)},
       {CityHash[1], CHOOSE_BY_ENDIANESS(0x87c69099911bab7eULL, 0xb17be531dde56e57ULL)},
       {CityHash[2], CHOOSE_BY_ENDIANESS(0x85322632e188694aULL, 0xe14f578b688e266dULL)},
       {CityHash[3], CHOOSE_BY_ENDIANESS(0x85322632e188694aULL, 0xca5a764a0450eac6ULL)},
   };
 
-  std::__murmur2_or_cityhash<uint64_t> h64;
+  std::__murmur2_or_cityhash<std::uint64_t> h64;
   for (const auto& test_case : TestCases) {
     assert(h64(test_case.first.data(), test_case.first.size()) == test_case.second);
   }
 
   return 0;
 }

libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v2.pass.cpp

 std::string CityHash[] = {
     {/* "abcdefgh" */ "\x61\x62\x63\x64\x65\x66\x67\x68"},
     {/* "abcDefgh" */ "\x61\x62\x63\x44\x65\x66\x67\x68"},
     {/* "CityHash" */ "\x43\x69\x74\x79\x48\x61\x73\x68"},
     {/* "CitYHash" */ "\x43\x69\x74\x59\x48\x61\x73\x68"},
 };
 
 int main(int, char**) {
-  const std::pair<std::string, uint64_t> TestCases[] = {
+  const std::pair<std::string, std::uint64_t> TestCases[] = {
       {CityHash[0], CHOOSE_BY_ENDIANESS(0x4382a8d0fe8edb17ULL, 0xca84e809bef16fbcULL)},
       {CityHash[1], CHOOSE_BY_ENDIANESS(0xecefb080a6854061ULL, 0xd7feb824250272dcULL)},
       {CityHash[2], CHOOSE_BY_ENDIANESS(0x169ea3aebf908d6dULL, 0xea8cef3ca6f6e368ULL)},
       {CityHash[3], CHOOSE_BY_ENDIANESS(0xe18298a2760f09faULL, 0xf33a7700bb7a94a8ULL)},
   };
 
-  std::__murmur2_or_cityhash<uint64_t> h64;
+  std::__murmur2_or_cityhash<std::uint64_t> h64;
   for (const auto& test_case : TestCases) {
     assert(h64(test_case.first.data(), test_case.first.size()) == test_case.second);
   }
   return 0;
 }

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

 #include <atomic>
 #include <type_traits>
 #include <cstdint>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    static_assert((std::is_same<std::atomic<  std::int_least8_t>,   std::atomic_int_least8_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::uint_least8_t>,  std::atomic_uint_least8_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::int_least16_t>,  std::atomic_int_least16_t>::value), "");
-    static_assert((std::is_same<std::atomic<std::uint_least16_t>, std::atomic_uint_least16_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::int_least32_t>,  std::atomic_int_least32_t>::value), "");
-    static_assert((std::is_same<std::atomic<std::uint_least32_t>, std::atomic_uint_least32_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::int_least64_t>,  std::atomic_int_least64_t>::value), "");
-    static_assert((std::is_same<std::atomic<std::uint_least64_t>, std::atomic_uint_least64_t>::value), "");
-
-    static_assert((std::is_same<std::atomic<  std::int_fast8_t>,   std::atomic_int_fast8_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::uint_fast8_t>,  std::atomic_uint_fast8_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::int_fast16_t>,  std::atomic_int_fast16_t>::value), "");
-    static_assert((std::is_same<std::atomic<std::uint_fast16_t>, std::atomic_uint_fast16_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::int_fast32_t>,  std::atomic_int_fast32_t>::value), "");
-    static_assert((std::is_same<std::atomic<std::uint_fast32_t>, std::atomic_uint_fast32_t>::value), "");
-    static_assert((std::is_same<std::atomic< std::int_fast64_t>,  std::atomic_int_fast64_t>::value), "");
-    static_assert((std::is_same<std::atomic<std::uint_fast64_t>, std::atomic_uint_fast64_t>::value), "");
+    static_assert((std::is_same<std::atomic<  std::int_least8_t>,   std::atomic_std::int_least8_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::uint_least8_t>,  std::atomic_std::uint_least8_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::int_least16_t>,  std::atomic_std::int_least16_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint_least16_t>, std::atomic_std::uint_least16_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::int_least32_t>,  std::atomic_std::int_least32_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint_least32_t>, std::atomic_std::uint_least32_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::int_least64_t>,  std::atomic_std::int_least64_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint_least64_t>, std::atomic_std::uint_least64_t>::value), "");
+
+    static_assert((std::is_same<std::atomic<  std::int_fast8_t>,   std::atomic_std::int_fast8_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::uint_fast8_t>,  std::atomic_std::uint_fast8_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::int_fast16_t>,  std::atomic_std::int_fast16_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint_fast16_t>, std::atomic_std::uint_fast16_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::int_fast32_t>,  std::atomic_std::int_fast32_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint_fast32_t>, std::atomic_std::uint_fast32_t>::value), "");
+    static_assert((std::is_same<std::atomic< std::int_fast64_t>,  std::atomic_std::int_fast64_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint_fast64_t>, std::atomic_std::uint_fast64_t>::value), "");
 
     static_assert((std::is_same<std::atomic< std::intptr_t>,  std::atomic_intptr_t>::value), "");
     static_assert((std::is_same<std::atomic<std::uintptr_t>, std::atomic_uintptr_t>::value), "");
     static_assert((std::is_same<std::atomic<   std::size_t>,    std::atomic_size_t>::value), "");
     static_assert((std::is_same<std::atomic<std::ptrdiff_t>, std::atomic_ptrdiff_t>::value), "");
     static_assert((std::is_same<std::atomic< std::intmax_t>,  std::atomic_intmax_t>::value), "");
     static_assert((std::is_same<std::atomic<std::uintmax_t>, std::atomic_uintmax_t>::value), "");
 
   return 0;
 }

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

#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<std::atomic_char8_t, char8_t>();
 #endif
     test<std::atomic_char16_t, char16_t>();
     test<std::atomic_char32_t, char32_t>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<std::atomic_wchar_t, wchar_t>();
 #endif
 
-    test<std::atomic_int8_t,    int8_t>();
-    test<std::atomic_uint8_t,  uint8_t>();
-    test<std::atomic_int16_t,   int16_t>();
-    test<std::atomic_uint16_t, uint16_t>();
-    test<std::atomic_int32_t,   int32_t>();
-    test<std::atomic_uint32_t, uint32_t>();
-    test<std::atomic_int64_t,   int64_t>();
-    test<std::atomic_uint64_t, uint64_t>();
+    test<std::atomic_std::int8_t,    std::int8_t>();
+    test<std::atomic_std::uint8_t,  std::uint8_t>();
+    test<std::atomic_std::int16_t,   std::int16_t>();
+    test<std::atomic_std::uint16_t, std::uint16_t>();
+    test<std::atomic_std::int32_t,   std::int32_t>();
+    test<std::atomic_std::uint32_t, std::uint32_t>();
+    test<std::atomic_std::int64_t,   std::int64_t>();
+    test<std::atomic_std::uint64_t, std::uint64_t>();
 
     test<volatile std::atomic_char, char>();
     test<volatile std::atomic_schar, signed char>();
     test<volatile std::atomic_uchar, unsigned char>();
     test<volatile std::atomic_short, short>();
     test<volatile std::atomic_ushort, unsigned short>();
     test<volatile std::atomic_int, int>();
     test<volatile std::atomic_uint, unsigned int>();
     test<volatile std::atomic_long, long>();
     test<volatile std::atomic_ulong, unsigned long>();
     test<volatile std::atomic_llong, long long>();
     test<volatile std::atomic_ullong, unsigned long long>();
     test<volatile std::atomic_char16_t, char16_t>();
     test<volatile std::atomic_char32_t, char32_t>();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<volatile std::atomic_wchar_t, wchar_t>();
 #endif
 
-    test<volatile std::atomic_int8_t,    int8_t>();
-    test<volatile std::atomic_uint8_t,  uint8_t>();
-    test<volatile std::atomic_int16_t,   int16_t>();
-    test<volatile std::atomic_uint16_t, uint16_t>();
-    test<volatile std::atomic_int32_t,   int32_t>();
-    test<volatile std::atomic_uint32_t, uint32_t>();
-    test<volatile std::atomic_int64_t,   int64_t>();
-    test<volatile std::atomic_uint64_t, uint64_t>();
+    test<volatile std::atomic_std::int8_t,    std::int8_t>();
+    test<volatile std::atomic_std::uint8_t,  std::uint8_t>();
+    test<volatile std::atomic_std::int16_t,   std::int16_t>();
+    test<volatile std::atomic_std::uint16_t, std::uint16_t>();
+    test<volatile std::atomic_std::int32_t,   std::int32_t>();
+    test<volatile std::atomic_std::uint32_t, std::uint32_t>();
+    test<volatile std::atomic_std::int64_t,   std::int64_t>();
+    test<volatile std::atomic_std::uint64_t, std::uint64_t>();
 
   return 0;
 }

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

 #endif
     static_assert((std::is_same<std::atomic<char16_t>, std::atomic_char16_t>::value), "");
     static_assert((std::is_same<std::atomic<char32_t>, std::atomic_char32_t>::value), "");
 
 //  Added by LWG 2441
     static_assert((std::is_same<std::atomic<intptr_t>,  std::atomic_intptr_t>::value), "");
     static_assert((std::is_same<std::atomic<uintptr_t>, std::atomic_uintptr_t>::value), "");
 
-    static_assert((std::is_same<std::atomic<int8_t>,    std::atomic_int8_t>::value), "");
-    static_assert((std::is_same<std::atomic<uint8_t>,   std::atomic_uint8_t>::value), "");
-    static_assert((std::is_same<std::atomic<int16_t>,   std::atomic_int16_t>::value), "");
-    static_assert((std::is_same<std::atomic<uint16_t>,  std::atomic_uint16_t>::value), "");
-    static_assert((std::is_same<std::atomic<int32_t>,   std::atomic_int32_t>::value), "");
-    static_assert((std::is_same<std::atomic<uint32_t>,  std::atomic_uint32_t>::value), "");
-    static_assert((std::is_same<std::atomic<int64_t>,   std::atomic_int64_t>::value), "");
-    static_assert((std::is_same<std::atomic<uint64_t>,  std::atomic_uint64_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::int8_t>,    std::atomic_std::int8_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint8_t>,   std::atomic_std::uint8_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::int16_t>,   std::atomic_std::int16_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint16_t>,  std::atomic_std::uint16_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::int32_t>,   std::atomic_std::int32_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint32_t>,  std::atomic_std::uint32_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::int64_t>,   std::atomic_std::int64_t>::value), "");
+    static_assert((std::is_same<std::atomic<std::uint64_t>,  std::atomic_std::uint64_t>::value), "");
 
   return 0;
 }

libcxx/test/std/atomics/stdatomic.h.syn/types.compile.pass.cpp

#ifndef _LIBCPP_HAS_NO_CHAR8_T
   static_assert(std::is_same_v<std::atomic<char8_t>,  ::atomic_char8_t>);
 #endif
   static_assert(std::is_same_v<std::atomic<char16_t>, ::atomic_char16_t>);
   static_assert(std::is_same_v<std::atomic<char32_t>, ::atomic_char32_t>);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   static_assert(std::is_same_v<std::atomic<wchar_t>,  ::atomic_wchar_t>);
 #endif
 
-  static_assert(std::is_same_v<std::atomic<int8_t>,   ::atomic_int8_t>);
-  static_assert(std::is_same_v<std::atomic<uint8_t>,  ::atomic_uint8_t>);
-  static_assert(std::is_same_v<std::atomic<int16_t>,  ::atomic_int16_t>);
-  static_assert(std::is_same_v<std::atomic<uint16_t>, ::atomic_uint16_t>);
-  static_assert(std::is_same_v<std::atomic<int32_t>,  ::atomic_int32_t>);
-  static_assert(std::is_same_v<std::atomic<uint32_t>, ::atomic_uint32_t>);
-  static_assert(std::is_same_v<std::atomic<int64_t>,  ::atomic_int64_t>);
-  static_assert(std::is_same_v<std::atomic<uint64_t>, ::atomic_uint64_t>);
-
-  static_assert(std::is_same_v<std::atomic<int_least8_t>,   ::atomic_int_least8_t>);
-  static_assert(std::is_same_v<std::atomic<uint_least8_t>,  ::atomic_uint_least8_t>);
-  static_assert(std::is_same_v<std::atomic<int_least16_t>,  ::atomic_int_least16_t>);
-  static_assert(std::is_same_v<std::atomic<uint_least16_t>, ::atomic_uint_least16_t>);
-  static_assert(std::is_same_v<std::atomic<int_least32_t>,  ::atomic_int_least32_t>);
-  static_assert(std::is_same_v<std::atomic<uint_least32_t>, ::atomic_uint_least32_t>);
-  static_assert(std::is_same_v<std::atomic<int_least64_t>,  ::atomic_int_least64_t>);
-  static_assert(std::is_same_v<std::atomic<uint_least64_t>, ::atomic_uint_least64_t>);
-
-  static_assert(std::is_same_v<std::atomic<int_fast8_t>,    ::atomic_int_fast8_t>);
-  static_assert(std::is_same_v<std::atomic<uint_fast8_t>,   ::atomic_uint_fast8_t>);
-  static_assert(std::is_same_v<std::atomic<int_fast16_t>,   ::atomic_int_fast16_t>);
-  static_assert(std::is_same_v<std::atomic<uint_fast16_t>,  ::atomic_uint_fast16_t>);
-  static_assert(std::is_same_v<std::atomic<int_fast32_t>,   ::atomic_int_fast32_t>);
-  static_assert(std::is_same_v<std::atomic<uint_fast32_t>,  ::atomic_uint_fast32_t>);
-  static_assert(std::is_same_v<std::atomic<int_fast64_t>,   ::atomic_int_fast64_t>);
-  static_assert(std::is_same_v<std::atomic<uint_fast64_t>,  ::atomic_uint_fast64_t>);
+  static_assert(std::is_same_v<std::atomic<std::int8_t>,   ::atomic_std::int8_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint8_t>,  ::atomic_std::uint8_t>);
+  static_assert(std::is_same_v<std::atomic<std::int16_t>,  ::atomic_std::int16_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint16_t>, ::atomic_std::uint16_t>);
+  static_assert(std::is_same_v<std::atomic<std::int32_t>,  ::atomic_std::int32_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint32_t>, ::atomic_std::uint32_t>);
+  static_assert(std::is_same_v<std::atomic<std::int64_t>,  ::atomic_std::int64_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint64_t>, ::atomic_std::uint64_t>);
+
+  static_assert(std::is_same_v<std::atomic<std::int_least8_t>,   ::atomic_std::int_least8_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_least8_t>,  ::atomic_std::uint_least8_t>);
+  static_assert(std::is_same_v<std::atomic<std::int_least16_t>,  ::atomic_std::int_least16_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_least16_t>, ::atomic_std::uint_least16_t>);
+  static_assert(std::is_same_v<std::atomic<std::int_least32_t>,  ::atomic_std::int_least32_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_least32_t>, ::atomic_std::uint_least32_t>);
+  static_assert(std::is_same_v<std::atomic<std::int_least64_t>,  ::atomic_std::int_least64_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_least64_t>, ::atomic_std::uint_least64_t>);
+
+  static_assert(std::is_same_v<std::atomic<std::int_fast8_t>,    ::atomic_std::int_fast8_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_fast8_t>,   ::atomic_std::uint_fast8_t>);
+  static_assert(std::is_same_v<std::atomic<std::int_fast16_t>,   ::atomic_std::int_fast16_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_fast16_t>,  ::atomic_std::uint_fast16_t>);
+  static_assert(std::is_same_v<std::atomic<std::int_fast32_t>,   ::atomic_std::int_fast32_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_fast32_t>,  ::atomic_std::uint_fast32_t>);
+  static_assert(std::is_same_v<std::atomic<std::int_fast64_t>,   ::atomic_std::int_fast64_t>);
+  static_assert(std::is_same_v<std::atomic<std::uint_fast64_t>,  ::atomic_std::uint_fast64_t>);
 
   static_assert(std::is_same_v<std::atomic<intptr_t>,  ::atomic_intptr_t>);
   static_assert(std::is_same_v<std::atomic<uintptr_t>, ::atomic_uintptr_t>);
   static_assert(std::is_same_v<std::atomic<size_t>,    ::atomic_size_t>);
   static_assert(std::is_same_v<std::atomic<ptrdiff_t>, ::atomic_ptrdiff_t>);
   static_assert(std::is_same_v<std::atomic<intmax_t>,  ::atomic_intmax_t>);
   static_assert(std::is_same_v<std::atomic<uintmax_t>, ::atomic_uintmax_t>);
 

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

#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     test<char8_t>            ();
 #endif
     test<char16_t>           ();
     test<char32_t>           ();
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
     test<wchar_t>            ();
 #endif
 
-    test<int_least8_t>   ();
-    test<uint_least8_t>  ();
-    test<int_least16_t>  ();
-    test<uint_least16_t> ();
-    test<int_least32_t>  ();
-    test<uint_least32_t> ();
-    test<int_least64_t>  ();
-    test<uint_least64_t> ();
-
-    test<int_fast8_t>   ();
-    test<uint_fast8_t>  ();
-    test<int_fast16_t>  ();
-    test<uint_fast16_t> ();
-    test<int_fast32_t>  ();
-    test<uint_fast32_t> ();
-    test<int_fast64_t>  ();
-    test<uint_fast64_t> ();
-
-    test< int8_t>  ();
-    test<uint8_t>  ();
-    test< int16_t> ();
-    test<uint16_t> ();
-    test< int32_t> ();
+    test<std::int_least8_t>   ();
+    test<std::uint_least8_t>  ();
+    test<std::int_least16_t>  ();
+    test<std::uint_least16_t> ();
+    test<std::int_least32_t>  ();
+    test<std::uint_least32_t> ();
+    test<std::int_least64_t>  ();
+    test<std::uint_least64_t> ();
+
+    test<std::int_fast8_t>   ();
+    test<std::uint_fast8_t>  ();
+    test<std::int_fast16_t>  ();
+    test<std::uint_fast16_t> ();
+    test<std::int_fast32_t>  ();
+    test<std::uint_fast32_t> ();
+    test<std::int_fast64_t>  ();
+    test<std::uint_fast64_t> ();
+
+    test< std::int8_t>  ();
+    test<std::uint8_t>  ();
+    test< std::int16_t> ();
+    test<std::uint16_t> ();
+    test< std::int32_t> ();
     test<std::uint32_t> ();
-    test< int64_t> ();
-    test<uint64_t> ();
+    test< std::int64_t> ();
+    test<std::uint64_t> ();
 
     test<intptr_t>  ();
     test<uintptr_t> ();
     test<size_t>    ();
     test<ptrdiff_t> ();
     test<intmax_t>  ();
     test<uintmax_t> ();
 

libcxx/test/std/containers/sequences/deque/abi.compile.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
 //
 //===----------------------------------------------------------------------===//
 
 #include <deque>
 
 #include "min_allocator.h"
 #include "test_allocator.h"
 #include "test_macros.h"
 
 template <class T>
 class small_pointer {
-  uint16_t offset;
+  std::uint16_t offset;
 };
 
 template <class T>
 class small_iter_allocator {
 public:
   using value_type      = T;
   using pointer         = small_pointer<T>;
-  using size_type       = int16_t;
-  using difference_type = int16_t;
+  using size_type       = std::int16_t;
+  using difference_type = std::int16_t;
 
   small_iter_allocator() TEST_NOEXCEPT {}
 
   template <class U>
   small_iter_allocator(small_iter_allocator<U>) TEST_NOEXCEPT {}
 
   T* allocate(std::size_t n);
   void deallocate(T* p, std::size_t);

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

TEST_CONSTEXPR_CXX20 void test_ctor_with_different_value_type() {
     Der *array[1] = { &z };
     // 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::int32_t array[1] = { -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

libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp

static_assert(
     "");
 static_assert(
     sizeof(ex::simd<char, ex::__simd_abi<ex::_StorageKind::_VecExt, 3>>) == 4,
     "");
 static_assert(
     sizeof(ex::simd<char, ex::__simd_abi<ex::_StorageKind::_VecExt, 12>>) == 16,
     "");
 static_assert(
-    sizeof(ex::simd<int32_t, ex::__simd_abi<ex::_StorageKind::_VecExt, 3>>) ==
+    sizeof(ex::simd<std::int32_t, ex::__simd_abi<ex::_StorageKind::_VecExt, 3>>) ==
         16,
     "");
 static_assert(
-    sizeof(ex::simd<int32_t, ex::__simd_abi<ex::_StorageKind::_VecExt, 5>>) ==
+    sizeof(ex::simd<std::int32_t, ex::__simd_abi<ex::_StorageKind::_VecExt, 5>>) ==
         32,
     "");
 static_assert(
-    std::is_same<ex::simd_abi::native<int8_t>,
+    std::is_same<ex::simd_abi::native<std::int8_t>,
                  ex::__simd_abi<ex::_StorageKind::_VecExt, reg_width()>>::value,
     "");
 #else
 static_assert(
-    std::is_same<ex::simd_abi::native<int8_t>,
+    std::is_same<ex::simd_abi::native<std::int8_t>,
                  ex::__simd_abi<ex::_StorageKind::_Array, reg_width()>>::value,
     "");
 
 #endif
 
-static_assert(std::is_same<ex::simd_abi::compatible<int8_t>,
+static_assert(std::is_same<ex::simd_abi::compatible<std::int8_t>,
                            ex::__simd_abi<ex::_StorageKind::_Array, 16>>::value,
               "");
 
 int main(int, char**) {
   return 0;
 }

libcxx/test/std/experimental/simd/simd.access/default.pass.cpp

 #include "test_macros.h"
 
 namespace ex = std::experimental::parallelism_v2;
 
 template <typename SimdType>
 void test_access() {
   {
     SimdType a(42), b(4);
-    static_assert(std::is_convertible<decltype(a[0]), int8_t>::value, "");
+    static_assert(std::is_convertible<decltype(a[0]), std::int8_t>::value, "");
 
     assert(a[0] == 42);
     assert(!a[0] == !42);
     assert(~a[0] == ~42);
     assert(+a[0] == +42);
     assert(-a[0] == -42);
     assert(a[0] + b[0] == 42 + 4);
     assert(a[0] - b[0] == 42 - 4);

libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp

 #include <experimental/simd>
 #include <cstdint>
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::parallelism_v2;
 
 static_assert(
-    std::is_same<decltype(ex::simd_cast<int32_t>(ex::native_simd<int32_t>())),
-                 ex::native_simd<int32_t>>::value,
+    std::is_same<decltype(ex::simd_cast<std::int32_t>(ex::native_simd<std::int32_t>())),
+                 ex::native_simd<std::int32_t>>::value,
     "");
 
-static_assert(std::is_same<decltype(ex::simd_cast<int64_t>(
-                               ex::fixed_size_simd<int32_t, 4>())),
-                           ex::fixed_size_simd<int64_t, 4>>::value,
+static_assert(std::is_same<decltype(ex::simd_cast<std::int64_t>(
+                               ex::fixed_size_simd<std::int32_t, 4>())),
+                           ex::fixed_size_simd<std::int64_t, 4>>::value,
               "");
 
 static_assert(
-    std::is_same<decltype(ex::simd_cast<ex::fixed_size_simd<int64_t, 1>>(
-                     ex::simd<int32_t, ex::simd_abi::scalar>())),
-                 ex::fixed_size_simd<int64_t, 1>>::value,
+    std::is_same<decltype(ex::simd_cast<ex::fixed_size_simd<std::int64_t, 1>>(
+                     ex::simd<std::int32_t, ex::simd_abi::scalar>())),
+                 ex::fixed_size_simd<std::int64_t, 1>>::value,
     "");
 
 static_assert(
     std::is_same<
-        decltype(ex::simd_cast<ex::simd<int64_t, ex::simd_abi::scalar>>(
-            ex::fixed_size_simd<int32_t, 1>())),
-        ex::simd<int64_t, ex::simd_abi::scalar>>::value,
+        decltype(ex::simd_cast<ex::simd<std::int64_t, ex::simd_abi::scalar>>(
+            ex::fixed_size_simd<std::int32_t, 1>())),
+        ex::simd<std::int64_t, ex::simd_abi::scalar>>::value,
     "");
 
 int main(int, char**) {
   return 0;
 }

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

 template <class T, class... Args>
 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_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<std::int8_t>(3);
+  supported_native_simd_ctor<std::int16_t>(3);
+  supported_native_simd_ctor<std::int32_t>(3);
+  supported_native_simd_ctor<std::int64_t>(3);
+  supported_native_simd_ctor<std::uint8_t>(3);
+  supported_native_simd_ctor<std::uint16_t>(3);
   supported_native_simd_ctor<std::uint32_t>(3);
-  supported_native_simd_ctor<uint64_t>(3);
+  supported_native_simd_ctor<std::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<std::int8_t>(long(3));
   not_supported_native_simd_ctor<float>(long(3));
   not_supported_native_simd_ctor<int>(3.);
 }
 
 void compile_convertible() {
   struct ConvertibleToInt {
-    operator int64_t() const;
+    operator std::int64_t() const;
   };
-  supported_native_simd_ctor<int64_t>(ConvertibleToInt());
+  supported_native_simd_ctor<std::int64_t>(ConvertibleToInt());
 
   struct NotConvertibleToInt {};
-  not_supported_native_simd_ctor<int64_t>(NotConvertibleToInt());
+  not_supported_native_simd_ctor<std::int64_t>(NotConvertibleToInt());
 }
 
 void compile_unsigned() {
   not_supported_native_simd_ctor<int>(3u);
-  supported_native_simd_ctor<uint16_t>(3u);
+  supported_native_simd_ctor<std::uint16_t>(3u);
 }
 
 template <typename SimdType>
 void test_broadcast() {
   SimdType a(3);
   for (size_t i = 0; i < a.size(); i++) {
     assert(a[i] == 3);
   }

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

 #include <cstdint>
 #include <experimental/simd>
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::parallelism_v2;
 
 int main(int, char**) {
-  static_assert(ex::native_simd<int32_t>().size() > 0, "");
-  static_assert(ex::fixed_size_simd<int32_t, 4>().size() == 4, "");
-  static_assert(ex::fixed_size_simd<int32_t, 5>().size() == 5, "");
-  static_assert(ex::fixed_size_simd<int32_t, 1>().size() == 1, "");
+  static_assert(ex::native_simd<std::int32_t>().size() > 0, "");
+  static_assert(ex::fixed_size_simd<std::int32_t, 4>().size() == 4, "");
+  static_assert(ex::fixed_size_simd<std::int32_t, 5>().size() == 5, "");
+  static_assert(ex::fixed_size_simd<std::int32_t, 1>().size() == 1, "");
   static_assert(ex::fixed_size_simd<char, 32>().size() == 32, "");
 
   return 0;
 }

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

void compile_generator() {
   supported_simd128_ctor<int>(identity());
   not_supported_simd128_ctor<int>([](int i) { return float(i); });
   not_supported_simd128_ctor<int>([](intptr_t i) { return (int*)(i); });
   not_supported_simd128_ctor<int>([](int* i) { return i; });
 }
 
 struct limited_identity {
   template <size_t value>
-  typename std::conditional<value <= 2, int32_t, int64_t>::type
+  typename std::conditional<value <= 2, std::int32_t, std::int64_t>::type
   operator()(std::integral_constant<size_t, value>) const {
     return value;
   }
 };
 
 void compile_limited_identity() {
-  supported_simd128_ctor<int64_t>(limited_identity());
-  not_supported_simd128_ctor<int32_t>(limited_identity());
+  supported_simd128_ctor<std::int64_t>(limited_identity());
+  not_supported_simd128_ctor<std::int32_t>(limited_identity());
 }
 
 template <typename SimdType>
 void test_generator() {
   {
     SimdType a([](int i) { return i; });
     assert(a[0] == 0);
     assert(a[1] == 1);
     assert(a[2] == 2);
     assert(a[3] == 3);
   }
   {
     SimdType a([](int i) { return 2 * i - 1; });
     assert(a[0] == -1);
     assert(a[1] == 1);
     assert(a[2] == 3);
     assert(a[3] == 5);
   }
 }
 
 int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
-  assert(ex::native_simd<int32_t>::size() >= 4);
-  test_generator<ex::native_simd<int32_t>>();
-  test_generator<ex::fixed_size_simd<int32_t, 4>>();
+  assert(ex::native_simd<std::int32_t>::size() >= 4);
+  test_generator<ex::native_simd<std::int32_t>>();
+  test_generator<ex::fixed_size_simd<std::int32_t, 4>>();
 
   return 0;
 }

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

 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<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,
+  supported_native_simd_ctor<std::uint16_t>((unsigned int*)nullptr,
                                        ex::element_aligned_tag());
   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};
+  alignas(32) std::int32_t buffer[] = {4, 3, 2, 1};
   {
     SimdType a(buffer, ex::element_aligned_tag());
     assert(a[0] == 4);
     assert(a[1] == 3);
     assert(a[2] == 2);
     assert(a[3] == 1);
   }
   {
void test_converting_load_ctor() {
   assert(a[0] == 1);
   assert(a[1] == 2);
   assert(a[2] == 4);
   assert(a[3] == 8);
 }
 
 int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
-  assert(ex::native_simd<int32_t>::size() >= 4);
-  test_load_ctor<ex::native_simd<int32_t>>();
-  test_load_ctor<ex::fixed_size_simd<int32_t, 4>>();
-  test_converting_load_ctor<ex::native_simd<int32_t>>();
-  test_converting_load_ctor<ex::fixed_size_simd<int32_t, 4>>();
+  assert(ex::native_simd<std::int32_t>::size() >= 4);
+  test_load_ctor<ex::native_simd<std::int32_t>>();
+  test_load_ctor<ex::fixed_size_simd<std::int32_t, 4>>();
+  test_converting_load_ctor<ex::native_simd<std::int32_t>>();
+  test_converting_load_ctor<ex::fixed_size_simd<std::int32_t, 4>>();
 
   return 0;
 }

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

 
 template <class T>
 void supported_load(...) = delete;
 
 void compile_load() {
   supported_load<int>((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<std::uint16_t>((unsigned int*)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};
+  alignas(32) std::int32_t buffer[] = {4, 3, 2, 1};
   {
     SimdType a;
     a.copy_from(buffer, ex::element_aligned_tag());
     assert(a[0] == 4);
     assert(a[1] == 3);
     assert(a[2] == 2);
     assert(a[3] == 1);
   }
void test_converting_load() {
   assert(a[0] == 1);
   assert(a[1] == 2);
   assert(a[2] == 4);
   assert(a[3] == 8);
 }
 
 int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
-  assert(ex::native_simd<int32_t>::size() >= 4);
-  test_load<ex::native_simd<int32_t>>();
-  test_load<ex::fixed_size_simd<int32_t, 4>>();
-  test_converting_load<ex::native_simd<int32_t>>();
-  test_converting_load<ex::fixed_size_simd<int32_t, 4>>();
+  assert(ex::native_simd<std::int32_t>::size() >= 4);
+  test_load<ex::native_simd<std::int32_t>>();
+  test_load<ex::fixed_size_simd<std::int32_t, 4>>();
+  test_converting_load<ex::native_simd<std::int32_t>>();
+  test_converting_load<ex::fixed_size_simd<std::int32_t, 4>>();
 
   return 0;
 }

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

 #include "test_macros.h"
 
 namespace ex = std::experimental::parallelism_v2;
 
 template <typename SimdType>
 void test_store() {
   SimdType a([](int i) { return 4 - i; });
   {
-    alignas(32) int32_t buffer[4] = {0};
+    alignas(32) std::int32_t buffer[4] = {0};
     a.copy_to(buffer, ex::element_aligned_tag());
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
     assert(buffer[2] == 2);
     assert(buffer[3] == 1);
   }
   {
-    alignas(32) int32_t buffer[4] = {0};
+    alignas(32) std::int32_t buffer[4] = {0};
     a.copy_to(buffer, ex::vector_aligned_tag());
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
     assert(buffer[2] == 2);
     assert(buffer[3] == 1);
   }
   {
-    alignas(32) int32_t buffer[4] = {0};
+    alignas(32) std::int32_t buffer[4] = {0};
     a.copy_to(buffer, ex::overaligned_tag<32>());
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
     assert(buffer[2] == 2);
     assert(buffer[3] == 1);
   }
 
   {
-    alignas(32) int32_t buffer[4] = {0};
+    alignas(32) std::int32_t buffer[4] = {0};
     a.copy_to(buffer, ex::element_aligned);
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
     assert(buffer[2] == 2);
     assert(buffer[3] == 1);
   }
   {
-    alignas(32) int32_t buffer[4] = {0};
+    alignas(32) std::int32_t buffer[4] = {0};
     a.copy_to(buffer, ex::vector_aligned);
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
     assert(buffer[2] == 2);
     assert(buffer[3] == 1);
   }
   {
-    alignas(32) int32_t buffer[4] = {0};
+    alignas(32) std::int32_t buffer[4] = {0};
     a.copy_to(buffer, ex::overaligned<32>);
     assert(buffer[0] == 4);
     assert(buffer[1] == 3);
     assert(buffer[2] == 2);
     assert(buffer[3] == 1);
   }
 }
 
 template <typename SimdType>
 void test_converting_store() {
   float buffer[4] = {0.};
   SimdType a([](int i) { return 1 << i; });
   a.copy_to(buffer, ex::element_aligned_tag());
   assert(buffer[0] == 1.);
   assert(buffer[1] == 2.);
   assert(buffer[2] == 4.);
   assert(buffer[3] == 8.);
 }
 
 int main(int, char**) {
   // TODO: adjust the tests when this assertion fails.
-  test_store<ex::native_simd<int32_t>>();
-  test_store<ex::fixed_size_simd<int32_t, 4>>();
-  test_converting_store<ex::native_simd<int32_t>>();
-  test_converting_store<ex::fixed_size_simd<int32_t, 4>>();
+  test_store<ex::native_simd<std::int32_t>>();
+  test_store<ex::fixed_size_simd<std::int32_t, 4>>();
+  test_converting_store<ex::native_simd<std::int32_t>>();
+  test_converting_store<ex::fixed_size_simd<std::int32_t, 4>>();
 
   return 0;
 }

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

 #include <cstdint>
 #include <experimental/simd>
 #include "test_macros.h"
 
 namespace ex = std::experimental::parallelism_v2;
 
 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<std::int8_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::native<std::int16_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::native<std::int32_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::native<std::int64_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::native<std::uint8_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::native<std::uint16_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<std::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<std::int8_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::int16_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::int32_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::int64_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::uint8_t>>::value, "");
+static_assert(ex::is_abi_tag<ex::simd_abi::compatible<std::uint16_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<std::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_abi::fixed_size<1>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<2>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<3>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<4>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<5>>::value, "");
 static_assert(ex::is_abi_tag<ex::simd_abi::fixed_size<32>>::value, "");
 
 static_assert(!ex::is_abi_tag<void>::value, "");
 static_assert(!ex::is_abi_tag<int>::value, "");
 static_assert(!ex::is_abi_tag<float>::value, "");
 static_assert(!ex::is_abi_tag<UserType>::value, "");
 static_assert(!ex::is_abi_tag<ex::simd<int>>::value, "");
 static_assert(!ex::is_abi_tag<ex::simd<float>>::value, "");
 static_assert(!ex::is_abi_tag<ex::simd_mask<int>>::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<std::int8_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::int16_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::int32_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::int64_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::uint8_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::native<std::uint16_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<std::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<std::int8_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::int16_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::int32_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::int64_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::uint8_t>>, "");
+static_assert(ex::is_abi_tag_v<ex::simd_abi::compatible<std::uint16_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<std::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

 #include <cstdint>
 #include <experimental/simd>
 #include "test_macros.h"
 
 namespace ex = std::experimental::parallelism_v2;
 
 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<std::int8_t>>::value, "");
+static_assert(ex::is_simd<ex::native_simd<std::int16_t>>::value, "");
+static_assert(ex::is_simd<ex::native_simd<std::int32_t>>::value, "");
+static_assert(ex::is_simd<ex::native_simd<std::int64_t>>::value, "");
+static_assert(ex::is_simd<ex::native_simd<std::uint8_t>>::value, "");
+static_assert(ex::is_simd<ex::native_simd<std::uint16_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<std::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<std::int8_t, 1>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int16_t, 1>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int32_t, 1>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int64_t, 1>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint8_t, 1>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint16_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<std::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<std::int8_t, 3>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int16_t, 3>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int32_t, 3>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int64_t, 3>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint8_t, 3>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint16_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<std::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<std::int8_t, 32>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int16_t, 32>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int32_t, 32>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::int64_t, 32>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint8_t, 32>>::value, "");
+static_assert(ex::is_simd<ex::fixed_size_simd<std::uint16_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<std::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<std::int8_t>>, "");
+static_assert(ex::is_simd_v<ex::native_simd<std::int16_t>>, "");
+static_assert(ex::is_simd_v<ex::native_simd<std::int32_t>>, "");
+static_assert(ex::is_simd_v<ex::native_simd<std::int64_t>>, "");
+static_assert(ex::is_simd_v<ex::native_simd<std::uint8_t>>, "");
+static_assert(ex::is_simd_v<ex::native_simd<std::uint16_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<std::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<std::int8_t, 1>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int16_t, 1>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int32_t, 1>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int64_t, 1>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint8_t, 1>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint16_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<std::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<std::int8_t, 3>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int16_t, 3>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int32_t, 3>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int64_t, 3>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint8_t, 3>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint16_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<std::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<std::int8_t, 32>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int16_t, 32>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int32_t, 32>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::int64_t, 32>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint8_t, 32>>, "");
+static_assert(ex::is_simd_v<ex::fixed_size_simd<std::uint16_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<std::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_flag_type.pass.cpp

 static_assert(ex::is_simd_flag_type<ex::vector_aligned_tag>::value, "");
 static_assert(ex::is_simd_flag_type<ex::overaligned_tag<16>>::value, "");
 static_assert(ex::is_simd_flag_type<ex::overaligned_tag<32>>::value, "");
 
 static_assert(!ex::is_simd_flag_type<void>::value, "");
 static_assert(!ex::is_simd_flag_type<int>::value, "");
 static_assert(!ex::is_simd_flag_type<float>::value, "");
 static_assert(!ex::is_simd_flag_type<UserType>::value, "");
-static_assert(!ex::is_simd_flag_type<ex::simd<int8_t>>::value, "");
-static_assert(!ex::is_simd_flag_type<ex::simd_mask<int8_t>>::value, "");
+static_assert(!ex::is_simd_flag_type<ex::simd<std::int8_t>>::value, "");
+static_assert(!ex::is_simd_flag_type<ex::simd_mask<std::int8_t>>::value, "");
 
 static_assert(ex::is_simd_flag_type_v<ex::element_aligned_tag>, "");
 static_assert(ex::is_simd_flag_type_v<ex::vector_aligned_tag>, "");
 static_assert(ex::is_simd_flag_type_v<ex::overaligned_tag<16>>, "");
 static_assert(ex::is_simd_flag_type_v<ex::overaligned_tag<32>>, "");
 
 static_assert(!ex::is_simd_flag_type_v<void>, "");
 static_assert(!ex::is_simd_flag_type_v<int>, "");
 static_assert(!ex::is_simd_flag_type_v<float>, "");
 static_assert(!ex::is_simd_flag_type_v<UserType>, "");
-static_assert(!ex::is_simd_flag_type_v<ex::simd<int8_t>>, "");
-static_assert(!ex::is_simd_flag_type_v<ex::simd_mask<int8_t>>, "");
+static_assert(!ex::is_simd_flag_type_v<ex::simd<std::int8_t>>, "");
+static_assert(!ex::is_simd_flag_type_v<ex::simd_mask<std::int8_t>>, "");
 
 int main(int, char**) {
   return 0;
 }

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

 #include <cstdint>
 #include <experimental/simd>
 #include "test_macros.h"
 
 namespace ex = std::experimental::parallelism_v2;
 
 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<std::int8_t>>::value, "");
+static_assert(ex::is_simd_mask<ex::native_simd_mask<std::int16_t>>::value, "");
+static_assert(ex::is_simd_mask<ex::native_simd_mask<std::int32_t>>::value, "");
+static_assert(ex::is_simd_mask<ex::native_simd_mask<std::int64_t>>::value, "");
+static_assert(ex::is_simd_mask<ex::native_simd_mask<std::uint8_t>>::value, "");
+static_assert(ex::is_simd_mask<ex::native_simd_mask<std::uint16_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<std::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<std::int8_t, 1>>::value, "");
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::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<std::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<std::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<std::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<std::uint16_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<std::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<std::int8_t, 3>>::value, "");
+static_assert(ex::is_simd_mask<ex::fixed_size_simd_mask<std::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<std::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<std::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<std::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<std::uint16_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<std::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<std::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<std::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<std::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<std::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<std::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<std::uint16_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<std::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<std::int8_t>>, "");
+static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::int16_t>>, "");
+static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::int32_t>>, "");
+static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::int64_t>>, "");
+static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::uint8_t>>, "");
+static_assert(ex::is_simd_mask_v<ex::native_simd_mask<std::uint16_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<std::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<std::int8_t, 1>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int16_t, 1>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int32_t, 1>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int64_t, 1>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint8_t, 1>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint16_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<std::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<std::int8_t, 3>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int16_t, 3>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int32_t, 3>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int64_t, 3>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint8_t, 3>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint16_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<std::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<std::int8_t, 32>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int16_t, 32>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int32_t, 32>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::int64_t, 32>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint8_t, 32>>, "");
+static_assert(ex::is_simd_mask_v<ex::fixed_size_simd_mask<std::uint16_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<std::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/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp

 using Minutes = std::chrono::minutes;
 using MilliSec = std::chrono::duration<file_time_type::rep, std::milli>;
 using MicroSec = std::chrono::duration<file_time_type::rep, std::micro>;
 using NanoSec = std::chrono::duration<file_time_type::rep, std::nano>;
 using std::chrono::duration_cast;
 
 #ifdef _WIN32
 struct TimeSpec {
-  int64_t tv_sec;
-  int64_t tv_nsec;
+  std::int64_t tv_sec;
+  std::int64_t tv_nsec;
 };
 struct StatT {
   TimeSpec st_atim;
   TimeSpec st_mtim;
 };
 // There were 369 years and 89 leap days from the Windows epoch
 // (1601) to the Unix epoch (1970).
-#define FILE_TIME_OFFSET_SECS (uint64_t(369 * 365 + 89) * (24 * 60 * 60))
+#define FILE_TIME_OFFSET_SECS (std::uint64_t(369 * 365 + 89) * (24 * 60 * 60))
 static TimeSpec filetime_to_timespec(LARGE_INTEGER li) {
   TimeSpec ret;
   ret.tv_sec = li.QuadPart / 10000000 - FILE_TIME_OFFSET_SECS;
   ret.tv_nsec = (li.QuadPart % 10000000) * 100;
   return ret;
 }
 static int stat_file(const char *path, StatT *buf, int flags) {
   HANDLE h = CreateFileA(path, FILE_READ_ATTRIBUTES,

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

int main(int, char**)
     test<int>(o, "020000000000");
     test<int>(d, "-2147483648");
     test<int>(x, "0x80000000");
 
     test<unsigned int>(o, "037777777777");
     test<unsigned int>(d, "4294967295");
     test<unsigned int>(x, "0xffffffff");
 
-    const bool long_is_32 = std::integral_constant<bool, sizeof(long) == sizeof(int32_t)>::value; // avoid compiler warnings
-    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
+    const bool long_is_32 = std::integral_constant<bool, sizeof(long) == sizeof(std::int32_t)>::value; // avoid compiler warnings
+    const bool long_is_64 = std::integral_constant<bool, sizeof(long) == sizeof(std::int64_t)>::value; // avoid compiler warnings
+    const bool long_long_is_64 = std::integral_constant<bool, sizeof(long long) == sizeof(std::int64_t)>::value; // avoid compiler warnings
 
     if (long_is_32) {
         test<long>(o, "020000000000");
         test<long>(d, "-2147483648");
         test<long>(x, "0x80000000");
 
         test<unsigned long>(o, "037777777777");
         test<unsigned long>(d, "4294967295");

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

for (size_t i = 0; i < str.size(); ++i )
         str[i] = static_cast<char>(std::toupper(str[i]));
 
     assert(str == expected);
 }
 
 int main(int, char**)
 {
 
-    test_octal<uint16_t>(                "177777");
-    test_octal< int16_t>(                "177777");
+    test_octal<std::uint16_t>(                "177777");
+    test_octal< std::int16_t>(                "177777");
     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");
+    test_octal< std::int32_t>(           "37777777777");
+    test_octal<std::uint64_t>("1777777777777777777777");
+    test_octal< std::int64_t>("1777777777777777777777");
+    test_octal<std::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
+    const bool long_is_64 = std::integral_constant<bool, sizeof(long) == sizeof(std::int64_t)>::value; // avoid compiler warnings
+    const bool long_long_is_64 = std::integral_constant<bool, sizeof(long long) == sizeof(std::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<std::uint16_t>(               "65535");
+    test_dec< std::int16_t>(                  "-1");
     test_dec<std::uint32_t>(          "4294967295");
-    test_dec< int32_t>(                  "-1");
-    test_dec<uint64_t>("18446744073709551615");
-    test_dec< int64_t>(                  "-1");
+    test_dec< std::int32_t>(                  "-1");
+    test_dec<std::uint64_t>("18446744073709551615");
+    test_dec< std::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<std::uint16_t>(            "FFFF");
+    test_hex< std::int16_t>(            "FFFF");
     test_hex<std::uint32_t>(        "FFFFFFFF");
-    test_hex< int32_t>(        "FFFFFFFF");
-    test_hex<uint64_t>("FFFFFFFFFFFFFFFF");
-    test_hex< int64_t>("FFFFFFFFFFFFFFFF");
+    test_hex< std::int32_t>(        "FFFFFFFF");
+    test_hex<std::uint64_t>("FFFFFFFFFFFFFFFF");
+    test_hex< std::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/iterators/iterator.container/ssize.pass.cpp

 #include <vector>
 
 #include "test_macros.h"
 
 // Ignore warning about std::numeric_limits comparisons being tautological.
 TEST_GCC_DIAGNOSTIC_IGNORED("-Wtype-limits")
 
 struct short_container {
-    uint16_t size() const { return 60000; } // not noexcept
+    std::uint16_t size() const { return 60000; } // not noexcept
 };
 
 template<typename C>
 void test_container(C& c)
 {
 //  Can't say noexcept here because the container might not be
     static_assert( std::is_signed_v<decltype(std::ssize(c))>, "");
     assert ( std::ssize(c)   == static_cast<decltype(std::ssize(c))>(c.size()));

libcxx/test/std/language.support/support.srcloc/general.pass.cpp

 static_assert(empty.column() == 0);
 static_assert(empty.file_name()[0] == '\0');
 static_assert(empty.function_name()[0] == '\0');
 
 ASSERT_NOEXCEPT(empty.line());
 ASSERT_NOEXCEPT(empty.column());
 ASSERT_NOEXCEPT(empty.file_name());
 ASSERT_NOEXCEPT(empty.function_name());
-std::same_as<uint_least32_t> auto line   = empty.line();
-std::same_as<uint_least32_t> auto column = empty.column();
+std::same_as<std::uint_least32_t> auto line   = empty.line();
+std::same_as<std::uint_least32_t> auto column = empty.column();
 std::same_as<const char*> auto file      = empty.file_name();
 std::same_as<const char*> auto function  = empty.function_name();
 
 // A simple use of current() outside a function.
 constexpr std::source_location cur =
 #line 1000 "ss"
     std::source_location::current();
 static_assert(cur.line() == 1000);

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

 {
     // Make sure we generate a compile-time error for UB
     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<std::uint8_t>(), "");   // expected-error-re {{{{(static_assert|static assertion)}} expression is not an integral constant expression}}
+    static_assert(toobig<std::uint16_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<std::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

int main(int, char**)
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
#endif
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     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<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::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<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::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

int main(int, char**)
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
#endif
     static_assert(test<unsigned short>());
     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<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::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<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::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

int main(int, char**)
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
#endif
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     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<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::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<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::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

int main(int, char**)
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
#endif
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     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<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::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<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

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

int main(int, char**)
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
#endif
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     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<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::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<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

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

int main(int, char**)
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
#endif
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     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<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::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<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

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

int main(int, char**)
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
#endif
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     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<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::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<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

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

int main(int, char**)
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
#endif
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     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<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::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<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

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

int main(int, char**)
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
#endif
     static_assert(test<unsigned char>());
     static_assert(test<unsigned short>());
     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<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::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<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

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

int main(int, char**)
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
#endif
     static_assert(test<unsigned short>());
     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<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::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<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

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

int main(int, char**)
     static_assert(!std::is_invocable_v<L, short>);
     static_assert(!std::is_invocable_v<L, int>);
     static_assert(!std::is_invocable_v<L, long>);
     static_assert(!std::is_invocable_v<L, long long>);
 #ifndef TEST_HAS_NO_INT128
     static_assert(!std::is_invocable_v<L, __int128_t>);
 #endif
 
-    static_assert(!std::is_invocable_v<L, int8_t>);
-    static_assert(!std::is_invocable_v<L, int16_t>);
-    static_assert(!std::is_invocable_v<L, int32_t>);
-    static_assert(!std::is_invocable_v<L, int64_t>);
+    static_assert(!std::is_invocable_v<L, std::int8_t>);
+    static_assert(!std::is_invocable_v<L, std::int16_t>);
+    static_assert(!std::is_invocable_v<L, std::int32_t>);
+    static_assert(!std::is_invocable_v<L, std::int64_t>);
     static_assert(!std::is_invocable_v<L, intmax_t>);
     static_assert(!std::is_invocable_v<L, intptr_t>);
     static_assert(!std::is_invocable_v<L, ptrdiff_t>);
 
     static_assert(!std::is_invocable_v<L, bool>);
     static_assert(!std::is_invocable_v<L, char>);
     static_assert(!std::is_invocable_v<L, wchar_t>);
 #ifndef TEST_HAS_NO_CHAR8_T
#endif
     static_assert(test<unsigned short>());
     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<std::uint8_t>());
+    static_assert(test<std::uint16_t>());
     static_assert(test<std::uint32_t>());
-    static_assert(test<uint64_t>());
+    static_assert(test<std::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<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
     test<uintmax_t>();
     test<uintptr_t>();
     test<size_t>();
 
     return 0;
 }

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

 
 template <class T>
 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<std::uint8_t>(0xAB, 0xAB);
+  test_num<std::uint16_t>(0xCDEF, 0xEFCD);
   test_num<std::uint32_t>(0x01234567, 0x67452301);
-  test_num<uint64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
+  test_num<std::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);
+  test_num<std::int8_t>(static_cast<std::int8_t>(0xAB), static_cast<std::int8_t>(0xAB));
+  test_num<std::int16_t>(static_cast<std::int16_t>(0xCDEF), static_cast<std::int16_t>(0xEFCD));
+  test_num<std::int32_t>(0x01234567, 0x67452301);
+  test_num<std::int64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
 
 #ifndef TEST_HAS_NO_INT128
   const auto in = static_cast<__uint128_t>(0x0123456789ABCDEF) << 64 | 0x13579BDF02468ACE;
   const auto expected = static_cast<__uint128_t>(0xCE8A4602DF9B5713) << 64 | 0xEFCDAB8967452301;
   test_num<__uint128_t>(in, expected);
   test_num<__int128_t>(in, expected);
 #endif
 

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

 int main(int, char**)
 {
     signed_test<signed char>();
     signed_test<short>();
     signed_test<int>();
     signed_test<long>();
     signed_test<long long>();
 
-    signed_test<int8_t>();
-    signed_test<int16_t>();
-    signed_test<int32_t>();
-    signed_test<int64_t>();
+    signed_test<std::int8_t>();
+    signed_test<std::int16_t>();
+    signed_test<std::int32_t>();
+    signed_test<std::int64_t>();
 
     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<std::uint8_t>();
+    unsigned_test<std::uint16_t>();
     unsigned_test<std::uint32_t>();
-    unsigned_test<uint64_t>();
+    unsigned_test<std::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/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp

int main(int, char**) {
     tests<long long>();
 
     tests<unsigned short>();
     tests<unsigned int>();
     tests<unsigned long>();
     tests<unsigned long long>();
 
 #if defined(_LIBCPP_VERSION) // extension
-    tests<int8_t>();
-    tests<uint8_t>();
+    tests<std::int8_t>();
+    tests<std::uint8_t>();
 #if !defined(TEST_HAS_NO_INT128)
     tests<__int128_t>();
     tests<__uint128_t>();
 #endif
 #endif
 
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp

int main(int, char**) {
     tests<long long>();
 
     tests<unsigned short>();
     tests<unsigned int>();
     tests<unsigned long>();
     tests<unsigned long long>();
 
 #if defined(_LIBCPP_VERSION) // extension
-    tests<int8_t>();
-    tests<uint8_t>();
+    tests<std::int8_t>();
+    tests<std::uint8_t>();
 #if !defined(TEST_HAS_NO_INT128)
     tests<__int128_t>();
     tests<__uint128_t>();
 #endif
 #endif
 
     return 0;
 }

libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp

int main(int, char**)
     test_statistics<unsigned short, std::minstd_rand0>();
     test_statistics<unsigned int, std::minstd_rand0>();
     test_statistics<unsigned long, std::minstd_rand0>();
     test_statistics<unsigned long long, std::minstd_rand0>();
 
     test_statistics<short, std::minstd_rand0>(SHRT_MIN, SHRT_MAX);
 
 #if defined(_LIBCPP_VERSION) // extension
-    test_statistics<int8_t, std::minstd_rand0>();
-    test_statistics<uint8_t, std::minstd_rand0>();
+    test_statistics<std::int8_t, std::minstd_rand0>();
+    test_statistics<std::uint8_t, std::minstd_rand0>();
 
 #if !defined(TEST_HAS_NO_INT128) && !defined(TEST_BUGGY_I128_FP)
     test_statistics<__int128_t, std::minstd_rand0>();
     test_statistics<__uint128_t, std::minstd_rand0>();
 
     test_statistics<__int128_t, std::minstd_rand0>(-100, 900);
     test_statistics<__int128_t, std::minstd_rand0>(0, UINT64_MAX);
     test_statistics<__int128_t, std::minstd_rand0>(std::numeric_limits<__int128_t>::min(), std::numeric_limits<__int128_t>::max());
     test_statistics<__uint128_t, std::minstd_rand0>(0, UINT64_MAX);
 #endif
 #endif
 
     return 0;
 }

libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp

 #endif
 }
 
 int main(int, char**)
 {
     test1();
     test2();
 
-    test_implicit<std::mt19937, uint_fast32_t>();
-    test_implicit<std::mt19937_64, uint_fast64_t>();
+    test_implicit<std::mt19937, std::uint_fast32_t>();
+    test_implicit<std::mt19937_64, std::uint_fast64_t>();
 
     return 0;
 }

libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp

int main(int, char**)
     test1();
     test2();
 
 #if TEST_STD_VER >= 11
     static_assert(test_convertible<std::ranlux24_base>(), "");
     static_assert(test_convertible<std::ranlux48_base>(), "");
     test_implicit_ctor<std::ranlux24_base>();
     test_implicit_ctor<std::ranlux48_base>();
-    static_assert(!test_convertible<std::ranlux24_base, uint_fast32_t>(), "");
-    static_assert(!test_convertible<std::ranlux48_base, uint_fast64_t>(), "");
+    static_assert(!test_convertible<std::ranlux24_base, std::uint_fast32_t>(), "");
+    static_assert(!test_convertible<std::ranlux48_base, std::uint_fast64_t>(), "");
 #endif
 
   return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp

#endif
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.append(s_long.begin(), s_long.end());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 
   { // test appending a different type
     typedef std::string S;
-    const uint8_t p[] = "ABCD";
+    const std::uint8_t p[] = "ABCD";
 
     S s;
     s.append(p, p + 4);
     assert(s == "ABCD");
   }
 
   { // regression-test appending to self in sneaky ways
     std::string s_short = "hello";

libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp

#endif
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/");
 
     s_long.assign(s_long.begin() + 30, s_long.end());
     assert(s_long == "nsectetur/");
   }
 
   { // test assigning a different type
     typedef std::string S;
-    const uint8_t p[] = "ABCD";
+    const std::uint8_t p[] = "ABCD";
 
     S s;
     s.assign(p, p + 4);
     assert(s == "ABCD");
   }
 
   { // regression-test assigning to self in sneaky ways
     std::string sneaky = "hello";

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp

#endif
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.insert(s_long.begin(), s_long.begin(), s_long.end());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 
   { // test assigning a different type
     typedef std::string S;
-    const uint8_t p[] = "ABCD";
+    const std::uint8_t p[] = "ABCD";
 
     S s;
     s.insert(s.begin(), p, p + 4);
     assert(s == "ABCD");
   }
 
   if (!TEST_IS_CONSTANT_EVALUATED) { // regression-test inserting into self in sneaky ways
     std::string s_short = "hello";

libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp

#endif
     s_short.replace(s_short.begin(), s_short.begin(), s_short.begin(), s_short.end());
     assert(s_short == "123/123/123/123/123/123/123/123/");
 
     s_long.replace(s_long.begin(), s_long.begin(), s_long.begin(), s_long.end());
     assert(s_long == "Lorem ipsum dolor sit amet, consectetur/Lorem ipsum dolor sit amet, consectetur/");
   }
 
   { // test assigning a different type
-    const uint8_t pc[] = "ABCD";
-    uint8_t        p[] = "EFGH";
+    const std::uint8_t pc[] = "ABCD";
+    std::uint8_t        p[] = "EFGH";
 
     S s;
     s.replace(s.begin(), s.end(), pc, pc + 4);
     assert(s == "ABCD");
 
     s.clear();
     s.replace(s.begin(), s.end(), p, p + 4);
     assert(s == "EFGH");

libcxx/test/std/time/time.hms/time.hms.members/seconds.pass.cpp

 #include <cassert>
 #include <cstdint>
 #include <ratio>
 #include <utility>
 
 #include "test_macros.h"
 
 template <typename Duration>
-constexpr int64_t check_seconds(Duration d)
+constexpr std::int64_t check_seconds(Duration d)
 {
     using HMS = std::chrono::hh_mm_ss<Duration>;
     ASSERT_SAME_TYPE(std::chrono::seconds, decltype(std::declval<HMS>().seconds()));
     ASSERT_NOEXCEPT(                                std::declval<HMS>().seconds());
     return HMS(d).seconds().count();
 }
 
 int main(int, char**)

libcxx/test/std/time/time.hms/time.hms.members/subseconds.pass.cpp

 #include <cassert>
 #include <cstdint>
 #include <ratio>
 #include <utility>
 
 #include "test_macros.h"
 
 template <typename Duration>
-constexpr int64_t check_subseconds(Duration d)
+constexpr std::int64_t check_subseconds(Duration d)
 {
     using HMS = std::chrono::hh_mm_ss<Duration>;
     ASSERT_SAME_TYPE(typename HMS::precision, decltype(std::declval<HMS>().subseconds()));
     ASSERT_NOEXCEPT(                                   std::declval<HMS>().subseconds());
     return HMS(d).subseconds().count();
 }
 
 int main(int, char**)

libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp

check(SV("-%H='03'\t"
            "%p='AM'\t"
            "%R='03:02'\t"
            "%T='03:02:01.123456789012'\t"
            "%r='03:02:01 AM'\t"
            "%X='03:02:01'\t"
            "%EX='03:02:01'\t"
            "\n"),
         fmt,
-        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<int64_t, std::pico>(123456789012))));
+        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<std::int64_t, std::pico>(123456789012))));
 
   // The number of fractional seconds is 0 according to the Standard
   // TODO FMT Determine what to do.
   check(SV("%H='01'\t"
            "%OH='01'\t"
            "%I='01'\t"
            "%OI='01'\t"
            "%M='01'\t"
#elif defined(__APPLE__)
            "%r=''\t"
 #else
            "%r='03:02:01 '\t"
 #endif
            "%X='03:02:01'\t"
            "%EX='03:02:01'\t"
            "\n"),
         lfmt,
-        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<int64_t, std::pico>(123456789012))));
+        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<std::int64_t, std::pico>(123456789012))));
 
   check(SV("%H='01'\t"
            "%OH='01'\t"
            "%I='01'\t"
            "%OI='01'\t"
            "%M='01'\t"
            "%OM='01'\t"
            "%S='01'\t"
#  if defined(__APPLE__)
            "%EX='03時02分01秒'\t"
 #  else
            "%r='午前03:02:01'\t"
            "%X='03:02:01'\t"
            "%EX='03:02:01'\t"
 #  endif
            "\n"),
         lfmt,
-        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<int64_t, std::pico>(123456789012))));
+        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<std::int64_t, std::pico>(123456789012))));
 
   check(loc,
         SV("%H='01'\t"
            "%OH='01'\t"
            "%I='01'\t"
            "%OI='01'\t"
            "%M='01'\t"
            "%OM='01'\t"
check(loc,
            "%p='午前'\t"
            "%R='03:02'\t"
            "%T='03:02:01.123456789012'\t"
            "%r='午前03時02分01秒'\t"
            "%X='03時02分01秒'\t"
            "%EX='03時02分01秒'\t"
            "\n"),
         lfmt,
-        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<int64_t, std::pico>(123456789012))));
+        std::chrono::hh_mm_ss(-(3h + 2min + 1s + std::chrono::duration<std::int64_t, std::pico>(123456789012))));
 
   check(loc,
         SV("%H='01'\t"
            "%OH='一'\t"
            "%I='01'\t"
            "%OI='一'\t"
            "%M='01'\t"
            "%OM='一'\t"

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

 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #ifndef FLOATING_POINT_TEST_CASES_HPP
 #define FLOATING_POINT_TEST_CASES_HPP
 
 #include <stdint.h>
 #include <utility>
 
-constexpr std::pair<const char*, uint64_t> floating_point_test_cases_double[] = {
+constexpr std::pair<const char*, std::uint64_t> floating_point_test_cases_double[] = {
     // Verify small exactly-representable integers:
     {"1", 0x3FF0000000000000ULL},
     {"2", 0x4000000000000000ULL},
     {"3", 0x4008000000000000ULL},
     {"4", 0x4010000000000000ULL},
     {"5", 0x4014000000000000ULL},
     {"6", 0x4018000000000000ULL},
     {"7", 0x401C000000000000ULL},

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

 }
 
 // https://www.wolframalpha.com : Table[BaseForm[n * 2 - 1, n], {n, 2, 36}]
 constexpr const char* output_max_digit[] = {"skip0", "skip1", "11", "12", "13", "14", "15", "16", "17", "18", "19",
     "1a", "1b", "1c", "1d", "1e", "1f", "1g", "1h", "1i", "1j", "1k", "1l", "1m", "1n", "1o", "1p", "1q", "1r", "1s",
     "1t", "1u", "1v", "1w", "1x", "1y", "1z"};
 
 // https://www.wolframalpha.com : Table[BaseForm[k, n], {k, {MEOW, MEOW, MEOW}}, {n, 2, 36}]
-constexpr uint64_t stress_chunks_positive                          = 12000000345000678900ULL;
-constexpr pair<uint64_t, array<const char*, 37>> output_positive[] = {
+constexpr std::uint64_t stress_chunks_positive                          = 12000000345000678900ULL;
+constexpr pair<std::uint64_t, array<const char*, 37>> output_positive[] = {
     {123U, {{"skip0", "skip1", "1111011", "11120", "1323", "443", "323", "234", "173", "146", "123", "102", "a3", "96",
                "8b", "83", "7b", "74", "6f", "69", "63", "5i", "5d", "58", "53", "4n", "4j", "4f", "4b", "47", "43",
                "3u", "3r", "3o", "3l", "3i", "3f"}}},
-    {uint64_t{INT8_MAX}, {{"skip0", "skip1", "1111111", "11201", "1333", "1002", "331", "241", "177", "151", "127",
+    {std::uint64_t{INT8_MAX}, {{"skip0", "skip1", "1111111", "11201", "1333", "1002", "331", "241", "177", "151", "127",
                              "106", "a7", "9a", "91", "87", "7f", "78", "71", "6d", "67", "61", "5h", "5c", "57", "52",
                              "4n", "4j", "4f", "4b", "47", "43", "3v", "3s", "3p", "3m", "3j"}}},
     {161U, {{"skip0", "skip1", "10100001", "12222", "2201", "1121", "425", "320", "241", "188", "161", "137", "115",
                "c5", "b7", "ab", "a1", "98", "8h", "89", "81", "7e", "77", "70", "6h", "6b", "65", "5q", "5l", "5g",
                "5b", "56", "51", "4t", "4p", "4l", "4h"}}},
     {UINT8_MAX, {{"skip0", "skip1", "11111111", "100110", "3333", "2010", "1103", "513", "377", "313", "255", "212",
                     "193", "168", "143", "120", "ff", "f0", "e3", "d8", "cf", "c3", "bd", "b2", "af", "a5", "9l", "9c",
                     "93", "8n", "8f", "87", "7v", "7o", "7h", "7a", "73"}}},
     {1729U, {{"skip0", "skip1", "11011000001", "2101001", "123001", "23404", "12001", "5020", "3301", "2331", "1729",
                 "1332", "1001", "a30", "8b7", "7a4", "6c1", "5gc", "561", "4f0", "469", "3j7", "3cd", "364", "301",
                 "2j4", "2ed", "2a1", "25l", "21i", "1rj", "1oo", "1m1", "1jd", "1gt", "1ee", "1c1"}}},
-    {uint64_t{INT16_MAX}, {{"skip0", "skip1", "111111111111111", "1122221121", "13333333", "2022032", "411411",
+    {std::uint64_t{INT16_MAX}, {{"skip0", "skip1", "111111111111111", "1122221121", "13333333", "2022032", "411411",
                               "164350", "77777", "48847", "32767", "22689", "16b67", "11bb7", "bd27", "9a97", "7fff",
                               "6b68", "5b27", "4eeb", "41i7", "3b67", "31f9", "2flf", "28l7", "22ah", "1mc7", "1hpg",
                               "1dm7", "19rq", "16c7", "1330", "vvv", "u2v", "sbp", "qq7", "pa7"}}},
     {57494U, {{"skip0", "skip1", "1110000010010110", "2220212102", "32002112", "3314434", "1122102", "326423", "160226",
                  "86772", "57494", "3a218", "29332", "20228", "16d4a", "1207e", "e096", "bbg0", "9f82", "8750", "73ee",
                  "647h", "58h8", "4gfh", "43je", "3goj", "3718", "2onb", "2h9a", "2aag", "23qe", "1spk", "1o4m", "1jq8",
                  "1fp0", "1bwo", "18d2"}}},
     {UINT16_MAX, {{"skip0", "skip1", "1111111111111111", "10022220020", "33333333", "4044120", "1223223", "362031",
                      "177777", "108806", "65535", "45268", "31b13", "23aa2", "19c51", "14640", "ffff", "d5d0", "b44f",
                      "9aa4", "83gf", "71cf", "638j", "58k8", "4hif", "44la", "3iof", "38o6", "2rgf", "2jqo", "2cof",
                      "2661", "1vvv", "1r5u", "1mnh", "1ihf", "1ekf"}}},
     {71125478U, {{"skip0", "skip1", "100001111010100100111100110", "11221211112210222", "10033110213212",
                     "121202003403", "11020244342", "1522361624", "417244746", "157745728", "71125478", "3716a696",
                     "1b9a06b2", "11973ba8", "9636514", "639e338", "43d49e6", "2g19gfb", "21b9d18", "19dec94", "124addi",
                     "h8f25b", "dhdfa6", "b13hg2", "8m91he", "7720j3", "5pgj58", "4pmelq", "43k17i", "3dg8ek", "2ro898",
                     "2f0et8", "23qif6", "1qw5lh", "1j7l7s", "1cdvli", "16cgrq"}}},
-    {uint64_t{INT32_MAX},
+    {std::uint64_t{INT32_MAX},
         {{"skip0", "skip1", "1111111111111111111111111111111", "12112122212110202101", "1333333333333333",
             "13344223434042", "553032005531", "104134211161", "17777777777", "5478773671", "2147483647", "a02220281",
             "4bb2308a7", "282ba4aaa", "1652ca931", "c87e66b7", "7fffffff", "53g7f548", "3928g3h1", "27c57h32",
             "1db1f927", "140h2d91", "ikf5bf1", "ebelf95", "b5gge57", "8jmdnkm", "6oj8ion", "5ehncka", "4clm98f",
             "3hk7987", "2sb6cs7", "2d09uc1", "1vvvvvv", "1lsqtl1", "1d8xqrp", "15v22um", "zik0zj"}}},
     {3522553278ULL,
         {{"skip0", "skip1", "11010001111101011110010110111110", "100002111022020200020", "3101331132112332",
             "24203233201103", "1341312313010", "153202131426", "32175362676", "10074266606", "3522553278", "1548431462",
constexpr pair<std::uint64_t, array<const char*, 37>> output_positive[] = {
     {545890816626160ULL,
         {{"skip0", "skip1", "1111100000111110000011100001101100000110111110000", "2122120211122121121021010202111",
             "1330013300130031200313300", "1033022333343024014120", "5213002440142255104", "222661211220253465",
             "17407603415406760", "2576748547233674", "545890816626160", "148a34aa4706535", "51285369b87494",
             "1a57a38b045a95", "98b3383b9766c", "4319d1601875a", "1f07c1c360df0", "ffd471f34f13", "88g09ff9dh84",
             "4d0d5e232c53", "2d63h403i580", "1bf5h8185hdj", "kc3g550fkcg", "d41id5k9984", "8ef5n0him4g", "5i2dijfe1la",
             "3me22fm5fhi", "2hfmhgg73kd", "1ngpfabr53c", "18i7220bh11", "rm0lcjngpa", "kk1elesni1", "fgfge3c3fg",
             "bp4q5l6bjg", "8xna46jp0k", "6wejomvji5", "5di2s1qhv4"}}},
-    {uint64_t{INT64_MAX},
+    {std::uint64_t{INT64_MAX},
         {{"skip0", "skip1", "111111111111111111111111111111111111111111111111111111111111111",
             "2021110011022210012102010021220101220221", "13333333333333333333333333333333",
             "1104332401304422434310311212", "1540241003031030222122211", "22341010611245052052300",
             "777777777777777777777", "67404283172107811827", "9223372036854775807", "1728002635214590697",
             "41a792678515120367", "10b269549075433c37", "4340724c6c71dc7a7", "160e2ad3246366807", "7fffffffffffffff",
             "33d3d8307b214008", "16agh595df825fa7", "ba643dci0ffeehh", "5cbfjia3fh26ja7", "2heiciiie82dh97",
             "1adaibb21dckfa7", "i6k448cf4192c2", "acd772jnc9l0l7", "64ie1focnn5g77", "3igoecjbmca687", "27c48l5b37oaop",
             "1bk39f3ah3dmq7", "q1se8f0m04isb", "hajppbc1fc207", "bm03i95hia437", "7vvvvvvvvvvvv", "5hg4ck9jd4u37",
constexpr pair<std::uint64_t, array<const char*, 37>> output_positive[] = {
             "839365134a2a240713", "219505a9511a867b72", "8681049adb03db171", "2c1d56b648c6cd110", "ffffffffffffffff",
             "67979g60f5428010", "2d3fgb0b9cg4bd2f", "141c8786h1ccaagg", "b53bjh07be4dj0f", "5e8g4ggg7g56dif",
             "2l4lf104353j8kf", "1ddh88h2782i515", "l12ee5fn0ji1if", "c9c336o0mlb7ef", "7b7n2pcniokcgf",
             "4eo8hfam6fllmo", "2nc6j26l66rhof", "1n3rsh11f098rn", "14l9lkmo30o40f", "nd075ib45k86f", "fvvvvvvvvvvvv",
             "b1w8p7j5q9r6f", "7orp63sh4dphh", "5g24a25twkwff", "3w5e11264sgsf"}}},
 };
 
 // https://www.wolframalpha.com : Table[BaseForm[k, n], {k, {MEOW, MEOW, MEOW}}, {n, 2, 36}]
-constexpr int64_t stress_chunks_negative                          = -9000876000000054321LL;
-constexpr pair<int64_t, array<const char*, 37>> output_negative[] = {
+constexpr std::int64_t stress_chunks_negative                          = -9000876000000054321LL;
+constexpr pair<std::int64_t, array<const char*, 37>> output_negative[] = {
     {-85, {{"skip0", "skip1", "-1010101", "-10011", "-1111", "-320", "-221", "-151", "-125", "-104", "-85", "-78",
               "-71", "-67", "-61", "-5a", "-55", "-50", "-4d", "-49", "-45", "-41", "-3j", "-3g", "-3d", "-3a", "-37",
               "-34", "-31", "-2r", "-2p", "-2n", "-2l", "-2j", "-2h", "-2f", "-2d"}}},
     {INT8_MIN, {{"skip0", "skip1", "-10000000", "-11202", "-2000", "-1003", "-332", "-242", "-200", "-152", "-128",
                    "-107", "-a8", "-9b", "-92", "-88", "-80", "-79", "-72", "-6e", "-68", "-62", "-5i", "-5d", "-58",
                    "-53", "-4o", "-4k", "-4g", "-4c", "-48", "-44", "-40", "-3t", "-3q", "-3n", "-3k"}}},
     {-1591, {{"skip0", "skip1", "-11000110111", "-2011221", "-120313", "-22331", "-11211", "-4432", "-3067", "-2157",
                 "-1591", "-1217", "-b07", "-955", "-819", "-711", "-637", "-58a", "-4g7", "-47e", "-3jb", "-3cg",
void test_integer_to_chars() {
     for (int base = 2; base <= 36; ++base) {
         test_integer_to_chars(static_cast<T>(0), base, "0");
         test_integer_to_chars(static_cast<T>(1), base, "1");
 
         // tests [3, 71]
         test_integer_to_chars(static_cast<T>(base * 2 - 1), base, output_max_digit[base]);
 
         for (const auto& p : output_positive) {
-            if (p.first <= static_cast<uint64_t>(numeric_limits<T>::max())) {
+            if (p.first <= static_cast<std::uint64_t>(numeric_limits<T>::max())) {
                 test_integer_to_chars(static_cast<T>(p.first), base, p.second[static_cast<size_t>(base)]);
             }
         }
 
         if constexpr (is_signed_v<T>) {
             test_integer_to_chars(static_cast<T>(-1), base, "-1");
 
             for (const auto& p : output_negative) {
-                if (p.first >= static_cast<int64_t>(numeric_limits<T>::min())) {
+                if (p.first >= static_cast<std::int64_t>(numeric_limits<T>::min())) {
                     test_integer_to_chars(static_cast<T>(p.first), base, p.second[static_cast<size_t>(base)]);
                 }
             }
         }
     }
 
     test_integer_to_chars(static_cast<T>(42), nullopt, "42");
 }
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>, std::uint32_t, uint64_t>;
+                using Uint = conditional_t<is_same_v<T, float>, std::uint32_t, std::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 {
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) {
+void assert_message_bits(const bool b, const char* const msg, const std::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 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 std::uint32_t Fractions = 1U << FractionBits;
 constexpr std::uint32_t Mask32    = ~((1U << FractionBits) - 1U);
-constexpr uint64_t Mask64    = ~((1ULL << FractionBits) - 1ULL);
+constexpr std::uint64_t Mask64    = ~((1ULL << FractionBits) - 1ULL);
 
 constexpr std::uint32_t PrefixesToTest = 100; // Tunable for test coverage vs. performance.
 static_assert(PrefixesToTest >= 1, "Must test at least 1 prefix.");
 
 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, std::uint32_t> prefix) {
+void test_floating_prefix(const conditional_t<IsDouble, std::uint64_t, std::uint32_t> prefix) {
 
-    using UIntType     = conditional_t<IsDouble, uint64_t, std::uint32_t>;
+    using UIntType     = conditional_t<IsDouble, std::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
                 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, std::uint32_t> prefix) {
+void test_floating_hex_prefix(const conditional_t<IsDouble, std::uint64_t, std::uint32_t> prefix) {
 
-    using UIntType     = conditional_t<IsDouble, uint64_t, std::uint32_t>;
+    using UIntType     = conditional_t<IsDouble, std::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"
#if 0
         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, std::uint32_t> prefix) {
+void test_floating_precision_prefix(const conditional_t<IsDouble, std::uint64_t, std::uint32_t> prefix) {
 
-    using UIntType     = conditional_t<IsDouble, uint64_t, std::uint32_t>;
+    using UIntType     = conditional_t<IsDouble, std::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;
 
for (std::uint32_t frac = 0; frac < Fractions; ++frac) {
         stdio_sv = general_stdio_buffer;
 
         assert_message_bits(charconv_sv == stdio_sv, "general precision output", bits);
     }
 }
 
 void test_floating_prefixes(mt19937_64& mt64) {
     {
-        set<uint64_t> prefixes64;
+        set<std::uint64_t> prefixes64;
 
         while (prefixes64.size() < PrefixesToTest) {
-            const uint64_t val = mt64();
+            const std::uint64_t val = mt64();
 
             if ((val & 0x7FF0000000000000ULL) != 0x7FF0000000000000ULL) { // skip INF/NAN
                 prefixes64.insert(val & Mask64);
             }
         }
 
         for (const auto& prefix : prefixes64) {
             test_floating_prefix<true>(prefix);

libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp

 // constexpr to_chars_result to_chars(char* first, char* last, Integral value,
 //                                    int base = 10)
 
 #include <charconv>
 #include "test_macros.h"
 #include "charconv_test_helpers.h"
 
 #ifndef TEST_HAS_NO_INT128
-TEST_CONSTEXPR_CXX23 __uint128_t make_u128(__uint128_t a, uint64_t b) {
+TEST_CONSTEXPR_CXX23 __uint128_t make_u128(__uint128_t a, std::uint64_t b) {
   a *= 1000000000000000000UL;
   a *= 10;
   return a + b;
 }
 
-TEST_CONSTEXPR_CXX23 __uint128_t make_u128(__uint128_t a, uint64_t b, uint64_t c) {
+TEST_CONSTEXPR_CXX23 __uint128_t make_u128(__uint128_t a, std::uint64_t b, std::uint64_t c) {
   a *= 10000000000000ULL;
   a += b;
   a *= 10000000000000ULL;
   return a + c;
 }
 
-TEST_CONSTEXPR_CXX23 __int128_t make_i128(__int128_t a, int64_t b) {
+TEST_CONSTEXPR_CXX23 __int128_t make_i128(__int128_t a, std::int64_t b) {
   if (a < 0)
     return -make_u128(-a, b);
   return make_u128(a, b);
 }
 
-TEST_CONSTEXPR_CXX23 __int128_t make_i128(__int128_t a, __int128_t b, int64_t c) {
+TEST_CONSTEXPR_CXX23 __int128_t make_i128(__int128_t a, __int128_t b, std::int64_t c) {
   if (a < 0)
     return -make_u128(-a, b, c);
   return make_u128(a, b, c);
 }
 #endif
 
 template <typename T>
 struct test_basics : to_chars_test_base<T>

libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp

if (sizeof(A) > 1) {
     test_termination_condition(STR("-32768"), STR("}"), A(-32768));
     test_termination_condition(STR("32767"), STR("}"), A(32767));
   }
   if (sizeof(A) > 2) {
     test_termination_condition(STR("-2147483648"), STR("}"), A(-2147483648));
     test_termination_condition(STR("2147483647"), STR("}"), A(2147483647));
   }
   if (sizeof(A) > 4) {
-    test_termination_condition(STR("-9223372036854775808"), STR("}"), A(std::numeric_limits<int64_t>::min()));
-    test_termination_condition(STR("9223372036854775807"), STR("}"), A(std::numeric_limits<int64_t>::max()));
+    test_termination_condition(STR("-9223372036854775808"), STR("}"), A(std::numeric_limits<std::int64_t>::min()));
+    test_termination_condition(STR("9223372036854775807"), STR("}"), A(std::numeric_limits<std::int64_t>::max()));
   }
 #ifndef TEST_HAS_NO_INT128
   if (sizeof(A) > 8) {
     test_termination_condition(
         STR("-170141183460469231731687303715884105728"), STR("}"), A(std::numeric_limits<__int128_t>::min()));
     test_termination_condition(
         STR("170141183460469231731687303715884105727"), STR("}"), A(std::numeric_limits<__int128_t>::max()));
   }

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

void format_test_signed_integer(TestFunction check, ExceptionTest check_exception) {
   format_test_integer<short, CharT>(check, check_exception);
   format_test_integer<int, CharT>(check, check_exception);
   format_test_integer<long, CharT>(check, check_exception);
   format_test_integer<long long, CharT>(check, check_exception);
 #ifndef TEST_HAS_NO_INT128
   format_test_integer<__int128_t, CharT>(check, check_exception);
 #endif
   // *** check the minma and maxima ***
-  check(SV("-0b10000000"), SV("{:#b}"), std::numeric_limits<int8_t>::min());
-  check(SV("-0200"), SV("{:#o}"), std::numeric_limits<int8_t>::min());
-  check(SV("-128"), SV("{:#}"), std::numeric_limits<int8_t>::min());
-  check(SV("-0x80"), SV("{:#x}"), std::numeric_limits<int8_t>::min());
-
-  check(SV("-0b1000000000000000"), SV("{:#b}"), std::numeric_limits<int16_t>::min());
-  check(SV("-0100000"), SV("{:#o}"), std::numeric_limits<int16_t>::min());
-  check(SV("-32768"), SV("{:#}"), std::numeric_limits<int16_t>::min());
-  check(SV("-0x8000"), SV("{:#x}"), std::numeric_limits<int16_t>::min());
-
-  check(SV("-0b10000000000000000000000000000000"), SV("{:#b}"), std::numeric_limits<int32_t>::min());
-  check(SV("-020000000000"), SV("{:#o}"), std::numeric_limits<int32_t>::min());
-  check(SV("-2147483648"), SV("{:#}"), std::numeric_limits<int32_t>::min());
-  check(SV("-0x80000000"), SV("{:#x}"), std::numeric_limits<int32_t>::min());
+  check(SV("-0b10000000"), SV("{:#b}"), std::numeric_limits<std::int8_t>::min());
+  check(SV("-0200"), SV("{:#o}"), std::numeric_limits<std::int8_t>::min());
+  check(SV("-128"), SV("{:#}"), std::numeric_limits<std::int8_t>::min());
+  check(SV("-0x80"), SV("{:#x}"), std::numeric_limits<std::int8_t>::min());
+
+  check(SV("-0b1000000000000000"), SV("{:#b}"), std::numeric_limits<std::int16_t>::min());
+  check(SV("-0100000"), SV("{:#o}"), std::numeric_limits<std::int16_t>::min());
+  check(SV("-32768"), SV("{:#}"), std::numeric_limits<std::int16_t>::min());
+  check(SV("-0x8000"), SV("{:#x}"), std::numeric_limits<std::int16_t>::min());
+
+  check(SV("-0b10000000000000000000000000000000"), SV("{:#b}"), std::numeric_limits<std::int32_t>::min());
+  check(SV("-020000000000"), SV("{:#o}"), std::numeric_limits<std::int32_t>::min());
+  check(SV("-2147483648"), SV("{:#}"), std::numeric_limits<std::int32_t>::min());
+  check(SV("-0x80000000"), SV("{:#x}"), std::numeric_limits<std::int32_t>::min());
 
   check(SV("-0b1000000000000000000000000000000000000000000000000000000000000000"),
         SV("{:#b}"),
-        std::numeric_limits<int64_t>::min());
-  check(SV("-01000000000000000000000"), SV("{:#o}"), std::numeric_limits<int64_t>::min());
-  check(SV("-9223372036854775808"), SV("{:#}"), std::numeric_limits<int64_t>::min());
-  check(SV("-0x8000000000000000"), SV("{:#x}"), std::numeric_limits<int64_t>::min());
+        std::numeric_limits<std::int64_t>::min());
+  check(SV("-01000000000000000000000"), SV("{:#o}"), std::numeric_limits<std::int64_t>::min());
+  check(SV("-9223372036854775808"), SV("{:#}"), std::numeric_limits<std::int64_t>::min());
+  check(SV("-0x8000000000000000"), SV("{:#x}"), std::numeric_limits<std::int64_t>::min());
 
 #ifndef TEST_HAS_NO_INT128
   check(SV("-0b1000000000000000000000000000000000000000000000000000000000000000"
            "0000000000000000000000000000000000000000000000000000000000000000"),
         SV("{:#b}"),
         std::numeric_limits<__int128_t>::min());
   check(SV("-02000000000000000000000000000000000000000000"), SV("{:#o}"), std::numeric_limits<__int128_t>::min());
   check(SV("-170141183460469231731687303715884105728"), SV("{:#}"), std::numeric_limits<__int128_t>::min());
   check(SV("-0x80000000000000000000000000000000"), SV("{:#x}"), std::numeric_limits<__int128_t>::min());
 #endif
 
-  check(SV("0b1111111"), SV("{:#b}"), std::numeric_limits<int8_t>::max());
-  check(SV("0177"), SV("{:#o}"), std::numeric_limits<int8_t>::max());
-  check(SV("127"), SV("{:#}"), std::numeric_limits<int8_t>::max());
-  check(SV("0x7f"), SV("{:#x}"), std::numeric_limits<int8_t>::max());
-
-  check(SV("0b111111111111111"), SV("{:#b}"), std::numeric_limits<int16_t>::max());
-  check(SV("077777"), SV("{:#o}"), std::numeric_limits<int16_t>::max());
-  check(SV("32767"), SV("{:#}"), std::numeric_limits<int16_t>::max());
-  check(SV("0x7fff"), SV("{:#x}"), std::numeric_limits<int16_t>::max());
-
-  check(SV("0b1111111111111111111111111111111"), SV("{:#b}"), std::numeric_limits<int32_t>::max());
-  check(SV("017777777777"), SV("{:#o}"), std::numeric_limits<int32_t>::max());
-  check(SV("2147483647"), SV("{:#}"), std::numeric_limits<int32_t>::max());
-  check(SV("0x7fffffff"), SV("{:#x}"), std::numeric_limits<int32_t>::max());
+  check(SV("0b1111111"), SV("{:#b}"), std::numeric_limits<std::int8_t>::max());
+  check(SV("0177"), SV("{:#o}"), std::numeric_limits<std::int8_t>::max());
+  check(SV("127"), SV("{:#}"), std::numeric_limits<std::int8_t>::max());
+  check(SV("0x7f"), SV("{:#x}"), std::numeric_limits<std::int8_t>::max());
+
+  check(SV("0b111111111111111"), SV("{:#b}"), std::numeric_limits<std::int16_t>::max());
+  check(SV("077777"), SV("{:#o}"), std::numeric_limits<std::int16_t>::max());
+  check(SV("32767"), SV("{:#}"), std::numeric_limits<std::int16_t>::max());
+  check(SV("0x7fff"), SV("{:#x}"), std::numeric_limits<std::int16_t>::max());
+
+  check(SV("0b1111111111111111111111111111111"), SV("{:#b}"), std::numeric_limits<std::int32_t>::max());
+  check(SV("017777777777"), SV("{:#o}"), std::numeric_limits<std::int32_t>::max());
+  check(SV("2147483647"), SV("{:#}"), std::numeric_limits<std::int32_t>::max());
+  check(SV("0x7fffffff"), SV("{:#x}"), std::numeric_limits<std::int32_t>::max());
 
   check(SV("0b111111111111111111111111111111111111111111111111111111111111111"),
         SV("{:#b}"),
-        std::numeric_limits<int64_t>::max());
-  check(SV("0777777777777777777777"), SV("{:#o}"), std::numeric_limits<int64_t>::max());
-  check(SV("9223372036854775807"), SV("{:#}"), std::numeric_limits<int64_t>::max());
-  check(SV("0x7fffffffffffffff"), SV("{:#x}"), std::numeric_limits<int64_t>::max());
+        std::numeric_limits<std::int64_t>::max());
+  check(SV("0777777777777777777777"), SV("{:#o}"), std::numeric_limits<std::int64_t>::max());
+  check(SV("9223372036854775807"), SV("{:#}"), std::numeric_limits<std::int64_t>::max());
+  check(SV("0x7fffffffffffffff"), SV("{:#x}"), std::numeric_limits<std::int64_t>::max());
 
 #ifndef TEST_HAS_NO_INT128
   check(SV("0b111111111111111111111111111111111111111111111111111111111111111"
            "1111111111111111111111111111111111111111111111111111111111111111"),
         SV("{:#b}"),
         std::numeric_limits<__int128_t>::max());
   check(SV("01777777777777777777777777777777777777777777"), SV("{:#o}"), std::numeric_limits<__int128_t>::max());
   check(SV("170141183460469231731687303715884105727"), SV("{:#}"), std::numeric_limits<__int128_t>::max());
   check(SV("0x7fffffffffffffffffffffffffffffff"), SV("{:#x}"), std::numeric_limits<__int128_t>::max());
 #endif
 }
 
 template <class CharT, class TestFunction, class ExceptionTest>
 void format_test_unsigned_integer(TestFunction check, ExceptionTest check_exception) {
   format_test_integer<unsigned char, CharT>(check, check_exception);
   format_test_integer<unsigned short, CharT>(check, check_exception);
   format_test_integer<unsigned, CharT>(check, check_exception);
   format_test_integer<unsigned long, CharT>(check, check_exception);
   format_test_integer<unsigned long long, CharT>(check, check_exception);
 #ifndef TEST_HAS_NO_INT128
   format_test_integer<__uint128_t, CharT>(check, check_exception);
 #endif
   // *** test the maxima ***
-  check(SV("0b11111111"), SV("{:#b}"), std::numeric_limits<uint8_t>::max());
-  check(SV("0377"), SV("{:#o}"), std::numeric_limits<uint8_t>::max());
-  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("0b11111111"), SV("{:#b}"), std::numeric_limits<std::uint8_t>::max());
+  check(SV("0377"), SV("{:#o}"), std::numeric_limits<std::uint8_t>::max());
+  check(SV("255"), SV("{:#}"), std::numeric_limits<std::uint8_t>::max());
+  check(SV("0xff"), SV("{:#x}"), std::numeric_limits<std::uint8_t>::max());
+
+  check(SV("0b1111111111111111"), SV("{:#b}"), std::numeric_limits<std::uint16_t>::max());
+  check(SV("0177777"), SV("{:#o}"), std::numeric_limits<std::uint16_t>::max());
+  check(SV("65535"), SV("{:#}"), std::numeric_limits<std::uint16_t>::max());
+  check(SV("0xffff"), SV("{:#x}"), std::numeric_limits<std::uint16_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());
+        std::numeric_limits<std::uint64_t>::max());
+  check(SV("01777777777777777777777"), SV("{:#o}"), std::numeric_limits<std::uint64_t>::max());
+  check(SV("18446744073709551615"), SV("{:#}"), std::numeric_limits<std::uint64_t>::max());
+  check(SV("0xffffffffffffffff"), SV("{:#x}"), std::numeric_limits<std::uint64_t>::max());
 
 #ifndef TEST_HAS_NO_INT128
   check(SV("0b1111111111111111111111111111111111111111111111111111111111111111"
            "1111111111111111111111111111111111111111111111111111111111111111"),
         SV("{:#b}"),
         std::numeric_limits<__uint128_t>::max());
   check(SV("03777777777777777777777777777777777777777777"), SV("{:#o}"), std::numeric_limits<__uint128_t>::max());
   check(SV("340282366920938463463374607431768211455"), SV("{:#}"), std::numeric_limits<__uint128_t>::max());

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

 #include <cassert>
 #include <type_traits>
 #include <limits>
 
 enum class Colors { red, orange, yellow, green, blue, indigo, violet };
 enum class Cardinals { zero, one, two, three, five=5 };
 enum class LongColors : short { red, orange, yellow, green, blue, indigo, violet };
 enum class ShortColors : long { red, orange, yellow, green, blue, indigo, violet };
-enum class EightBitColors : uint8_t { red, orange, yellow, green, blue, indigo, violet };
+enum class EightBitColors : std::uint8_t { red, orange, yellow, green, blue, indigo, violet };
 
 enum Fruits { apple, pear, grape, mango, cantaloupe };
 
 template <class T>
 void
 test()
 {
     typedef std::hash<T> H;

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

#endif
     test<unsigned long>();
     test<long long>();
     test<unsigned long long>();
 
 //  LWG #2119
     test<std::ptrdiff_t>();
     test<size_t>();
 
-    test<int8_t>();
-    test<int16_t>();
-    test<int32_t>();
-    test<int64_t>();
-
-    test<int_fast8_t>();
-    test<int_fast16_t>();
-    test<int_fast32_t>();
-    test<int_fast64_t>();
-
-    test<int_least8_t>();
-    test<int_least16_t>();
-    test<int_least32_t>();
-    test<int_least64_t>();
+    test<std::int8_t>();
+    test<std::int16_t>();
+    test<std::int32_t>();
+    test<std::int64_t>();
+
+    test<std::int_fast8_t>();
+    test<std::int_fast16_t>();
+    test<std::int_fast32_t>();
+    test<std::int_fast64_t>();
+
+    test<std::int_least8_t>();
+    test<std::int_least16_t>();
+    test<std::int_least32_t>();
+    test<std::int_least64_t>();
 
     test<intmax_t>();
     test<intptr_t>();
 
-    test<uint8_t>();
-    test<uint16_t>();
+    test<std::uint8_t>();
+    test<std::uint16_t>();
     test<std::uint32_t>();
-    test<uint64_t>();
+    test<std::uint64_t>();
 
-    test<uint_fast8_t>();
-    test<uint_fast16_t>();
-    test<uint_fast32_t>();
-    test<uint_fast64_t>();
-
-    test<uint_least8_t>();
-    test<uint_least16_t>();
-    test<uint_least32_t>();
-    test<uint_least64_t>();
+    test<std::uint_fast8_t>();
+    test<std::uint_fast16_t>();
+    test<std::uint_fast32_t>();
+    test<std::uint_fast64_t>();
+
+    test<std::uint_least8_t>();
+    test<std::uint_least16_t>();
+    test<std::uint_least32_t>();
+    test<std::uint_least64_t>();
 
     test<uintmax_t>();
     test<uintptr_t>();
 
 #ifndef TEST_HAS_NO_INT128
     test<__int128_t>();
     test<__uint128_t>();
 #endif
 
   return 0;
 }

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

constexpr void test_in_range1() {
   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));
 }
 
 constexpr void test_in_range() {
-  constexpr Tuple<uint8_t> utup8;
-  constexpr Tuple<int8_t> stup8;
-  assert(!std::in_range<int8_t>(utup8.max));
+  constexpr Tuple<std::uint8_t> utup8;
+  constexpr Tuple<std::int8_t> stup8;
+  assert(!std::in_range<std::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));
+  assert(!std::in_range<std::uint8_t>(stup8.min));
+  assert(std::in_range<std::int8_t>(utup8.mid));
+  assert(!std::in_range<std::uint8_t>(stup8.mid));
+  assert(!std::in_range<std::uint8_t>(-1));
 }
 
 template <class... Ts>
 constexpr void test1(const std::tuple<Ts...>&) {
   (test_in_range1<Ts>() , ...);
 }
 
 constexpr bool test() {

libcxx/test/support/atomic_helpers.h

void operator()() const {
     TestFunctor<long long>()();
     TestFunctor<unsigned long long>()();
     TestFunctor<wchar_t>()();
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
     TestFunctor<char8_t>()();
 #endif
     TestFunctor<char16_t>()();
     TestFunctor<char32_t>()();
-    TestFunctor<int8_t>()();
-    TestFunctor<uint8_t>()();
-    TestFunctor<int16_t>()();
-    TestFunctor<uint16_t>()();
-    TestFunctor<int32_t>()();
+    TestFunctor<std::int8_t>()();
+    TestFunctor<std::uint8_t>()();
+    TestFunctor<std::int16_t>()();
+    TestFunctor<std::uint16_t>()();
+    TestFunctor<std::int32_t>()();
     TestFunctor<std::uint32_t>()();
-    TestFunctor<int64_t>()();
-    TestFunctor<uint64_t>()();
+    TestFunctor<std::int64_t>()();
+    TestFunctor<std::uint64_t>()();
   }
 };
 
 template <template <class TestArg> class TestFunctor>
 struct TestEachFloatingPointType {
   void operator()() const {
     TestFunctor<float>()();
     TestFunctor<double>()();

libcxx/test/support/filesystem_test_helper.h

inline bool space(std::string path, std::uintmax_t &capacity,
         avail = do_mult(expect.f_bavail);
         return true;
     }
 #endif
 
     // N.B. libc might define some of the foo[64] identifiers using macros from
     // foo64 -> foo or vice versa.
 #if defined(_WIN32)
-    using off64_t = int64_t;
+    using off64_t = std::int64_t;
 #elif defined(__MVS__) || defined(__LP64__)
     using off64_t = ::off_t;
 #else
     using ::off64_t;
 #endif
 
     inline FILE* fopen64(const char* pathname, const char* mode) {
         // Bionic does not distinguish between fopen and fopen64, but fopen64

libcxx/test/support/format.functions.common.h

struct context<wchar_t> {
   using type = std::wformat_context;
 };
 #endif
 
 template <class T>
 using context_t = typename context<T>::type;
 
 // A user-defined type used to test the handle formatter.
-enum class status : uint16_t { foo = 0xAAAA, bar = 0x5555, foobar = 0xAA55 };
+enum class status : std::uint16_t { foo = 0xAAAA, bar = 0x5555, foobar = 0xAA55 };
 
 // The formatter for a user-defined type used to test the handle formatter.
 template <class CharT>
 struct std::formatter<status, CharT> {
   int type = 0;
 
   constexpr auto parse(basic_format_parse_context<CharT>& parse_ctx) -> decltype(parse_ctx.begin()) {
     auto begin = parse_ctx.begin();
auto format(status s, basic_format_context<Out, CharT>& ctx) const -> decltype(ctx.out()) {
     char buffer[7];
     const char* begin = names[0];
     const char* end = names[0];
     switch (type) {
     case 0:
       begin = buffer;
       buffer[0] = '0';
       buffer[1] = 'x';
-      end = std::to_chars(&buffer[2], std::end(buffer), static_cast<uint16_t>(s), 16).ptr;
+      end = std::to_chars(&buffer[2], std::end(buffer), static_cast<std::uint16_t>(s), 16).ptr;
       buffer[6] = '\0';
       break;
 
     case 1:
       begin = buffer;
       buffer[0] = '0';
       buffer[1] = 'X';
-      end = std::to_chars(&buffer[2], std::end(buffer), static_cast<uint16_t>(s), 16).ptr;
+      end = std::to_chars(&buffer[2], std::end(buffer), static_cast<std::uint16_t>(s), 16).ptr;
       std::transform(static_cast<const char*>(&buffer[2]), end, &buffer[2], [](char c) {
         return static_cast<char>(std::toupper(c)); });
       buffer[6] = '\0';
       break;
 
     case 2:
       switch (s) {
       case status::foo: