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/__to_chars_base_10.pass.cpp

Changeset View

Standalone View

View Options

libcxx/test/std/utilities/format/__itoa/__to_chars_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 _OutIt, class _Tp>
// requires(_VSTD::is_integral_v<_Tp>&& _VSTD::is_unsigned_v<_Tp>)
// constexpr _OutIt
// __to_chars_base_10(_OutIt __out_it, _Tp __value) noexcept
// template <class _OutIt, class _Tp>
// requires(_VSTD::is_integral_v<_Tp>&& _VSTD::is_signed_v<_Tp>)
// constexpr _OutIt
// __to_chars_base_10(_OutIt __out_it, _Tp __value) noexcept
#include <__format_itoa>
#include <cassert>
#include "test_macros.h"
template <class CharT, 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() {
CharT output[128];
// Set all characthers to '0'. The 5 starting at the second character will
// change during the tests, the otherw will remain the same.
std::array<CharT, 128> expected;
std::fill(expected.begin(), expected.end(), CharT('0'));
expected[0] = CharT('-');
for (T a = 1; a < 10; ++a) { //[-1, -9)
expected[1] = CharT('0' + a);
T value = a;
value = -value;
auto it = std::__to_chars_base_10(output, value);
assert(it == output + 2);
assert((std::equal(output, it, expected.begin())));
}
for (T a = 1; a < 10; ++a) { // [-10, -100)
expected[1] = CharT('0' + a);
for (T b = 0; b < 10; ++b) {
expected[2] = CharT('0' + b);
T value = (10 * a) + b;
value = -value;
auto it = std::__to_chars_base_10(output, value);
assert(it == output + 3);
assert((std::equal(output, it, expected.begin())));
}
}
// 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;
for (T a = 1; a < 10; ++a) { // [-100, -1.000)
expected[1] = CharT('0' + a);
for (T b = 0; b < 10; ++b) {
expected[2] = CharT('0' + b);
for (T c = 0; c < 10; ++c) {
expected[3] = CharT('0' + c);
T value = (100 * a) + (10 * b) + c;
value = -value;
auto it = std::__to_chars_base_10(output, value);
assert(it == output + 4);
assert((std::equal(output, it, expected.begin())));
if (value == -127 && std::numeric_limits<T>::digits == 7)
return; // Bail-out for int8_t.
}
}
}
for (T a = 1; a < 10; ++a) { // [-1.000, -10.000)
expected[1] = CharT('0' + a);
for (T b = 0; b < 10; ++b) {
expected[2] = CharT('0' + b);
for (T c = 0; c < 10; ++c) {
expected[3] = CharT('0' + c);
for (T d = 0; d < 10; ++d) {
expected[4] = CharT('0' + d);
T value = (1000 * a) + (100 * b) + (10 * c) + d;
value = -value;
auto it = std::__to_chars_base_10(output, value);
assert(it == output + 5);
assert((std::equal(output, it, expected.begin())));
if (value == -127 && std::numeric_limits<T>::digits == 7)
return; // Bail-out for int8_t.
}
}
}
}
for (T a = 1; a < 10; ++a) { // [-10.000, -100.000)
expected[1] = CharT('0' + a);
for (T b = 0; b < 10; ++b) {
expected[2] = CharT('0' + b);
for (T c = 0; c < 10; ++c) {
expected[3] = CharT('0' + c);
for (T d = 0; d < 10; ++d) {
expected[4] = CharT('0' + d);
for (T e = 0; e < 10; ++e) {
expected[5] = CharT('0' + e);
T value = (10000 * a) + (1000 * b) + (100 * c) + (10 * d) + e;
value = -value;
auto it = std::__to_chars_base_10(output, value);
assert(it == output + 6);
assert((std::equal(output, it, expected.begin())));
if (value == -32767 && std::numeric_limits<T>::digits == 15)
return; // Bail-out for int16_t.
}
}
}
}
}
T multiplier = -10;
for (size_t i = 6; i < 40; ++i, multiplier *= 10) {
for (T a = 1; a < 10; ++a) {
expected[1] = CharT('0' + a);
for (T b = 0; b < 10; ++b) {
expected[2] = CharT('0' + b);
for (T c = 0; c < 10; ++c) {
expected[3] = CharT('0' + c);
for (T d = 0; d < 10; ++d) {
expected[4] = CharT('0' + d);
for (T e = 0; e < 10; ++e) {
expected[5] = CharT('0' + 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;
auto it = std::__to_chars_base_10(output, value);
assert(it == output + i + 1);
assert((std::equal(output, it, expected.begin())));
}
}
}
}
}
}
}
template <class CharT, class T>
constexpr void test() {
{
CharT* ptr = nullptr;
T value = 0;
ASSERT_NOEXCEPT((std::__to_chars_base_10(ptr, value)));
// TODO FMT Remove if statement once std::string can be constexpr.
if (!std::is_constant_evaluated()) {
std::basic_string<CharT> str;
ASSERT_NOT_NOEXCEPT(
(std::__to_chars_base_10(std::back_inserter(str), value)));
}
}
// TODO FMT Use concept std::signed_integral<T>
if constexpr (std::is_integral_v<T> && std::is_signed_v<T>)
test_negative<CharT, T>();
CharT output[128];
// Set all characthers to '0', the first 5 will change during the tests the
// others will remain '0'.
std::array<CharT, 128> expected;
std::fill(expected.begin(), expected.end(), CharT('0'));
for (T a = 0; a < 10; ++a) { // [0, 10)
expected[0] = CharT('0' + a);
T value = a;
auto it = std::__to_chars_base_10(output, value);
assert(it == output + 1);
assert((std::equal(output, it, expected.begin())));
}
for (T a = 1; a < 10; ++a) { // [10, 100)
expected[0] = CharT('0' + a);
for (T b = 0; b < 10; ++b) {
expected[1] = CharT('0' + b);
T value = (10 * a) + b;
auto it = std::__to_chars_base_10(output, value);
assert(it == output + 2);
assert((std::equal(output, it, expected.begin())));
}
}
// 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;
for (T a = 1; a < 10; ++a) { // [100, 1.000)
expected[0] = CharT('0' + a);
for (T b = 0; b < 10; ++b) {
expected[1] = CharT('0' + b);
for (T c = 0; c < 10; ++c) {
expected[2] = CharT('0' + c);
T value = (100 * a) + (10 * b) + c;
auto it = std::__to_chars_base_10(output, value);
assert(it == output + 3);
assert((std::equal(output, it, expected.begin())));
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.
}
}
}
for (T a = 1; a < 10; ++a) { // [1.000, 10.000)
expected[0] = CharT('0' + a);
for (T b = 0; b < 10; ++b) {
expected[1] = CharT('0' + b);
for (T c = 0; c < 10; ++c) {
expected[2] = CharT('0' + c);
for (T d = 0; d < 10; ++d) {
expected[3] = CharT('0' + d);
T value = (1000 * a) + (100 * b) + (10 * c) + d;
auto it = std::__to_chars_base_10(output, value);
assert(it == output + 4);
assert((std::equal(output, it, expected.begin())));
}
}
}
}
for (T a = 1; a < 10; ++a) { // [10.000, 100.000)
expected[0] = CharT('0' + a);
for (T b = 0; b < 10; ++b) {
expected[1] = CharT('0' + b);
for (T c = 0; c < 10; ++c) {
expected[2] = CharT('0' + c);
for (T d = 0; d < 10; ++d) {
expected[3] = CharT('0' + d);
for (T e = 0; e < 10; ++e) {
expected[4] = CharT('0' + e);
T value = (10000 * a) + (1000 * b) + (100 * c) + (10 * d) + e;
auto it = std::__to_chars_base_10(output, value);
assert(it == output + 5);
assert((std::equal(output, it, expected.begin())));
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.
}
}
}
}
}
T multiplier = 10;
for (size_t i = 6; i < 40; ++i, multiplier *= 10) {
for (T a = 1; a < 10; ++a) {
expected[0] = CharT('0' + a);
for (T b = 0; b < 10; ++b) {
expected[1] = CharT('0' + b);
for (T c = 0; c < 10; ++c) {
expected[2] = CharT('0' + c);
for (T d = 0; d < 10; ++d) {
expected[3] = CharT('0' + d);
for (T e = 0; e < 10; ++e) {
expected[4] = CharT('0' + 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;
auto it = std::__to_chars_base_10(output, value);
assert(it == output + i);
assert(std::equal(output, it, expected.begin()));
}
}
}
}
}
}
}
template <class CharT>
constexpr void test() {
test<CharT, uint8_t>();
test<CharT, uint16_t>();
test<CharT, uint32_t>();
test<CharT, uint64_t>();
#ifndef _LIBCPP_HAS_NO_INT128
test<CharT, __uint128_t>();
#endif
test<CharT, int8_t>();
test<CharT, int16_t>();
test<CharT, int32_t>();
test<CharT, int64_t>();
#ifndef _LIBCPP_HAS_NO_INT128
test<CharT, __int128_t>();
#endif
}
constexpr bool test() {
test<char>();
test<wchar_t>();
#ifndef _LIBCPP_NO_HAS_CHAR8_T
test<char8_t>();
#endif
#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
test<char16_t>();
test<char32_t>();
#endif
return true;
}
int main(int, char**) {
test();
static_assert(test());
return 0;
}