[libcxx-commits] [libcxx] bd5d0fe - [libc++] Qualifies uint32_t and friends.
Mark de Wever via libcxx-commits
libcxx-commits at lists.llvm.org
Tue Mar 14 09:29:00 PDT 2023
Author: Mark de Wever
Date: 2023-03-14T17:28:53+01:00
New Revision: bd5d0fee9bbb3762ff26538f03d59926f5635c78
URL: https://github.com/llvm/llvm-project/commit/bd5d0fee9bbb3762ff26538f03d59926f5635c78
DIFF: https://github.com/llvm/llvm-project/commit/bd5d0fee9bbb3762ff26538f03d59926f5635c78.diff
LOG: [libc++] Qualifies uint32_t and friends.
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.
Reviewed By: ldionne, #libc
Differential Revision: https://reviews.llvm.org/D145880
Added:
Modified:
libcxx/test/libcxx/containers/unord/next_pow2.pass.cpp
libcxx/test/libcxx/fuzzing/random.pass.cpp
libcxx/test/libcxx/input.output/filesystems/convert_file_time.pass.cpp
libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp
libcxx/test/libcxx/strings/basic.string/alignof.compile.pass.cpp
libcxx/test/libcxx/strings/basic.string/sizeof.compile.pass.cpp
libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp
libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
libcxx/test/libcxx/utilities/format/format.arguments/format.arg/arg_t.compile.pass.cpp
libcxx/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v1.pass.cpp
libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v2.pass.cpp
libcxx/test/std/atomics/types.pass.cpp
libcxx/test/std/containers/sequences/deque/abi.compile.pass.cpp
libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
libcxx/test/std/experimental/simd/simd.access/default.pass.cpp
libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp
libcxx/test/std/experimental/simd/simd.cons/default.pass.cpp
libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp
libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp
libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp
libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp
libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
libcxx/test/std/iterators/iterator.container/ssize.pass.cpp
libcxx/test/std/language.support/support.srcloc/general.pass.cpp
libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp
libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp
libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp
libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp
libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp
libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp
libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp
libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp
libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp
libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
libcxx/test/std/numerics/bit/byteswap.pass.cpp
libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp
libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
libcxx/test/std/time/time.hms/time.hms.members/seconds.pass.cpp
libcxx/test/std/time/time.hms/time.hms.members/subseconds.pass.cpp
libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp
libcxx/test/std/utilities/charconv/charconv.msvc/floating_point_test_cases.hpp
libcxx/test/std/utilities/charconv/charconv.msvc/test.cpp
libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp
libcxx/test/std/utilities/format/format.functions/format_tests.h
libcxx/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp
libcxx/test/support/atomic_helpers.h
libcxx/test/support/filesystem_test_helper.h
libcxx/test/support/format.functions.common.h
Removed:
################################################################################
diff --git a/libcxx/test/libcxx/containers/unord/next_pow2.pass.cpp b/libcxx/test/libcxx/containers/unord/next_pow2.pass.cpp
index 5a29248741a2e..5146f41dbe49a 100644
--- a/libcxx/test/libcxx/containers/unord/next_pow2.pass.cpp
+++ b/libcxx/test/libcxx/containers/unord/next_pow2.pass.cpp
@@ -68,7 +68,7 @@ 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);
diff --git a/libcxx/test/libcxx/fuzzing/random.pass.cpp b/libcxx/test/libcxx/fuzzing/random.pass.cpp
index e7545ffdf4da2..79ab7ac41151c 100644
--- a/libcxx/test/libcxx/fuzzing/random.pass.cpp
+++ b/libcxx/test/libcxx/fuzzing/random.pass.cpp
@@ -38,7 +38,7 @@ struct ParamTypeHelper {
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);
diff --git a/libcxx/test/libcxx/input.output/filesystems/convert_file_time.pass.cpp b/libcxx/test/libcxx/input.output/filesystems/convert_file_time.pass.cpp
index 88054f3e1e7d4..b86282ccbedb5 100644
--- a/libcxx/test/libcxx/input.output/filesystems/convert_file_time.pass.cpp
+++ b/libcxx/test/libcxx/input.output/filesystems/convert_file_time.pass.cpp
@@ -280,12 +280,12 @@ 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,
@@ -295,12 +295,12 @@ int main(int, char**) {
}
#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
diff --git a/libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp b/libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp
index 7823b6e773a0a..a89a3d69476cd 100644
--- a/libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp
+++ b/libcxx/test/libcxx/numerics/numeric.ops/midpoint.integer.pass.cpp
@@ -40,10 +40,10 @@ int main(int, char**)
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>();
@@ -51,10 +51,10 @@ int main(int, char**)
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>();
diff --git a/libcxx/test/libcxx/strings/basic.string/alignof.compile.pass.cpp b/libcxx/test/libcxx/strings/basic.string/alignof.compile.pass.cpp
index d679e7a1b7e31..1613fd7b5fdaa 100644
--- a/libcxx/test/libcxx/strings/basic.string/alignof.compile.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/alignof.compile.pass.cpp
@@ -18,7 +18,7 @@
template <class T>
class small_pointer {
- uint16_t offset;
+ std::uint16_t offset;
};
template <class T>
@@ -26,8 +26,8 @@ class small_iter_allocator {
public:
using value_type = T;
using pointer = small_pointer<T>;
- using size_type = int16_t;
- using
diff erence_type = int16_t;
+ using size_type = std::int16_t;
+ using
diff erence_type = std::int16_t;
small_iter_allocator() TEST_NOEXCEPT {}
diff --git a/libcxx/test/libcxx/strings/basic.string/sizeof.compile.pass.cpp b/libcxx/test/libcxx/strings/basic.string/sizeof.compile.pass.cpp
index 9024d11c598e0..7a1835d0479f5 100644
--- a/libcxx/test/libcxx/strings/basic.string/sizeof.compile.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/sizeof.compile.pass.cpp
@@ -16,7 +16,7 @@
template <class T>
class small_pointer {
- uint16_t offset;
+ std::uint16_t offset;
};
template <class T>
@@ -24,8 +24,8 @@ class small_iter_allocator {
public:
using value_type = T;
using pointer = small_pointer<T>;
- using size_type = int16_t;
- using
diff erence_type = int16_t;
+ using size_type = std::int16_t;
+ using
diff erence_type = std::int16_t;
small_iter_allocator() TEST_NOEXCEPT {}
diff --git a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp
index 13a2301937309..2a120fb645770 100644
--- a/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp
+++ b/libcxx/test/libcxx/strings/basic.string/string.iterators/debug.iterator.index.pass.cpp
@@ -20,7 +20,7 @@
#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');
diff --git a/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp b/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
index 78402adac966b..9bbb85f2fe30c 100644
--- a/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
+++ b/libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp
@@ -71,7 +71,7 @@ constexpr void test() {
// 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>>();
@@ -81,7 +81,7 @@ constexpr void test() {
#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
@@ -89,7 +89,7 @@ constexpr void test() {
#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
@@ -97,7 +97,7 @@ constexpr void test() {
#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.
diff --git a/libcxx/test/libcxx/utilities/format/format.arguments/format.arg/arg_t.compile.pass.cpp b/libcxx/test/libcxx/utilities/format/format.arguments/format.arg/arg_t.compile.pass.cpp
index 7f21f13f702b8..2775539ac8818 100644
--- a/libcxx/test/libcxx/utilities/format/format.arguments/format.arg/arg_t.compile.pass.cpp
+++ b/libcxx/test/libcxx/utilities/format/format.arguments/format.arg/arg_t.compile.pass.cpp
@@ -18,21 +18,21 @@
#include "test_macros.h"
-static_assert(std::is_same_v<std::underlying_type_t<std::__format::__arg_t>, 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::is_same_v<std::underlying_type_t<std::__format::__arg_t>, std::uint8_t>);
+
+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);
diff --git a/libcxx/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp b/libcxx/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
index 22bfdf79d5f91..73ad7aa5d03cb 100644
--- a/libcxx/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
+++ b/libcxx/test/libcxx/utilities/function.objects/unord.hash/murmur2_or_cityhash_ubsan_unsigned_overflow_ignored.pass.cpp
@@ -18,7 +18,7 @@
#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) {
diff --git a/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v1.pass.cpp b/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v1.pass.cpp
index 3f8557adb0364..cdaaacad282ef 100644
--- a/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v1.pass.cpp
+++ b/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v1.pass.cpp
@@ -33,14 +33,14 @@ std::string CityHash[] = {
};
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);
}
diff --git a/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v2.pass.cpp b/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v2.pass.cpp
index 01f8b88c81fe7..25c0b9f177dce 100644
--- a/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v2.pass.cpp
+++ b/libcxx/test/libcxx/utilities/utility/__murmur2_or_cityhash.abi-v2.pass.cpp
@@ -32,14 +32,14 @@ std::string CityHash[] = {
};
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);
}
diff --git a/libcxx/test/std/atomics/types.pass.cpp b/libcxx/test/std/atomics/types.pass.cpp
index 869babfcfa72d..ee5cca2237745 100644
--- a/libcxx/test/std/atomics/types.pass.cpp
+++ b/libcxx/test/std/atomics/types.pass.cpp
@@ -119,32 +119,32 @@ int main(int, char**)
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> ();
diff --git a/libcxx/test/std/containers/sequences/deque/abi.compile.pass.cpp b/libcxx/test/std/containers/sequences/deque/abi.compile.pass.cpp
index 74cbfe3ffaec2..36a76b2e11d61 100644
--- a/libcxx/test/std/containers/sequences/deque/abi.compile.pass.cpp
+++ b/libcxx/test/std/containers/sequences/deque/abi.compile.pass.cpp
@@ -14,7 +14,7 @@
template <class T>
class small_pointer {
- uint16_t offset;
+ std::uint16_t offset;
};
template <class T>
@@ -22,8 +22,8 @@ class small_iter_allocator {
public:
using value_type = T;
using pointer = small_pointer<T>;
- using size_type = int16_t;
- using
diff erence_type = int16_t;
+ using size_type = std::int16_t;
+ using
diff erence_type = std::int16_t;
small_iter_allocator() TEST_NOEXCEPT {}
diff --git a/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
index ea029ebf9dad8..5d71b8a20d1a1 100644
--- a/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
@@ -190,7 +190,7 @@ TEST_CONSTEXPR_CXX20 void test_ctor_with_
diff erent_value_type() {
}
{
// Though the types are
diff erent, 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);
}
diff --git a/libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp b/libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
index 35a45381a0156..e9182760ecec2 100644
--- a/libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.abi/vector_extension.pass.cpp
@@ -42,26 +42,26 @@ 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,
"");
diff --git a/libcxx/test/std/experimental/simd/simd.access/default.pass.cpp b/libcxx/test/std/experimental/simd/simd.access/default.pass.cpp
index 2ca5ec4482bf8..a8ec36c4f615b 100644
--- a/libcxx/test/std/experimental/simd/simd.access/default.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.access/default.pass.cpp
@@ -26,7 +26,7 @@ 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);
diff --git a/libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp b/libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
index 038af4be058ce..3a58f9f770b22 100644
--- a/libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.casts/simd_cast.pass.cpp
@@ -22,26 +22,26 @@
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**) {
diff --git a/libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp b/libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp
index 77a3be678d0b7..02dd00379691d 100644
--- a/libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.cons/broadcast.pass.cpp
@@ -37,37 +37,37 @@ 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>
diff --git a/libcxx/test/std/experimental/simd/simd.cons/default.pass.cpp b/libcxx/test/std/experimental/simd/simd.cons/default.pass.cpp
index feba23ee871b9..753917e1bcbe9 100644
--- a/libcxx/test/std/experimental/simd/simd.cons/default.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.cons/default.pass.cpp
@@ -21,10 +21,10 @@
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;
diff --git a/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp b/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp
index ace829fb7597a..5049d9b0de9a0 100644
--- a/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.cons/generator.pass.cpp
@@ -53,15 +53,15 @@ void compile_generator() {
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>
@@ -84,9 +84,9 @@ void test_generator() {
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;
}
diff --git a/libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp b/libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp
index 181f170f2d4db..ff29e7150e872 100644
--- a/libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.cons/load.pass.cpp
@@ -42,7 +42,7 @@ void compile_load_ctor() {
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());
@@ -52,7 +52,7 @@ void compile_load_ctor() {
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);
@@ -110,11 +110,11 @@ void test_converting_load_ctor() {
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;
}
diff --git a/libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp b/libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp
index 266ee53bf96ab..c036d4f81db9c 100644
--- a/libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.mem/load.pass.cpp
@@ -41,7 +41,7 @@ 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());
@@ -49,7 +49,7 @@ void compile_load() {
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());
@@ -114,11 +114,11 @@ void test_converting_load() {
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;
}
diff --git a/libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp b/libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp
index d3ead6094bb55..932ecfc5faeb2 100644
--- a/libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.mem/store.pass.cpp
@@ -25,7 +25,7 @@ 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);
@@ -33,7 +33,7 @@ void test_store() {
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);
@@ -41,7 +41,7 @@ void test_store() {
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);
@@ -50,7 +50,7 @@ void test_store() {
}
{
- 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);
@@ -58,7 +58,7 @@ void test_store() {
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);
@@ -66,7 +66,7 @@ void test_store() {
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);
@@ -88,10 +88,10 @@ void test_converting_store() {
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;
}
diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
index 4a1613aeafcdb..4d0883be45160 100644
--- a/libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.traits/is_abi_tag.pass.cpp
@@ -23,25 +23,25 @@ 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, "");
@@ -66,25 +66,25 @@ 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>>, "");
diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
index f78939703f162..dc20adf37b0cd 100644
--- a/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.traits/is_simd.pass.cpp
@@ -23,47 +23,47 @@ 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, "");
@@ -74,47 +74,47 @@ 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>>, "");
diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
index 1e7b0468867e0..e174a7c4d51d8 100644
--- a/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.traits/is_simd_flag_type.pass.cpp
@@ -32,8 +32,8 @@ 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>, "");
@@ -44,8 +44,8 @@ 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;
diff --git a/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp b/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
index db869ab205e17..b9d6cf84ea401 100644
--- a/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
+++ b/libcxx/test/std/experimental/simd/simd.traits/is_simd_mask.pass.cpp
@@ -23,68 +23,68 @@ 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,
@@ -97,47 +97,47 @@ 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>>, "");
diff --git a/libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp b/libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
index 51546f33a4f28..21d08f44bc47e 100644
--- a/libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
+++ b/libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp
@@ -51,8 +51,8 @@ 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;
@@ -60,7 +60,7 @@ struct StatT {
};
// 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;
diff --git a/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp b/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
index 126151221aa4b..3f522389ed065 100644
--- a/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
+++ b/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minmax_showbase.pass.cpp
@@ -67,9 +67,9 @@ int main(int, char**)
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");
diff --git a/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp b/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
index fcb250537aac9..1f3003a0945d7 100644
--- a/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
+++ b/libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/minus1.pass.cpp
@@ -63,16 +63,16 @@ void test_hex(const char *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");
@@ -83,12 +83,12 @@ int main(int, char**)
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");
@@ -98,12 +98,12 @@ int main(int, char**)
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");
diff --git a/libcxx/test/std/iterators/iterator.container/ssize.pass.cpp b/libcxx/test/std/iterators/iterator.container/ssize.pass.cpp
index a424ebbf4a52a..779e9ed8aa9dc 100644
--- a/libcxx/test/std/iterators/iterator.container/ssize.pass.cpp
+++ b/libcxx/test/std/iterators/iterator.container/ssize.pass.cpp
@@ -30,7 +30,7 @@
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>
diff --git a/libcxx/test/std/language.support/support.srcloc/general.pass.cpp b/libcxx/test/std/language.support/support.srcloc/general.pass.cpp
index 39ad936628ee3..70861ee351973 100644
--- a/libcxx/test/std/language.support/support.srcloc/general.pass.cpp
+++ b/libcxx/test/std/language.support/support.srcloc/general.pass.cpp
@@ -43,8 +43,8 @@ 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();
diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp
index e3524589c563c..c768d0fa9de26 100644
--- a/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.fail.cpp
@@ -39,10 +39,10 @@ int main(int, char**)
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}}
diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp
index 9d37ab223ed83..7aa1265838dbb 100644
--- a/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/bit_ceil.pass.cpp
@@ -84,10 +84,10 @@ int main(int, char**)
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, ptr
diff _t>);
@@ -115,10 +115,10 @@ int main(int, char**)
#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>());
@@ -131,10 +131,10 @@ int main(int, char**)
#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>();
diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp
index b795c2723e4a4..7b8d67c6152f0 100644
--- a/libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/bit_floor.pass.cpp
@@ -81,10 +81,10 @@ int main(int, char**)
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, ptr
diff _t>);
@@ -113,10 +113,10 @@ int main(int, char**)
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>());
@@ -130,10 +130,10 @@ int main(int, char**)
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>();
diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp
index c16a6cb047436..899d272f56d7c 100644
--- a/libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/bit_width.pass.cpp
@@ -86,10 +86,10 @@ int main(int, char**)
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, ptr
diff _t>);
@@ -117,10 +117,10 @@ int main(int, char**)
#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>());
@@ -133,10 +133,10 @@ int main(int, char**)
#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>();
diff --git a/libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp b/libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp
index bccc28af3b876..2c33bda72982c 100644
--- a/libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bit.pow.two/has_single_bit.pass.cpp
@@ -84,10 +84,10 @@ int main(int, char**)
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, ptr
diff _t>);
@@ -115,10 +115,10 @@ int main(int, char**)
#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>());
@@ -131,10 +131,10 @@ int main(int, char**)
#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>();
diff --git a/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp
index 220494bec02e6..f9def0a4d3407 100644
--- a/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countl_one.pass.cpp
@@ -81,10 +81,10 @@ int main(int, char**)
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, ptr
diff _t>);
@@ -112,10 +112,10 @@ int main(int, char**)
#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>());
@@ -128,10 +128,10 @@ int main(int, char**)
#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>();
diff --git a/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp
index 60d3a7e6bb078..b76731eeb0469 100644
--- a/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countl_zero.pass.cpp
@@ -80,10 +80,10 @@ int main(int, char**)
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, ptr
diff _t>);
@@ -111,10 +111,10 @@ int main(int, char**)
#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>());
@@ -127,10 +127,10 @@ int main(int, char**)
#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>();
diff --git a/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp
index 2d25c0ad5fe37..c1a9a4a0ebb5f 100644
--- a/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countr_one.pass.cpp
@@ -85,10 +85,10 @@ int main(int, char**)
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, ptr
diff _t>);
@@ -116,10 +116,10 @@ int main(int, char**)
#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>());
@@ -132,10 +132,10 @@ int main(int, char**)
#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>();
diff --git a/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp
index 176fa771f1238..639144309454c 100644
--- a/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/countr_zero.pass.cpp
@@ -82,10 +82,10 @@ int main(int, char**)
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, ptr
diff _t>);
@@ -113,10 +113,10 @@ int main(int, char**)
#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>());
@@ -129,10 +129,10 @@ int main(int, char**)
#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>();
diff --git a/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp b/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
index 2d2fca930b27f..6b996ed5177a9 100644
--- a/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.count/popcount.pass.cpp
@@ -92,10 +92,10 @@ int main(int, char**)
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, ptr
diff _t>);
@@ -123,10 +123,10 @@ int main(int, char**)
#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>());
@@ -139,10 +139,10 @@ int main(int, char**)
#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>();
diff --git a/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp b/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
index 5599bd7f8c295..34859ae922197 100644
--- a/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.rot/rotl.pass.cpp
@@ -80,10 +80,10 @@ int main(int, char**)
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, ptr
diff _t>);
@@ -112,10 +112,10 @@ int main(int, char**)
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>());
@@ -129,10 +129,10 @@ int main(int, char**)
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>();
diff --git a/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp b/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
index 293144c1538a0..a6851e72a5ad6 100644
--- a/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
+++ b/libcxx/test/std/numerics/bit/bitops.rot/rotr.pass.cpp
@@ -81,10 +81,10 @@ int main(int, char**)
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, ptr
diff _t>);
@@ -113,10 +113,10 @@ int main(int, char**)
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>());
@@ -130,10 +130,10 @@ int main(int, char**)
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>();
diff --git a/libcxx/test/std/numerics/bit/byteswap.pass.cpp b/libcxx/test/std/numerics/bit/byteswap.pass.cpp
index b507d0f51cb46..b87faf150177f 100644
--- a/libcxx/test/std/numerics/bit/byteswap.pass.cpp
+++ b/libcxx/test/std/numerics/bit/byteswap.pass.cpp
@@ -54,15 +54,15 @@ constexpr void test_implementation_defined_size() {
}
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;
diff --git a/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp b/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp
index 069ddf55a6b8e..1862045a4ec90 100644
--- a/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp
+++ b/libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp
@@ -115,10 +115,10 @@ int main(int, char**)
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>();
@@ -126,10 +126,10 @@ int main(int, char**)
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>();
diff --git a/libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp b/libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
index a9a1a8fda5dab..dbdd097241194 100644
--- a/libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
+++ b/libcxx/test/std/numerics/rand/rand.dist/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
@@ -529,8 +529,8 @@ int main(int, char**) {
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>();
diff --git a/libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp b/libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
index 4403c6cdbea6a..578a66c7c1c0c 100644
--- a/libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
+++ b/libcxx/test/std/numerics/rand/rand.dist/rand.dist.samp/rand.dist.samp.discrete/eval.pass.cpp
@@ -306,8 +306,8 @@ int main(int, char**) {
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>();
diff --git a/libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp b/libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
index 15270cc2b8cd1..669f90d5292df 100644
--- a/libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
+++ b/libcxx/test/std/numerics/rand/rand.dist/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
@@ -124,8 +124,8 @@ int main(int, char**)
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>();
diff --git a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
index a8140566f07af..02df0345525cb 100644
--- a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
+++ b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
@@ -267,8 +267,8 @@ 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;
}
diff --git a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
index 291dbf70ff1e1..3c7ab48c8db0d 100644
--- a/libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
+++ b/libcxx/test/std/numerics/rand/rand.eng/rand.eng.sub/ctor_result_type.pass.cpp
@@ -76,8 +76,8 @@ int main(int, char**)
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;
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
index 83b8d8a1147a6..cf74053136474 100644
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_append/iterator.pass.cpp
@@ -154,7 +154,7 @@ TEST_CONSTEXPR_CXX20 bool test() {
{ // test appending a
diff erent type
typedef std::string S;
- const uint8_t p[] = "ABCD";
+ const std::uint8_t p[] = "ABCD";
S s;
s.append(p, p + 4);
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
index 3b8d0dcc0a6b0..9af2f12bdb308 100644
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_assign/iterator.pass.cpp
@@ -155,7 +155,7 @@ TEST_CONSTEXPR_CXX20 bool test() {
{ // test assigning a
diff erent type
typedef std::string S;
- const uint8_t p[] = "ABCD";
+ const std::uint8_t p[] = "ABCD";
S s;
s.assign(p, p + 4);
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
index fb32892d10ada..d7f3ca3c4d4ca 100644
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp
@@ -145,7 +145,7 @@ TEST_CONSTEXPR_CXX20 bool test() {
{ // test assigning a
diff erent 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);
diff --git a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
index 5a1282cb0c097..c70a43e2ca81e 100644
--- a/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
+++ b/libcxx/test/std/strings/basic.string/string.modifiers/string_replace/iter_iter_iter_iter.pass.cpp
@@ -1028,8 +1028,8 @@ TEST_CONSTEXPR_CXX20 bool test9() {
}
{ // test assigning a
diff erent 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);
diff --git a/libcxx/test/std/time/time.hms/time.hms.members/seconds.pass.cpp b/libcxx/test/std/time/time.hms/time.hms.members/seconds.pass.cpp
index 7aa9f3c4a1035..f0723be01a74c 100644
--- a/libcxx/test/std/time/time.hms/time.hms.members/seconds.pass.cpp
+++ b/libcxx/test/std/time/time.hms/time.hms.members/seconds.pass.cpp
@@ -24,7 +24,7 @@
#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()));
diff --git a/libcxx/test/std/time/time.hms/time.hms.members/subseconds.pass.cpp b/libcxx/test/std/time/time.hms/time.hms.members/subseconds.pass.cpp
index b3b46a974d4b3..6504d19c48358 100644
--- a/libcxx/test/std/time/time.hms/time.hms.members/subseconds.pass.cpp
+++ b/libcxx/test/std/time/time.hms/time.hms.members/subseconds.pass.cpp
@@ -24,7 +24,7 @@
#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()));
diff --git a/libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp b/libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp
index 8814fa316337a..1bbe72a8e285e 100644
--- a/libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp
+++ b/libcxx/test/std/time/time.syn/formatter.hh_mm_ss.pass.cpp
@@ -149,7 +149,7 @@ static void test_valid_values() {
"%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.
@@ -260,7 +260,7 @@ static void test_valid_values() {
"%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"
@@ -379,7 +379,7 @@ static void test_valid_values() {
# 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"
@@ -466,7 +466,7 @@ static void test_valid_values() {
"%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"
diff --git a/libcxx/test/std/utilities/charconv/charconv.msvc/floating_point_test_cases.hpp b/libcxx/test/std/utilities/charconv/charconv.msvc/floating_point_test_cases.hpp
index c152e65bf405c..5ea71438c01cc 100644
--- a/libcxx/test/std/utilities/charconv/charconv.msvc/floating_point_test_cases.hpp
+++ b/libcxx/test/std/utilities/charconv/charconv.msvc/floating_point_test_cases.hpp
@@ -7,7 +7,7 @@
#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},
diff --git a/libcxx/test/std/utilities/charconv/charconv.msvc/test.cpp b/libcxx/test/std/utilities/charconv/charconv.msvc/test.cpp
index d90525c4dd16c..38ff3d8f29a62 100644
--- a/libcxx/test/std/utilities/charconv/charconv.msvc/test.cpp
+++ b/libcxx/test/std/utilities/charconv/charconv.msvc/test.cpp
@@ -187,12 +187,12 @@ constexpr const char* output_max_digit[] = {"skip0", "skip1", "11", "12", "13",
"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",
@@ -204,7 +204,7 @@ constexpr pair<uint64_t, array<const char*, 37>> output_positive[] = {
{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"}}},
@@ -221,7 +221,7 @@ constexpr pair<uint64_t, array<const char*, 37>> output_positive[] = {
"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",
@@ -247,7 +247,7 @@ constexpr pair<uint64_t, array<const char*, 37>> output_positive[] = {
"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",
@@ -290,8 +290,8 @@ constexpr pair<uint64_t, array<const char*, 37>> output_positive[] = {
};
// 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"}}},
@@ -360,7 +360,7 @@ void test_integer_to_chars() {
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)]);
}
}
@@ -369,7 +369,7 @@ void test_integer_to_chars() {
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)]);
}
}
@@ -402,7 +402,7 @@ void test_from_chars(const string_view input, const BaseOrFmt base_or_fmt, const
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 {
@@ -553,7 +553,7 @@ void assert_message_bits(const bool b, const char* const msg, const std::uint32_
}
}
-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));
@@ -570,7 +570,7 @@ 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.");
@@ -581,9 +581,9 @@ constexpr std::uint32_t PrefixLimit = 2 // sign bit
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"
@@ -643,9 +643,9 @@ void test_floating_prefix(const conditional_t<IsDouble, uint64_t, std::uint32_t>
}
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.
@@ -681,9 +681,9 @@ void test_floating_hex_prefix(const conditional_t<IsDouble, uint64_t, std::uint3
}
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.)
@@ -748,10 +748,10 @@ void test_floating_precision_prefix(const conditional_t<IsDouble, uint64_t, std:
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);
diff --git a/libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp b/libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
index 4bdb8ca084716..3fc5670593058 100644
--- a/libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
+++ b/libcxx/test/std/utilities/charconv/charconv.to.chars/integral.pass.cpp
@@ -23,26 +23,26 @@
#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);
diff --git a/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp b/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp
index 9625c5bf55681..1bec16279948d 100644
--- a/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp
+++ b/libcxx/test/std/utilities/format/format.formatter/format.formatter.spec/formatter.signed_integral.pass.cpp
@@ -88,8 +88,8 @@ void test_signed_integral_type() {
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) {
diff --git a/libcxx/test/std/utilities/format/format.functions/format_tests.h b/libcxx/test/std/utilities/format/format.functions/format_tests.h
index 2561c472bb1bf..0337d4c9767c1 100644
--- a/libcxx/test/std/utilities/format/format.functions/format_tests.h
+++ b/libcxx/test/std/utilities/format/format.functions/format_tests.h
@@ -663,27 +663,27 @@ void format_test_signed_integer(TestFunction check, ExceptionTest check_exceptio
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("-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<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("-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<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("-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"
@@ -695,27 +695,27 @@ void format_test_signed_integer(TestFunction check, ExceptionTest check_exceptio
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("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<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("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<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("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"
@@ -739,15 +739,15 @@ void format_test_unsigned_integer(TestFunction check, ExceptionTest check_except
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("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<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("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());
@@ -756,10 +756,10 @@ void format_test_unsigned_integer(TestFunction check, ExceptionTest check_except
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"
diff --git a/libcxx/test/std/utilities/function.objects/unord.hash/enum.pass.cpp b/libcxx/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
index 6dd14dc77496a..54e9f25275cf2 100644
--- a/libcxx/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/unord.hash/enum.pass.cpp
@@ -23,7 +23,7 @@ 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 };
diff --git a/libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp b/libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
index 78236706c9518..622a99cf0b4e8 100644
--- a/libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
+++ b/libcxx/test/std/utilities/function.objects/unord.hash/integral.pass.cpp
@@ -74,38 +74,38 @@ int main(int, char**)
test<std::ptr
diff _t>();
test<size_t>();
- 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<int_fast8_t>();
- test<int_fast16_t>();
- test<int_fast32_t>();
- test<int_fast64_t>();
+ test<std::int_fast8_t>();
+ test<std::int_fast16_t>();
+ test<std::int_fast32_t>();
+ test<std::int_fast64_t>();
- test<int_least8_t>();
- test<int_least16_t>();
- test<int_least32_t>();
- test<int_least64_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<std::uint_fast8_t>();
+ test<std::uint_fast16_t>();
+ test<std::uint_fast32_t>();
+ test<std::uint_fast64_t>();
- test<uint_least8_t>();
- test<uint_least16_t>();
- test<uint_least32_t>();
- test<uint_least64_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>();
diff --git a/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp
index 1efa3d965a7f3..847cee2532581 100644
--- a/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp
+++ b/libcxx/test/std/utilities/utility/utility.intcmp/intcmp.in_range/in_range.pass.cpp
@@ -47,14 +47,14 @@ constexpr void test_in_range1() {
}
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>
diff --git a/libcxx/test/support/atomic_helpers.h b/libcxx/test/support/atomic_helpers.h
index 9bc77c9979b1e..8add02d946b3f 100644
--- a/libcxx/test/support/atomic_helpers.h
+++ b/libcxx/test/support/atomic_helpers.h
@@ -84,14 +84,14 @@ struct TestEachIntegralType {
#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>()();
}
};
diff --git a/libcxx/test/support/filesystem_test_helper.h b/libcxx/test/support/filesystem_test_helper.h
index 4a352c7b6ac76..766a973c23720 100644
--- a/libcxx/test/support/filesystem_test_helper.h
+++ b/libcxx/test/support/filesystem_test_helper.h
@@ -102,7 +102,7 @@ namespace utils {
// 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
diff --git a/libcxx/test/support/format.functions.common.h b/libcxx/test/support/format.functions.common.h
index 81ed04998a510..e70ae34200573 100644
--- a/libcxx/test/support/format.functions.common.h
+++ b/libcxx/test/support/format.functions.common.h
@@ -44,7 +44,7 @@ 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>
@@ -90,7 +90,7 @@ struct std::formatter<status, CharT> {
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;
@@ -98,7 +98,7 @@ struct std::formatter<status, CharT> {
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';
More information about the libcxx-commits
mailing list