================ @@ -0,0 +1,458 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23 +// The test uses "Placeholder variables with no name" +// UNSUPPORTED: clang-17 +// XFAIL: apple-clang + +// <numeric> + +// template<class R, class T> +// constexpr R saturate_cast(T x) noexcept; // freestanding + +#include <cassert> +#include <concepts> +#include <limits> +#include <numeric> + +#include "test_macros.h" + +// Smaller to larger +static_assert(noexcept(std::saturate_cast<signed int>(std::numeric_limits<signed char>::max()))); +static_assert(noexcept(std::saturate_cast<signed int>(std::numeric_limits<unsigned char>::max()))); + +static_assert(noexcept(std::saturate_cast<unsigned int>(std::numeric_limits<signed char>::max()))); +static_assert(noexcept(std::saturate_cast<unsigned int>(std::numeric_limits<unsigned char>::max()))); + +// Same type +static_assert(noexcept(std::saturate_cast<signed long int>(std::numeric_limits<signed long int>::max()))); +static_assert(noexcept(std::saturate_cast<unsigned long int>(std::numeric_limits<unsigned long int>::max()))); + +// Larger to smaller +static_assert(noexcept(std::saturate_cast<signed char>(std::numeric_limits<signed int>::max()))); +static_assert(noexcept(std::saturate_cast<signed char>(std::numeric_limits<unsigned int>::max()))); + +static_assert(noexcept(std::saturate_cast<unsigned char>(std::numeric_limits<signed int>::max()))); +static_assert(noexcept(std::saturate_cast<unsigned char>(std::numeric_limits<unsigned int>::max()))); + +template <typename IntegerT> +constexpr auto zero() { + return IntegerT{0}; +} + +constexpr bool test() { + // clang-format off + +#ifndef TEST_HAS_NO_INT128 + using SIntT = __int128_t; + using UIntT = __uint128_t; +#else + using SIntT = long long int; + using UIntT = unsigned long long int; +#endif + + // Constants: biggest numbers + + constexpr auto big_sintMin = std::numeric_limits<SIntT>::min(); + constexpr auto big_sintZero = zero<SIntT>(); + constexpr auto big_sintMax = std::numeric_limits<SIntT>::max(); + + constexpr auto big_uintMin = std::numeric_limits<UIntT>::min(); + constexpr auto big_uintZero = zero<UIntT>(); + constexpr auto big_uintMax = std::numeric_limits<UIntT>::max(); + + // Constants: numeric limits + + constexpr auto std_scharMin = std::numeric_limits<signed char>::min(); + constexpr auto std_scharZero = zero<signed char>(); + constexpr auto std_scharMax = std::numeric_limits<signed char>::max(); + + constexpr auto std_ucharMin = std::numeric_limits<unsigned char>::min(); + constexpr auto std_ucharZero = zero<unsigned char>(); + constexpr auto std_ucharMax = std::numeric_limits<unsigned char>::max(); + + constexpr auto std_ssintMin = std::numeric_limits<signed short int>::min(); + constexpr auto std_ssintZero = zero<signed short int>(); + constexpr auto std_ssintMax = std::numeric_limits<signed short int>::max(); + + constexpr auto std_usintMin = std::numeric_limits<unsigned short int>::min(); + constexpr auto std_usintZero = zero<unsigned short int>(); + constexpr auto std_usintMax = std::numeric_limits<unsigned short int>::max(); + + constexpr auto std_sintMin = std::numeric_limits<signed int>::min(); + constexpr auto std_sintZero = zero<signed int>(); + constexpr auto std_sintMax = std::numeric_limits<signed int>::max(); + + constexpr auto std_uintMin = std::numeric_limits<unsigned int>::min(); + constexpr auto std_uintZero = zero<unsigned int>(); + constexpr auto std_uintMax = std::numeric_limits<unsigned int>::max(); + + constexpr auto std_slMin = std::numeric_limits<signed long int>::min(); + constexpr auto std_slZero = zero<signed long int>(); + constexpr auto std_slMax = std::numeric_limits<signed long int>::max(); + + constexpr auto std_ulMin = std::numeric_limits<unsigned long int>::min(); + constexpr auto std_ulZero = zero<unsigned long int>(); + constexpr auto std_ulMax = std::numeric_limits<unsigned long int>::max(); + + constexpr auto std_sllMin = std::numeric_limits<signed long long int>::min(); + constexpr auto std_sllZero = zero<signed long long int>(); + constexpr auto std_sllMax = std::numeric_limits<signed long long int>::max(); + + constexpr auto std_ullMin = std::numeric_limits<unsigned long long int>::min(); + constexpr auto std_ullZero = zero<unsigned long long int>(); + constexpr auto std_ullMax = std::numeric_limits<unsigned long long int>::max(); + + // signed char + + assert(std::saturate_cast<signed char>(std_scharMin) == std_scharMin); + assert(std::saturate_cast<signed char>(std_scharZero) == std_scharZero); + assert(std::saturate_cast<signed char>(std_scharMax) == std_scharMax); + + assert(std::saturate_cast<signed char>(std_ucharMin) == std_scharZero); + assert(std::saturate_cast<signed char>(std_ucharZero) == std_scharZero); + assert(std::saturate_cast<signed char>(std_ucharMax) == std_scharMax); + + assert(std::saturate_cast<signed char>(big_sintMin) == std_scharMin); // saturated + assert(std::saturate_cast<signed char>(big_sintZero) == std_scharZero); + assert(std::saturate_cast<signed char>(big_sintMax) == std_scharMax); // saturated + + assert(std::saturate_cast<signed char>(big_uintMin) == std_scharZero); + assert(std::saturate_cast<signed char>(big_uintZero) == std_scharZero); + assert(std::saturate_cast<signed char>(big_uintMax) == std_scharMax); // saturated + + // short + + std::same_as<signed short int> decltype(auto) _ = std::saturate_cast<signed short int>(std_scharMin); + assert(std::saturate_cast<signed short int>(std_scharMin) == static_cast<signed short int>(std_scharMin)); + assert(std::saturate_cast<signed short int>(std_scharZero) == std_ssintZero); + assert(std::saturate_cast<signed short int>(std_scharMax) == static_cast<signed short int>(std_scharMax)); + + std::same_as<signed short int> decltype(auto) _ = std::saturate_cast<signed short int>(std_ucharMin); + assert(std::saturate_cast<signed short int>(std_ucharMin) == std_ssintZero); + assert(std::saturate_cast<signed short int>(std_ucharZero) == std_ssintZero); + assert(std::saturate_cast<signed short int>(std_ucharMax) == static_cast<signed short int>(std_ucharMax)); ---------------- H-G-Hristov wrote:
I want to test against the specific type, so I added constants for the missing literals. https://github.com/llvm/llvm-project/pull/77967 _______________________________________________ lldb-commits mailing list lldb-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
