Page MenuHomePhabricator

Please use GitHub pull requests for new patches. Avoid migrating existing patches. Phabricator shutdown timeline

Differential D96221 Diff 321994 libcxx/test/std/utilities/format/__itoa/__character_width_base_10.pass.cpp

Changeset View

Standalone View

View Options

libcxx/test/std/utilities/format/__itoa/__character_width_base_10.pass.cpp

  • This file was added.
//===----------------------------------------------------------------------===//
Lint: Lint
Inline Actions

clang-format suggested style edits found:

Lint: Lint: clang-format suggested style edits found:
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-concepts
// <__format_itoa>
//
// template <class _Tp>
// requires(_VSTD::is_integral_v<_Tp>&& _VSTD::is_unsigned_v<_Tp>)
// constexpr
// int __character_width_base_10(_Tp __value) noexcept;
// template <class _Tp>
// requires(_VSTD::is_integral_v<_Tp>&& _VSTD::is_signed_v<_Tp>)
// constexpr
// int __character_width_base_10(_Tp __value) noexcept;
#include <__format_itoa>
#include <cassert>
#include "test_macros.h"
template <class T>
// TODO FMT Use concept std::signed_integral<T>
requires(std::is_integral_v<T>&& std::is_signed_v<T>) constexpr
void test_negative() {
{
//[-1, -9)
for (T a = 1; a < 10; ++a) {
T value = a;
value = -value;
assert(std::__character_width_base_10(value) == 2);
}
}
{ // [-10, -100)
for (T a = 1; a < 10; ++a)
for (T b = 0; b < 10; ++b) {
T value = (10 * a) + b;
value = -value;
assert(std::__character_width_base_10(value) == 3);
}
}
// During constexpr evaluation the following error is triggered
// constexpr evaluation hit maximum step limit; possible infinite loop?
// Therefore only do a short test during constant evaluation.
if (std::is_constant_evaluated())
return;
[] { // [-100, -1.000)
for (T a = 1; a < 10; ++a)
for (T b = 0; b < 10; ++b)
for (T c = 0; c < 10; ++c) {
T value = (100 * a) + (10 * b) + c;
value = -value;
assert(std::__character_width_base_10(value) == 4);
if (value == -127 && std::numeric_limits<T>::digits == 7)
return; // Bail-out for int8_t.
}
}();
if (std::numeric_limits<T>::digits > 8) {
// [-1.000, -10.000)
for (T a = 1; a < 10; ++a)
for (T b = 0; b < 10; ++b)
for (T c = 0; c < 10; ++c)
for (T d = 0; d < 10; ++d) {
T value = (1000 * a) + (100 * b) + (10 * c) + d;
value = -value;
assert(std::__character_width_base_10(value) == 5);
}
}
if (std::numeric_limits<T>::digits > 8) {
[] { // [-10.000, -100.000)
for (T a = 1; a < 10; ++a)
for (T b = 0; b < 10; ++b)
for (T c = 0; c < 10; ++c)
for (T d = 0; d < 10; ++d)
for (T e = 0; e < 10; ++e) {
T value = (10000 * a) + (1000 * b) + (100 * c) + (10 * d) + e;
value = -value;
assert(std::__character_width_base_10(value) == 6);
if (value == -32767 && std::numeric_limits<T>::digits == 15)
return; // Bail-out for int16_t.
}
}();
}
if (std::numeric_limits<T>::digits > 16) {
T multiplier = -10;
for (int i = 6; i < 40; ++i, multiplier *= 10)
for (T a = 1; a < 10; ++a)
for (T b = 0; b < 10; ++b)
for (T c = 0; c < 10; ++c)
for (T d = 0; d < 10; ++d)
for (T e = 0; e < 10; ++e) {
T value = (10000 * a) + (1000 * b) + (100 * c) + (10 * d) + e;
// Validate whether the whether the maximum for a type is
// reached. Instead of testing against a huge number, just test
// the value before multiplying. Use the number of digits to
// "get" the real limit.
if (value == 21475 && i == 10 &&
std::numeric_limits<T>::digits == 31)
return; // Bail-out for int32_t.
if (value == 92234 && i == 19 &&
std::numeric_limits<T>::digits == 63)
return; // Bail-out for int64_t.
if (value == 17015 && i == 39 &&
std::numeric_limits<T>::digits == 127)
return; // Bail-out for __int128_t.
value *= multiplier;
assert(std::__character_width_base_10(value) == i + 1);
}
}
}
template <class T>
constexpr void test() {
ASSERT_NOEXCEPT(std::__character_width_base_10(T(0)));
// TODO FMT Use concept std::signed_integral<T>
if constexpr (std::is_integral_v<T> && std::is_signed_v<T>)
test_negative<T>();
{ // [0, 10)
for (T a = 0; a < 10; ++a) {
T value = a;
assert(std::__character_width_base_10(value) == 1);
}
}
{ // [10, 100)
for (T a = 1; a < 10; ++a)
for (T b = 0; b < 10; ++b) {
T value = (10 * a) + b;
assert(std::__character_width_base_10(value) == 2);
}
}
// During constexpr evaluation the following error is triggered
// constexpr evaluation hit maximum step limit; possible infinite loop?
// Therefore only do a short test during constant evaluation.
if (std::is_constant_evaluated())
return;
[] { // [100, 1.000)
for (T a = 1; a < 10; ++a)
for (T b = 0; b < 10; ++b)
for (T c = 0; c < 10; ++c) {
T value = (100 * a) + (10 * b) + c;
assert(std::__character_width_base_10(value) == 3);
if (value == 127 && std::numeric_limits<T>::digits == 7)
return; // Bail-out for int8_t.
if (value == 255 && std::numeric_limits<T>::digits == 8)
return; // Bail-out for uint8_t.
}
}();
if (std::numeric_limits<T>::digits > 8) {
// [1.000, 10.000)
for (T a = 1; a < 10; ++a)
for (T b = 0; b < 10; ++b)
for (T c = 0; c < 10; ++c)
for (T d = 0; d < 10; ++d) {
T value = (1000 * a) + (100 * b) + (10 * c) + d;
assert(std::__character_width_base_10(value) == 4);
}
}
if (std::numeric_limits<T>::digits > 8) {
[] { // [10.000, 100.000)
for (T a = 1; a < 10; ++a)
for (T b = 0; b < 10; ++b)
for (T c = 0; c < 10; ++c)
for (T d = 0; d < 10; ++d)
for (T e = 0; e < 10; ++e) {
T value = (10000 * a) + (1000 * b) + (100 * c) + (10 * d) + e;
assert(std::__character_width_base_10(value) == 5);
if (value == 32767 && std::numeric_limits<T>::digits == 15)
return; // Bail-out for int16_t.
if (value == 65535 && std::numeric_limits<T>::digits == 16)
return; // Bail-out for unt16_t.
}
}();
}
if (std::numeric_limits<T>::digits > 16) {
T multiplier = 10;
for (int i = 6; i < 40; ++i, multiplier *= 10)
for (T a = 1; a < 10; ++a)
for (T b = 0; b < 10; ++b)
for (T c = 0; c < 10; ++c)
for (T d = 0; d < 10; ++d)
for (T e = 0; e < 10; ++e) {
T value = (10000 * a) + (1000 * b) + (100 * c) + (10 * d) + e;
// Validate whether the whether the maximum for a type is
// reached. Instead of testing against a huge number, just test
// the value before multiplying. Use the number of digits to
// "get" the real limit.
if (value == 21475 && i == 10 &&
std::numeric_limits<T>::digits == 31)
return; // Bail-out for int32_t.
if (value == 42950 && i == 10 &&
std::numeric_limits<T>::digits == 32)
return; // Bail-out for unt32_t.
if (value == 92234 && i == 19 &&
std::numeric_limits<T>::digits == 63)
return; // Bail-out for int64_t.
if (value == 18447 && i == 20 &&
std::numeric_limits<T>::digits == 64)
return; // Bail-out for uint64_t.
if (value == 17015 && i == 39 &&
std::numeric_limits<T>::digits == 127)
return; // Bail-out for __int128_t.
if (value == 34029 && i == 39 &&
std::numeric_limits<T>::digits == 128)
return; // Bail-out for __uint128_t.
value *= multiplier;
assert(std::__character_width_base_10(value) == i);
}
}
}
constexpr bool test() {
test<uint8_t>();
test<uint16_t>();
test<uint32_t>();
test<uint64_t>();
#ifndef _LIBCPP_HAS_NO_INT128
test<__uint128_t>();
#endif
test<int8_t>();
test<int16_t>();
test<int32_t>();
test<int64_t>();
#ifndef _LIBCPP_HAS_NO_INT128
test<__int128_t>();
#endif
return true;
}
int main(int, char**) {
test();
static_assert(test());
return 0;
}