// Copyright (c) Microsoft Corporation.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#include "test.hpp"
#include <algorithm>
#include <array>
#include <assert.h>
#include <charconv>
#include <chrono>
#include <cmath>
#include <functional>
#include <iterator>
#include <limits>
#include <locale>
#include <optional>
#include <random>
#include <set>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <string_view>
#include <system_error>
#include <type_traits>
#include <utility>
#include <vector>
#include "double_fixed_precision_to_chars_test_cases_1.hpp"
#include "double_fixed_precision_to_chars_test_cases_2.hpp"
#include "double_fixed_precision_to_chars_test_cases_3.hpp"
#include "double_fixed_precision_to_chars_test_cases_4.hpp"
#include "double_from_chars_test_cases.hpp"
#include "double_general_precision_to_chars_test_cases.hpp"
#include "double_hex_precision_to_chars_test_cases.hpp"
#include "double_scientific_precision_to_chars_test_cases_1.hpp"
#include "double_scientific_precision_to_chars_test_cases_2.hpp"
#include "double_scientific_precision_to_chars_test_cases_3.hpp"
#include "double_scientific_precision_to_chars_test_cases_4.hpp"
#include "double_to_chars_test_cases.hpp"
#include "float_fixed_precision_to_chars_test_cases.hpp"
#include "float_from_chars_test_cases.hpp"
#include "float_general_precision_to_chars_test_cases.hpp"
#include "float_hex_precision_to_chars_test_cases.hpp"
#include "float_scientific_precision_to_chars_test_cases.hpp"
#include "float_to_chars_test_cases.hpp"
using namespace std;
void initialize_randomness(mt19937_64& mt64, const int argc, char** const /*argv*/) {
constexpr std::size_t n = mt19937_64::state_size;
constexpr std::size_t w = mt19937_64::word_size;
static_assert(w % 32 == 0);
constexpr std::size_t k = w / 32;
vector<std::uint32_t> vec(n * k);
puts("USAGE:");
puts("test.exe : generates seed data from random_device.");
if (argc == 1) {
random_device rd;
generate(vec.begin(), vec.end(), ref(rd));
puts("Generated seed data.");
} else {
puts("ERROR: Too many command-line arguments.");
abort();
}
puts("SEED DATA:");
for (const auto& elem : vec) {
printf("%zu ", static_cast<std::size_t>(elem));
}
printf("\n");
seed_seq seq(vec.cbegin(), vec.cend());
mt64.seed(seq);
puts("Successfully seeded mt64. First three values:");
for (int i = 0; i < 3; ++i) {
// libc++ uses long for 64-bit values.
printf("0x%016llX\n", static_cast<unsigned long long>(mt64()));
}
}
static_assert((chars_format::scientific & chars_format::fixed) == chars_format{});
static_assert((chars_format::scientific & chars_format::hex) == chars_format{});
static_assert((chars_format::fixed & chars_format::hex) == chars_format{});
static_assert(chars_format::general == (chars_format::fixed | chars_format::scientific));
template <typename T, typename Optional>
void test_common_to_chars(
const T value, const Optional opt_arg, const optional<int> opt_precision, const string_view correct) {
// Important: Test every effective buffer size from 0 through correct.size() and slightly beyond. For the sizes
// less than correct.size(), this verifies that the too-small buffer is correctly detected, and that we don't
// attempt to write outside of it, even by a single char. (This exhaustive validation is necessary because the
// implementation must check whenever it attempts to write. Sometimes we can calculate the total size and perform
// a single check, but sometimes we need to check when writing each part of the result.) Testing correct.size()
// verifies that we can succeed without overrunning, and testing slightly larger sizes verifies that we can succeed
// without attempting to write to extra chars even when they're available. Finally, we also verify that we aren't
// underrunning the buffer. This is a concern because sometimes we walk backwards when rounding.
constexpr std::size_t BufferPrefix = 20; // detect buffer underruns (specific value isn't important)
constexpr std::size_t Space = is_integral_v<T> ? 1 + 64 // worst case: -2^63 in binary
: is_same_v<T, float>
? 1 + 151 // worst case: negative min subnormal float, fixed notation
: 1 + 1076; // worst case: negative min subnormal double, fixed notation
constexpr std::size_t BufferSuffix = 30; // detect buffer overruns (specific value isn't important)
array<char, BufferPrefix + Space + BufferSuffix> buff;
char* const buff_begin = buff.data();
char* const first = buff_begin + BufferPrefix;
char* const buff_end = buff_begin + buff.size();
constexpr std::size_t ExtraChars = 3;
static_assert(ExtraChars + 10 < BufferSuffix,
"The specific values aren't important, but there should be plenty of room to detect buffer overruns.");
for (std::size_t n = 0; n <= correct.size() + ExtraChars; ++n) {
assert(n <= static_cast<std::size_t>(buff_end - first));
char* const last = first + n;
buff.fill('@');
const auto is_fill_char = [](const char c) { return c == '@'; };
to_chars_result result{};
if (opt_precision.has_value()) {
assert(opt_arg.has_value());
if constexpr (is_floating_point_v<T>) {
result = to_chars(first, last, value, opt_arg.value(), opt_precision.value());
} else {
abort();
}
} else if (opt_arg.has_value()) {
result = to_chars(first, last, value, opt_arg.value());
} else {
result = to_chars(first, last, value);
}
if (n < correct.size()) {
assert(result.ptr == last);
assert(result.ec == errc::value_too_large);
assert(all_of(buff_begin, first, is_fill_char));
// [first, last) is unspecified
assert(all_of(last, buff_end, is_fill_char));
} else {
assert(result.ptr == first + correct.size());
assert(result.ec == errc{});
assert(all_of(buff_begin, first, is_fill_char));
assert(equal(first, result.ptr, correct.begin(), correct.end()));
assert(all_of(result.ptr, buff_end, is_fill_char));
}
}
}
template <typename T>
void test_integer_to_chars(const T value, const optional<int> opt_base, const string_view correct) {
test_common_to_chars(value, opt_base, nullopt, correct);
{ // Also test successful from_chars() scenarios.
const char* const correct_first = correct.data();
const char* const correct_last = correct_first + correct.size();
T dest = 0;
const from_chars_result from_res =
(opt_base.has_value() ? from_chars(correct_first, correct_last, dest, opt_base.value())
: from_chars(correct_first, correct_last, dest));
assert(from_res.ptr == correct_last);
assert(from_res.ec == errc{});
assert(dest == value);
}
}
// https://www.wolframalpha.com : Table[BaseForm[n * 2 - 1, n], {n, 2, 36}]
constexpr const char* output_max_digit[] = {"skip0", "skip1", "11", "12", "13", "14", "15", "16", "17", "18", "19",
"1a", "1b", "1c", "1d", "1e", "1f", "1g", "1h", "1i", "1j", "1k", "1l", "1m", "1n", "1o", "1p", "1q", "1r", "1s",
"1t", "1u", "1v", "1w", "1x", "1y", "1z"};
// https://www.wolframalpha.com : Table[BaseForm[k, n], {k, {MEOW, MEOW, MEOW}}, {n, 2, 36}]
constexpr 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"}}},
{std::uint64_t{INT8_MAX}, {{"skip0", "skip1", "1111111", "11201", "1333", "1002", "331", "241", "177", "151", "127",
"106", "a7", "9a", "91", "87", "7f", "78", "71", "6d", "67", "61", "5h", "5c", "57", "52",
"4n", "4j", "4f", "4b", "47", "43", "3v", "3s", "3p", "3m", "3j"}}},
{161U, {{"skip0", "skip1", "10100001", "12222", "2201", "1121", "425", "320", "241", "188", "161", "137", "115",
"c5", "b7", "ab", "a1", "98", "8h", "89", "81", "7e", "77", "70", "6h", "6b", "65", "5q", "5l", "5g",
"5b", "56", "51", "4t", "4p", "4l", "4h"}}},
{UINT8_MAX, {{"skip0", "skip1", "11111111", "100110", "3333", "2010", "1103", "513", "377", "313", "255", "212",
"193", "168", "143", "120", "ff", "f0", "e3", "d8", "cf", "c3", "bd", "b2", "af", "a5", "9l", "9c",
"93", "8n", "8f", "87", "7v", "7o", "7h", "7a", "73"}}},
{1729U, {{"skip0", "skip1", "11011000001", "2101001", "123001", "23404", "12001", "5020", "3301", "2331", "1729",
"1332", "1001", "a30", "8b7", "7a4", "6c1", "5gc", "561", "4f0", "469", "3j7", "3cd", "364", "301",
"2j4", "2ed", "2a1", "25l", "21i", "1rj", "1oo", "1m1", "1jd", "1gt", "1ee", "1c1"}}},
{std::uint64_t{INT16_MAX}, {{"skip0", "skip1", "111111111111111", "1122221121", "13333333", "2022032", "411411",
"164350", "77777", "48847", "32767", "22689", "16b67", "11bb7", "bd27", "9a97", "7fff",
"6b68", "5b27", "4eeb", "41i7", "3b67", "31f9", "2flf", "28l7", "22ah", "1mc7", "1hpg",
"1dm7", "19rq", "16c7", "1330", "vvv", "u2v", "sbp", "qq7", "pa7"}}},
{57494U, {{"skip0", "skip1", "1110000010010110", "2220212102", "32002112", "3314434", "1122102", "326423", "160226",
"86772", "57494", "3a218", "29332", "20228", "16d4a", "1207e", "e096", "bbg0", "9f82", "8750", "73ee",
"647h", "58h8", "4gfh", "43je", "3goj", "3718", "2onb", "2h9a", "2aag", "23qe", "1spk", "1o4m", "1jq8",
"1fp0", "1bwo", "18d2"}}},
{UINT16_MAX, {{"skip0", "skip1", "1111111111111111", "10022220020", "33333333", "4044120", "1223223", "362031",
"177777", "108806", "65535", "45268", "31b13", "23aa2", "19c51", "14640", "ffff", "d5d0", "b44f",
"9aa4", "83gf", "71cf", "638j", "58k8", "4hif", "44la", "3iof", "38o6", "2rgf", "2jqo", "2cof",
"2661", "1vvv", "1r5u", "1mnh", "1ihf", "1ekf"}}},
{71125478U, {{"skip0", "skip1", "100001111010100100111100110", "11221211112210222", "10033110213212",
"121202003403", "11020244342", "1522361624", "417244746", "157745728", "71125478", "3716a696",
"1b9a06b2", "11973ba8", "9636514", "639e338", "43d49e6", "2g19gfb", "21b9d18", "19dec94", "124addi",
"h8f25b", "dhdfa6", "b13hg2", "8m91he", "7720j3", "5pgj58", "4pmelq", "43k17i", "3dg8ek", "2ro898",
"2f0et8", "23qif6", "1qw5lh", "1j7l7s", "1cdvli", "16cgrq"}}},
{std::uint64_t{INT32_MAX},
{{"skip0", "skip1", "1111111111111111111111111111111", "12112122212110202101", "1333333333333333",
"13344223434042", "553032005531", "104134211161", "17777777777", "5478773671", "2147483647", "a02220281",
"4bb2308a7", "282ba4aaa", "1652ca931", "c87e66b7", "7fffffff", "53g7f548", "3928g3h1", "27c57h32",
"1db1f927", "140h2d91", "ikf5bf1", "ebelf95", "b5gge57", "8jmdnkm", "6oj8ion", "5ehncka", "4clm98f",
"3hk7987", "2sb6cs7", "2d09uc1", "1vvvvvv", "1lsqtl1", "1d8xqrp", "15v22um", "zik0zj"}}},
{3522553278ULL,
{{"skip0", "skip1", "11010001111101011110010110111110", "100002111022020200020", "3101331132112332",
"24203233201103", "1341312313010", "153202131426", "32175362676", "10074266606", "3522553278", "1548431462",
"823842766", "441a34c6a", "255b8d486", "1593b4753", "d1f5e5be", "89ffb3b6", "5da3e606", "3hgbfb5i",
"2f0fj33i", "1k1ac536", "191b46e2", "10i6fmk8", "ia967l6", "eahia63", "baca9ga", "92d86i6", "78iq4i6",
"5qlc1dc", "4osos2i", "3u1862s", "38vbpdu", "2o0a7ro", "29hx9e6", "1w2dnod", "1m98ji6"}}},
{UINT32_MAX,
{{"skip0", "skip1", "11111111111111111111111111111111", "102002022201221111210", "3333333333333333",
"32244002423140", "1550104015503", "211301422353", "37777777777", "12068657453", "4294967295", "1904440553",
"9ba461593", "535a79888", "2ca5b7463", "1a20dcd80", "ffffffff", "a7ffda90", "704he7g3", "4f5aff65",
"3723ai4f", "281d55i3", "1fj8b183", "1606k7ib", "mb994af", "hek2mgk", "dnchbnl", "b28jpdl", "8pfgih3",
"76beigf", "5qmcpqf", "4q0jto3", "3vvvvvv", "3aokq93", "2qhxjlh", "2br45qa", "1z141z3"}}},
{545890816626160ULL,
{{"skip0", "skip1", "1111100000111110000011100001101100000110111110000", "2122120211122121121021010202111",
"1330013300130031200313300", "1033022333343024014120", "5213002440142255104", "222661211220253465",
"17407603415406760", "2576748547233674", "545890816626160", "148a34aa4706535", "51285369b87494",
"1a57a38b045a95", "98b3383b9766c", "4319d1601875a", "1f07c1c360df0", "ffd471f34f13", "88g09ff9dh84",
"4d0d5e232c53", "2d63h403i580", "1bf5h8185hdj", "kc3g550fkcg", "d41id5k9984", "8ef5n0him4g", "5i2dijfe1la",
"3me22fm5fhi", "2hfmhgg73kd", "1ngpfabr53c", "18i7220bh11", "rm0lcjngpa", "kk1elesni1", "fgfge3c3fg",
"bp4q5l6bjg", "8xna46jp0k", "6wejomvji5", "5di2s1qhv4"}}},
{std::uint64_t{INT64_MAX},
{{"skip0", "skip1", "111111111111111111111111111111111111111111111111111111111111111",
"2021110011022210012102010021220101220221", "13333333333333333333333333333333",
"1104332401304422434310311212", "1540241003031030222122211", "22341010611245052052300",
"777777777777777777777", "67404283172107811827", "9223372036854775807", "1728002635214590697",
"41a792678515120367", "10b269549075433c37", "4340724c6c71dc7a7", "160e2ad3246366807", "7fffffffffffffff",
"33d3d8307b214008", "16agh595df825fa7", "ba643dci0ffeehh", "5cbfjia3fh26ja7", "2heiciiie82dh97",
"1adaibb21dckfa7", "i6k448cf4192c2", "acd772jnc9l0l7", "64ie1focnn5g77", "3igoecjbmca687", "27c48l5b37oaop",
"1bk39f3ah3dmq7", "q1se8f0m04isb", "hajppbc1fc207", "bm03i95hia437", "7vvvvvvvvvvvv", "5hg4ck9jd4u37",
"3tdtk1v8j6tpp", "2pijmikexrxp7", "1y2p0ij32e8e7"}}},
{stress_chunks_positive,
{{"skip0", "skip1", "1010011010001000100100001011110000101100010101001001010111110100",
"2221221122020020011022001202200200202200", "22122020210023300230111021113310",
"1301130403021123030133211100", "2311004450342244200504500", "30325064311430214266301",
"1232104413605425112764", "87848206138052620680", "12000000345000678900", "2181782a1686924456a",
"54aa47a9058877b130", "150593a5b002c87b16", "571cad2b93c7760a8", "1c60d2676d4e53e00", "a68890bc2c5495f4",
"43499224707a4f4g", "1e052gdga1d26f40", "f06dh4g564c8a91", "769df0d9ace4h50", "3ee7bcj1ajghi4f",
"1k9agc4gfl0l43a", "10id7dakdlcjd22", "dge08fe0l5hl7c", "8184326d31ib60", "4ljbglf3cpim76",
"2pph66481kiiki", "1niph2ao132e58", "14qgbgk3c3iffg", "mhc35an1bhb00", "f78o8ur705ln5", "ad24gngm595fk",
"76e1n5i5v0ivl", "50wu8jsnks82g", "3ja41smfvqb1f", "2j64t3qgq0ut0"}}},
{14454900944617508688ULL,
{{"skip0", "skip1", "1100100010011010000111111101001011100011011000101000111101010000",
"10120022020112011211121221212101012220210", "30202122013331023203120220331100",
"1432224030234034034040234223", "3014532424232535441404120", "34610451042001242144165",
"1442320775134330507520", "116266464747855335823", "14454900944617508688", "266642a9a9471339935",
"662251403263939640", "1895280092bc310481", "68cb9c8292557406c", "23023deab20002893", "c89a1fd2e3628f50",
"50e7147a7db8ef84", "22a34a05086f78ec", "i1dgef04357g7i1", "8g90b882jcj8be8", "49c1kk35i0k24ic",
"272a16i54ebkacg", "15fdih7l3m7k8md", "gbj7303eg9nge0", "9hckfdkj3kkdmd", "5lc7hifdkl4nne",
"3f86e4mgpna5ol", "266pj428na273c", "1bomgjbnlg4m3f", "r5tf1f7f009ji", "iarsig29iqhhm", "ch6gvqbhm53qg",
"8lwtvcdj6rlqr", "61w23lajggp44", "49p1f3dsqqcdx", "31tkqqkxypopc"}}},
{UINT64_MAX,
{{"skip0", "skip1", "1111111111111111111111111111111111111111111111111111111111111111",
"11112220022122120101211020120210210211220", "33333333333333333333333333333333",
"2214220303114400424121122430", "3520522010102100444244423", "45012021522523134134601",
"1777777777777777777777", "145808576354216723756", "18446744073709551615", "335500516a429071284",
"839365134a2a240713", "219505a9511a867b72", "8681049adb03db171", "2c1d56b648c6cd110", "ffffffffffffffff",
"67979g60f5428010", "2d3fgb0b9cg4bd2f", "141c8786h1ccaagg", "b53bjh07be4dj0f", "5e8g4ggg7g56dif",
"2l4lf104353j8kf", "1ddh88h2782i515", "l12ee5fn0ji1if", "c9c336o0mlb7ef", "7b7n2pcniokcgf",
"4eo8hfam6fllmo", "2nc6j26l66rhof", "1n3rsh11f098rn", "14l9lkmo30o40f", "nd075ib45k86f", "fvvvvvvvvvvvv",
"b1w8p7j5q9r6f", "7orp63sh4dphh", "5g24a25twkwff", "3w5e11264sgsf"}}},
};
// https://www.wolframalpha.com : Table[BaseForm[k, n], {k, {MEOW, MEOW, MEOW}}, {n, 2, 36}]
constexpr std::int64_t stress_chunks_negative = -9000876000000054321LL;
constexpr pair<std::int64_t, array<const char*, 37>> output_negative[] = {
{-85, {{"skip0", "skip1", "-1010101", "-10011", "-1111", "-320", "-221", "-151", "-125", "-104", "-85", "-78",
"-71", "-67", "-61", "-5a", "-55", "-50", "-4d", "-49", "-45", "-41", "-3j", "-3g", "-3d", "-3a", "-37",
"-34", "-31", "-2r", "-2p", "-2n", "-2l", "-2j", "-2h", "-2f", "-2d"}}},
{INT8_MIN, {{"skip0", "skip1", "-10000000", "-11202", "-2000", "-1003", "-332", "-242", "-200", "-152", "-128",
"-107", "-a8", "-9b", "-92", "-88", "-80", "-79", "-72", "-6e", "-68", "-62", "-5i", "-5d", "-58",
"-53", "-4o", "-4k", "-4g", "-4c", "-48", "-44", "-40", "-3t", "-3q", "-3n", "-3k"}}},
{-1591, {{"skip0", "skip1", "-11000110111", "-2011221", "-120313", "-22331", "-11211", "-4432", "-3067", "-2157",
"-1591", "-1217", "-b07", "-955", "-819", "-711", "-637", "-58a", "-4g7", "-47e", "-3jb", "-3cg",
"-367", "-304", "-2i7", "-2dg", "-295", "-24p", "-20n", "-1pp", "-1n1", "-1ka", "-1hn", "-1f7", "-1cr",
"-1ag", "-187"}}},
{INT16_MIN, {{"skip0", "skip1", "-1000000000000000", "-1122221122", "-20000000", "-2022033", "-411412", "-164351",
"-100000", "-48848", "-32768", "-2268a", "-16b68", "-11bb8", "-bd28", "-9a98", "-8000", "-6b69",
"-5b28", "-4eec", "-41i8", "-3b68", "-31fa", "-2flg", "-28l8", "-22ai", "-1mc8", "-1hph", "-1dm8",
"-19rr", "-16c8", "-1331", "-1000", "-u2w", "-sbq", "-qq8", "-pa8"}}},
{-66748412,
{{"skip0", "skip1", "-11111110100111111111111100", "-11122121011121102", "-3332213333330", "-114041422122",
"-10342352232", "-1440231533", "-376477774", "-148534542", "-66748412", "-34750085", "-1a42b678",
"-10aa0803", "-8c1731a", "-5cd7492", "-3fa7ffc", "-2d03163", "-1h5f3b2", "-17i39c6", "-10h3b0c", "-g749jh",
"-ckkdkg", "-a8c0ak", "-894afk", "-6klmbc", "-5g1i6g", "-4hg4gb", "-3ogi7o", "-37anqb", "-2mc4r2",
"-2a8h7i", "-1vkvvs", "-1n9ca5", "-1fw8sk", "-19gshh", "-13qnek"}}},
{INT32_MIN, {{"skip0", "skip1", "-10000000000000000000000000000000", "-12112122212110202102", "-2000000000000000",
"-13344223434043", "-553032005532", "-104134211162", "-20000000000", "-5478773672", "-2147483648",
"-a02220282", "-4bb2308a8", "-282ba4aab", "-1652ca932", "-c87e66b8", "-80000000", "-53g7f549",
"-3928g3h2", "-27c57h33", "-1db1f928", "-140h2d92", "-ikf5bf2", "-ebelf96", "-b5gge58", "-8jmdnkn",
"-6oj8ioo", "-5ehnckb", "-4clm98g", "-3hk7988", "-2sb6cs8", "-2d09uc2", "-2000000", "-1lsqtl2",
"-1d8xqrq", "-15v22un", "-zik0zk"}}},
{-297139747082649553LL,
{{"skip0", "skip1", "-10000011111101001110000011010010001100000101011111111010001",
"-1222110012002112101210012211022102101", "-100133221300122101200223333101", "-4443033200104011124241203",
"-21313431255203203120401", "-350320603201030412545", "-20375160322140537721", "-1873162471705738371",
"-297139747082649553", "-65150976074a24025", "-173522497b5373101", "-5a60a99bc3b71654", "-1ca51a06cc38ba25",
"-a2a25babe62241d", "-41fa7069182bfd1", "-1d00134fba1769g", "-e4f799fc5f7e81", "-714ebbh8388188",
"-3cahb17836b3hd", "-1j8659jf5hbg3j", "-112bbb2jege5c5", "-dcjfmk2kjb4cc", "-836bm4klbgl61",
"-4ofia1416ee73", "-32ommgjef1l2h", "-1qc52eal5m8ba", "-17n53r05a4r15", "-oa88m2qiqjik", "-gn67qoat5r8d",
"-blgd6n5s90al", "-87t70q8o5fuh", "-5t09hwaqu9qg", "-47vssihaoa4x", "-32p24fbjye7x", "-299r8zck3841"}}},
{stress_chunks_negative,
{{"skip0", "skip1", "-111110011101001100010010000100010000111010101111001010000110001",
"-2012222010200021010000112111002001111200", "-13303221202100202013111321100301",
"-1101001100304341000003214241", "-1522150121302454031001413", "-22054250360123016161454",
"-763514220420725712061", "-65863607100474061450", "-9000876000000054321", "-1689813530958833498",
"-408258185a67069269", "-106b01597a47ba2948", "-41c02922bc776d49b", "-1584cd10979dc84b6",
"-7ce9890887579431", "-327cf6cbc67023c3", "-1604b5f6a0de8129", "-b50d3ef02f124a4", "-59h9bfif0006fg1",
"-2g5d8ekh05d2dfi", "-19i418c38g1chfj", "-hjgf7d0k0gla9a", "-a6b21ncehfa3f9", "-61060fnl003bml",
"-3g88bakondgf8l", "-25q3i730ed21di", "-1al84glo518iip", "-pcli8ig7pjhbo", "-gs31q8id2jnkl",
"-bd7kaglgdrbgk", "-7pqc9123lf51h", "-5d2sd1r5ms7su", "-3q833s8kdrun3", "-2n7vmqigfueqb",
"-1wdu892toj0a9"}}},
{INT64_MIN, {{"skip0", "skip1", "-1000000000000000000000000000000000000000000000000000000000000000",
"-2021110011022210012102010021220101220222", "-20000000000000000000000000000000",
"-1104332401304422434310311213", "-1540241003031030222122212", "-22341010611245052052301",
"-1000000000000000000000", "-67404283172107811828", "-9223372036854775808", "-1728002635214590698",
"-41a792678515120368", "-10b269549075433c38", "-4340724c6c71dc7a8", "-160e2ad3246366808",
"-8000000000000000", "-33d3d8307b214009", "-16agh595df825fa8", "-ba643dci0ffeehi",
"-5cbfjia3fh26ja8", "-2heiciiie82dh98", "-1adaibb21dckfa8", "-i6k448cf4192c3", "-acd772jnc9l0l8",
"-64ie1focnn5g78", "-3igoecjbmca688", "-27c48l5b37oaoq", "-1bk39f3ah3dmq8", "-q1se8f0m04isc",
"-hajppbc1fc208", "-bm03i95hia438", "-8000000000000", "-5hg4ck9jd4u38", "-3tdtk1v8j6tpq",
"-2pijmikexrxp8", "-1y2p0ij32e8e8"}}},
};
template <typename T>
void test_integer_to_chars() {
for (int base = 2; base <= 36; ++base) {
test_integer_to_chars(static_cast<T>(0), base, "0");
test_integer_to_chars(static_cast<T>(1), base, "1");
// tests [3, 71]
test_integer_to_chars(static_cast<T>(base * 2 - 1), base, output_max_digit[base]);
for (const auto& p : output_positive) {
if (p.first <= static_cast<std::uint64_t>(numeric_limits<T>::max())) {
test_integer_to_chars(static_cast<T>(p.first), base, p.second[static_cast<std::size_t>(base)]);
}
}
if constexpr (is_signed_v<T>) {
test_integer_to_chars(static_cast<T>(-1), base, "-1");
for (const auto& p : output_negative) {
if (p.first >= static_cast<std::int64_t>(numeric_limits<T>::min())) {
test_integer_to_chars(static_cast<T>(p.first), base, p.second[static_cast<std::size_t>(base)]);
}
}
}
}
test_integer_to_chars(static_cast<T>(42), nullopt, "42");
}
enum class TestFromCharsMode { Normal, SignalingNaN };
template <typename T, typename BaseOrFmt>
void test_from_chars(const string_view input, const BaseOrFmt base_or_fmt, const std::size_t correct_idx,
const errc correct_ec, const optional<T> opt_correct = nullopt,
const TestFromCharsMode mode = TestFromCharsMode::Normal) {
if constexpr (is_integral_v<T>) {
assert(mode == TestFromCharsMode::Normal);
}
constexpr T unmodified = 111;
T dest = unmodified;
const from_chars_result result = from_chars(input.data(), input.data() + input.size(), dest, base_or_fmt);
assert(result.ptr == input.data() + correct_idx);
assert(result.ec == correct_ec);
if (correct_ec == errc{} || (is_floating_point_v<T> && correct_ec == errc::result_out_of_range)) {
if constexpr (is_floating_point_v<T>) {
if (mode == TestFromCharsMode::Normal) {
using Uint = conditional_t<is_same_v<T, float>, std::uint32_t, std::uint64_t>;
assert(opt_correct.has_value());
assert(_Bit_cast<Uint>(dest) == _Bit_cast<Uint>(opt_correct.value()));
} else {
assert(mode == TestFromCharsMode::SignalingNaN);
assert(!opt_correct.has_value());
assert(isnan(dest));
}
} else {
assert(opt_correct.has_value());
assert(dest == opt_correct.value());
}
} else {
assert(!opt_correct.has_value());
assert(dest == unmodified);
}
}
constexpr errc inv_arg = errc::invalid_argument;
constexpr errc out_ran = errc::result_out_of_range;
template <typename T>
void test_integer_from_chars() {
for (int base = 2; base <= 36; ++base) {
test_from_chars<T>("", base, 0, inv_arg); // no characters
test_from_chars<T>("@1", base, 0, inv_arg); // '@' is bogus
test_from_chars<T>(".1", base, 0, inv_arg); // '.' is bogus, for integers
test_from_chars<T>("+1", base, 0, inv_arg); // '+' is bogus, N4713 23.20.3 [charconv.from.chars]/3
// "a minus sign is the only sign that may appear"
test_from_chars<T>(" 1", base, 0, inv_arg); // ' ' is bogus, no whitespace in subject sequence
if constexpr (is_unsigned_v<T>) { // N4713 23.20.3 [charconv.from.chars]/3
test_from_chars<T>("-1", base, 0, inv_arg); // "and only if value has a signed type"
}
// N4713 23.20.3 [charconv.from.chars]/1 "[ Note: If the pattern allows for an optional sign,
// but the string has no digit characters following the sign, no characters match the pattern. -end note ]"
test_from_chars<T>("-", base, 0, inv_arg); // '-' followed by no characters
test_from_chars<T>("-@1", base, 0, inv_arg); // '-' followed by bogus '@'
test_from_chars<T>("-.1", base, 0, inv_arg); // '-' followed by bogus '.'
test_from_chars<T>("-+1", base, 0, inv_arg); // '-' followed by bogus '+'
test_from_chars<T>("- 1", base, 0, inv_arg); // '-' followed by bogus ' '
test_from_chars<T>("--1", base, 0, inv_arg); // '-' can't be repeated
vector<char> bogus_digits;
if (base < 10) {
bogus_digits = {static_cast<char>('0' + base), 'A', 'a'};
} else {
// '[' and '{' are bogus for base 36
bogus_digits = {static_cast<char>('A' + (base - 10)), static_cast<char>('a' + (base - 10))};
}
for (const auto& bogus : bogus_digits) {
test_from_chars<T>(bogus + "1"s, base, 0, inv_arg); // bogus digit (for this base)
test_from_chars<T>("-"s + bogus + "1"s, base, 0, inv_arg); // '-' followed by bogus digit
}
// Test leading zeroes.
test_from_chars<T>(string(100, '0'), base, 100, errc{}, static_cast<T>(0));
test_from_chars<T>(string(100, '0') + "11"s, base, 102, errc{}, static_cast<T>(base + 1));
// Test negative zero and negative leading zeroes.
if constexpr (is_signed_v<T>) {
test_from_chars<T>("-0", base, 2, errc{}, static_cast<T>(0));
test_from_chars<T>("-"s + string(100, '0'), base, 101, errc{}, static_cast<T>(0));
test_from_chars<T>("-"s + string(100, '0') + "11"s, base, 103, errc{}, static_cast<T>(-base - 1));
}
// N4713 23.20.3 [charconv.from.chars]/1 "The member ptr of the return value points to the
// first character not matching the pattern, or has the value last if all characters match."
test_from_chars<T>("11", base, 2, errc{}, static_cast<T>(base + 1));
test_from_chars<T>("11@@@", base, 2, errc{}, static_cast<T>(base + 1));
// When overflowing, we need to keep consuming valid digits, in order to return ptr correctly.
test_from_chars<T>(string(100, '1'), base, 100, out_ran);
test_from_chars<T>(string(100, '1') + "@@@"s, base, 100, out_ran);
if constexpr (is_signed_v<T>) {
test_from_chars<T>("-"s + string(100, '1'), base, 101, out_ran);
test_from_chars<T>("-"s + string(100, '1') + "@@@"s, base, 101, out_ran);
}
}
// N4713 23.20.3 [charconv.from.chars]/3 "The pattern is the expected form of the subject sequence
// in the "C" locale for the given nonzero base, as described for strtol"
// C11 7.22.1.4/3 "The letters from a (or A) through z (or Z) are ascribed the values 10 through 35"
for (int i = 0; i < 26; ++i) {
test_from_chars<T>(string(1, static_cast<char>('A' + i)), 36, 1, errc{}, static_cast<T>(10 + i));
test_from_chars<T>(string(1, static_cast<char>('a' + i)), 36, 1, errc{}, static_cast<T>(10 + i));
}
// N4713 23.20.3 [charconv.from.chars]/3 "no "0x" or "0X" prefix shall appear if the value of base is 16"
test_from_chars<T>("0x1729", 16, 1, errc{}, static_cast<T>(0)); // reads '0', stops at 'x'
test_from_chars<T>("0X1729", 16, 1, errc{}, static_cast<T>(0)); // reads '0', stops at 'X'
if constexpr (is_signed_v<T>) {
test_from_chars<T>("-0x1729", 16, 2, errc{}, static_cast<T>(0)); // reads "-0", stops at 'x'
test_from_chars<T>("-0X1729", 16, 2, errc{}, static_cast<T>(0)); // reads "-0", stops at 'X'
}
}
template <typename T>
void test_integer() {
test_integer_to_chars<T>();
test_integer_from_chars<T>();
}
void all_integer_tests() {
test_integer<char>();
test_integer<signed char>();
test_integer<unsigned char>();
test_integer<short>();
test_integer<unsigned short>();
test_integer<int>();
test_integer<unsigned int>();
test_integer<long>();
test_integer<unsigned long>();
test_integer<long long>();
test_integer<unsigned long long>();
// Test overflow scenarios.
test_from_chars<unsigned int>("4294967289", 10, 10, errc{}, 4294967289U); // not risky
test_from_chars<unsigned int>("4294967294", 10, 10, errc{}, 4294967294U); // risky with good digit
test_from_chars<unsigned int>("4294967295", 10, 10, errc{}, 4294967295U); // risky with max digit
test_from_chars<unsigned int>("4294967296", 10, 10, out_ran); // risky with bad digit
test_from_chars<unsigned int>("4294967300", 10, 10, out_ran); // beyond risky
test_from_chars<int>("2147483639", 10, 10, errc{}, 2147483639); // not risky
test_from_chars<int>("2147483646", 10, 10, errc{}, 2147483646); // risky with good digit
test_from_chars<int>("2147483647", 10, 10, errc{}, 2147483647); // risky with max digit
test_from_chars<int>("2147483648", 10, 10, out_ran); // risky with bad digit
test_from_chars<int>("2147483650", 10, 10, out_ran); // beyond risky
test_from_chars<int>("-2147483639", 10, 11, errc{}, -2147483639); // not risky
test_from_chars<int>("-2147483647", 10, 11, errc{}, -2147483647); // risky with good digit
test_from_chars<int>("-2147483648", 10, 11, errc{}, -2147483647 - 1); // risky with max digit
test_from_chars<int>("-2147483649", 10, 11, out_ran); // risky with bad digit
test_from_chars<int>("-2147483650", 10, 11, out_ran); // beyond risky
}
void assert_message_bits(const bool b, const char* const msg, const std::uint32_t bits) {
if (!b) {
fprintf(stderr, "%s failed for 0x%08zX\n", msg, static_cast<std::size_t>(bits));
fprintf(stderr, "This is a randomized test.\n");
fprintf(stderr, "DO NOT IGNORE/RERUN THIS FAILURE.\n");
fprintf(stderr, "You must report it to the STL maintainers.\n");
abort();
}
}
void assert_message_bits(const bool b, const char* const msg, const std::uint64_t bits) {
if (!b) {
// libc++ uses long for 64-bit values.
fprintf(stderr, "%s failed for 0x%016llX\n", msg, static_cast<unsigned long long>(bits));
fprintf(stderr, "This is a randomized test.\n");
fprintf(stderr, "DO NOT IGNORE/RERUN THIS FAILURE.\n");
fprintf(stderr, "You must report it to the STL maintainers.\n");
abort();
}
}
constexpr std::uint32_t FractionBits = 10; // Tunable for test coverage vs. performance.
static_assert(FractionBits >= 1, "Must test at least 1 fraction bit.");
static_assert(FractionBits <= 23, "There are only 23 fraction bits in a float.");
constexpr std::uint32_t Fractions = 1U << FractionBits;
constexpr std::uint32_t Mask32 = ~((1U << FractionBits) - 1U);
constexpr std::uint64_t Mask64 = ~((1ULL << FractionBits) - 1ULL);
constexpr std::uint32_t PrefixesToTest = 100; // Tunable for test coverage vs. performance.
static_assert(PrefixesToTest >= 1, "Must test at least 1 prefix.");
constexpr std::uint32_t PrefixLimit = 2 // sign bit
* 255 // non-INF/NAN exponents for float
* (1U << (23 - FractionBits)); // fraction bits in prefix
static_assert(PrefixesToTest <= PrefixLimit, "Too many prefixes.");
template <bool IsDouble>
void test_floating_prefix(const conditional_t<IsDouble, std::uint64_t, std::uint32_t> prefix) {
using UIntType = conditional_t<IsDouble, std::uint64_t, std::uint32_t>;
using FloatingType = conditional_t<IsDouble, double, float>;
// "-1.2345678901234567e-100" or "-1.23456789e-10"
constexpr std::size_t buffer_size = IsDouble ? 24 : 15;
char buffer[buffer_size];
// TODO Enable once std::from_chars has floating point support.
#if 0
FloatingType val;
#endif
// Exact sizes are difficult to prove for fixed notation.
// This must be at least (IsDouble ? 327 : 48), and I suspect that that's exact.
// Here's a loose upper bound:
// 1 character for a negative sign
// + 325 (for double; 46 for float) characters in the "0.000~~~000" prefix of the min subnormal
// + 17 (for double; 9 for float) characters for round-trip digits
constexpr std::size_t fixed_buffer_size = IsDouble ? 1 + 325 + 17 : 1 + 46 + 9;
char fixed_buffer[fixed_buffer_size];
// worst case: negative sign + max normal + null terminator
constexpr std::size_t stdio_buffer_size = 1 + (IsDouble ? 309 : 39) + 1;
char stdio_buffer[stdio_buffer_size];
for (std::uint32_t frac = 0; frac < Fractions; ++frac) {
const UIntType bits = prefix + frac;
const FloatingType input = _Bit_cast<FloatingType>(bits);
{
const auto to_result = to_chars(buffer, end(buffer), input, chars_format::scientific);
assert_message_bits(to_result.ec == errc{}, "to_result.ec", bits);
// TODO Enable once std::from_chars has floating point support.
#if 0
const char* const last = to_result.ptr;
const auto from_result = from_chars(buffer, last, val);
assert_message_bits(from_result.ptr == last, "from_result.ptr", bits);
assert_message_bits(from_result.ec == errc{}, "from_result.ec", bits);
assert_message_bits(_Bit_cast<UIntType>(val) == bits, "round-trip", bits);
#endif
}
{
// Also verify that to_chars() and sprintf_s() emit the same output for integers in fixed notation.
const auto fixed_result = to_chars(fixed_buffer, end(fixed_buffer), input, chars_format::fixed);
assert_message_bits(fixed_result.ec == errc{}, "fixed_result.ec", bits);
const string_view fixed_sv(fixed_buffer, static_cast<std::size_t>(fixed_result.ptr - fixed_buffer));
if (find(fixed_sv.begin(), fixed_sv.end(), '.') == fixed_sv.end()) {
const int stdio_ret = sprintf_s(stdio_buffer, size(stdio_buffer), "%.0f", input);
assert_message_bits(stdio_ret != -1, "stdio_ret", bits);
const string_view stdio_sv(stdio_buffer);
assert_message_bits(fixed_sv == stdio_sv, "fixed_sv", bits);
}
}
}
}
template <bool IsDouble>
void test_floating_hex_prefix(const conditional_t<IsDouble, std::uint64_t, std::uint32_t> prefix) {
using UIntType = conditional_t<IsDouble, std::uint64_t, std::uint32_t>;
using FloatingType = conditional_t<IsDouble, double, float>;
// The precision is the number of hexits after the decimal point.
// These hexits correspond to the explicitly stored fraction bits.
// double explicitly stores 52 fraction bits. 52 / 4 == 13, so we need 13 hexits.
// float explicitly stores 23 fraction bits. 23 / 4 == 5.75, so we need 6 hexits.
// "-1.fffffffffffffp+1023" or "-1.fffffep+127"
constexpr std::size_t buffer_size = IsDouble ? 22 : 14;
char buffer[buffer_size];
// TODO Enable once std::from_chars has floating point support.
#if 0
FloatingType val;
#endif
for (std::uint32_t frac = 0; frac < Fractions; ++frac) {
const UIntType bits = prefix + frac;
const FloatingType input = _Bit_cast<FloatingType>(bits);
const auto to_result = to_chars(buffer, end(buffer), input, chars_format::hex);
assert_message_bits(to_result.ec == errc{}, "(hex) to_result.ec", bits);
// TODO Enable once std::from_chars has floating point support.
#if 0
const char* const last = to_result.ptr;
const auto from_result = from_chars(buffer, last, val, chars_format::hex);
assert_message_bits(from_result.ptr == last, "(hex) from_result.ptr", bits);
assert_message_bits(from_result.ec == errc{}, "(hex) from_result.ec", bits);
assert_message_bits(_Bit_cast<UIntType>(val) == bits, "(hex) round-trip", bits);
#endif
}
}
template <bool IsDouble>
void test_floating_precision_prefix(const conditional_t<IsDouble, std::uint64_t, std::uint32_t> prefix) {
using UIntType = conditional_t<IsDouble, std::uint64_t, std::uint32_t>;
using FloatingType = conditional_t<IsDouble, double, float>;
// Precision for min subnormal in fixed notation. (More than enough for scientific notation.)
constexpr int precision = IsDouble ? 1074 : 149;
// Number of digits for max normal in fixed notation.
constexpr int max_integer_length = IsDouble ? 309 : 39;
// Size for fixed notation. (More than enough for scientific notation.)
constexpr std::size_t charconv_buffer_size = 1 // negative sign
+ max_integer_length // integer digits
+ 1 // decimal point
+ precision; // fractional digits
char charconv_buffer[charconv_buffer_size];
constexpr std::size_t stdio_buffer_size = charconv_buffer_size + 1; // null terminator
char stdio_buffer[stdio_buffer_size];
// 1 character for a negative sign
// + worst cases: 0x1.fffffffffffffp-1022 and 0x1.fffffep-126f
constexpr std::size_t general_buffer_size = 1 + (IsDouble ? 773 : 117);
char general_buffer[general_buffer_size];
char general_stdio_buffer[general_buffer_size + 1]; // + null terminator
for (std::uint32_t frac = 0; frac < Fractions; ++frac) {
const UIntType bits = prefix + frac;
const FloatingType input = _Bit_cast<FloatingType>(bits);
auto result = to_chars(charconv_buffer, end(charconv_buffer), input, chars_format::fixed, precision);
assert_message_bits(result.ec == errc{}, "to_chars fixed precision", bits);
string_view charconv_sv(charconv_buffer, static_cast<std::size_t>(result.ptr - charconv_buffer));
int stdio_ret = sprintf_s(stdio_buffer, size(stdio_buffer), "%.*f", precision, input);
assert_message_bits(stdio_ret != -1, "sprintf_s fixed precision", bits);
string_view stdio_sv(stdio_buffer);
assert_message_bits(charconv_sv == stdio_sv, "fixed precision output", bits);
result = to_chars(charconv_buffer, end(charconv_buffer), input, chars_format::scientific, precision);
assert_message_bits(result.ec == errc{}, "to_chars scientific precision", bits);
charconv_sv = string_view(charconv_buffer, static_cast<std::size_t>(result.ptr - charconv_buffer));
stdio_ret = sprintf_s(stdio_buffer, size(stdio_buffer), "%.*e", precision, input);
assert_message_bits(stdio_ret != -1, "sprintf_s scientific precision", bits);
stdio_sv = stdio_buffer;
assert_message_bits(charconv_sv == stdio_sv, "scientific precision output", bits);
result = to_chars(general_buffer, end(general_buffer), input, chars_format::general, 5000);
assert_message_bits(result.ec == errc{}, "to_chars general precision", bits);
charconv_sv = string_view(general_buffer, static_cast<std::size_t>(result.ptr - general_buffer));
stdio_ret = sprintf_s(general_stdio_buffer, size(general_stdio_buffer), "%.5000g", input);
assert_message_bits(stdio_ret != -1, "sprintf_s general precision", bits);
stdio_sv = general_stdio_buffer;
assert_message_bits(charconv_sv == stdio_sv, "general precision output", bits);
}
}
void test_floating_prefixes(mt19937_64& mt64) {
{
set<std::uint64_t> prefixes64;
while (prefixes64.size() < PrefixesToTest) {
const std::uint64_t val = mt64();
if ((val & 0x7FF0000000000000ULL) != 0x7FF0000000000000ULL) { // skip INF/NAN
prefixes64.insert(val & Mask64);
}
}
for (const auto& prefix : prefixes64) {
test_floating_prefix<true>(prefix);
test_floating_precision_prefix<true>(prefix);
}
test_floating_hex_prefix<true>(*prefixes64.begin()); // save time by testing fewer hexfloats
}
{
set<std::uint32_t> prefixes32;
while (prefixes32.size() < PrefixesToTest) {
const std::uint32_t val = static_cast<std::uint32_t>(mt64());
if ((val & 0x7F800000U) != 0x7F800000U) { // skip INF/NAN
prefixes32.insert(val & Mask32);
}
}
for (const auto& prefix : prefixes32) {
test_floating_prefix<false>(prefix);
test_floating_precision_prefix<false>(prefix);
}
test_floating_hex_prefix<false>(*prefixes32.begin()); // save time by testing fewer hexfloats
}
}
// TODO Enable once std::from_chars has floating point support.
#if 0
template <typename T>
void test_floating_from_chars(const chars_format fmt) {
test_from_chars<T>("", fmt, 0, inv_arg); // no characters
test_from_chars<T>("@1", fmt, 0, inv_arg); // '@' is bogus
test_from_chars<T>("z1", fmt, 0, inv_arg); // 'z' is bogus
test_from_chars<T>(".", fmt, 0, inv_arg); // '.' without digits is bogus
test_from_chars<T>("+1", fmt, 0, inv_arg); // '+' is bogus
test_from_chars<T>(" 1", fmt, 0, inv_arg); // ' ' is bogus
test_from_chars<T>("p5", fmt, 0, inv_arg); // binary-exponent-part without digits is bogus
test_from_chars<T>("in", fmt, 0, inv_arg); // incomplete inf is bogus
test_from_chars<T>("na", fmt, 0, inv_arg); // incomplete nan is bogus
test_from_chars<T>("-", fmt, 0, inv_arg); // '-' followed by no characters
test_from_chars<T>("-@1", fmt, 0, inv_arg); // '-' followed by bogus '@'
test_from_chars<T>("-z1", fmt, 0, inv_arg); // '-' followed by bogus 'z'
test_from_chars<T>("-.", fmt, 0, inv_arg); // '-' followed by bogus '.'
test_from_chars<T>("-+1", fmt, 0, inv_arg); // '-' followed by bogus '+'
test_from_chars<T>("- 1", fmt, 0, inv_arg); // '-' followed by bogus ' '
test_from_chars<T>("-p5", fmt, 0, inv_arg); // '-' followed by bogus binary-exponent-part
test_from_chars<T>("-in", fmt, 0, inv_arg); // '-' followed by bogus incomplete inf
test_from_chars<T>("-na", fmt, 0, inv_arg); // '-' followed by bogus incomplete nan
test_from_chars<T>("--1", fmt, 0, inv_arg); // '-' can't be repeated
if (fmt != chars_format::hex) { // "e5" are valid hexits
test_from_chars<T>("e5", fmt, 0, inv_arg); // exponent-part without digits is bogus
test_from_chars<T>("-e5", fmt, 0, inv_arg); // '-' followed by bogus exponent-part
}
constexpr T inf = numeric_limits<T>::infinity();
constexpr T qnan = numeric_limits<T>::quiet_NaN();
test_from_chars<T>("InF", fmt, 3, errc{}, inf);
test_from_chars<T>("infinite", fmt, 3, errc{}, inf);
test_from_chars<T>("iNfInItY", fmt, 8, errc{}, inf);
test_from_chars<T>("InfinityMeow", fmt, 8, errc{}, inf);
test_from_chars<T>("-InF", fmt, 4, errc{}, -inf);
test_from_chars<T>("-infinite", fmt, 4, errc{}, -inf);
test_from_chars<T>("-iNfInItY", fmt, 9, errc{}, -inf);
test_from_chars<T>("-InfinityMeow", fmt, 9, errc{}, -inf);
test_from_chars<T>("NaN", fmt, 3, errc{}, qnan);
test_from_chars<T>("nanotech", fmt, 3, errc{}, qnan);
test_from_chars<T>("nan(", fmt, 3, errc{}, qnan);
test_from_chars<T>("nan(@)", fmt, 3, errc{}, qnan);
test_from_chars<T>("nan(()", fmt, 3, errc{}, qnan);
test_from_chars<T>("nan(abc", fmt, 3, errc{}, qnan);
test_from_chars<T>("nan()", fmt, 5, errc{}, qnan);
test_from_chars<T>("nan(abc)def", fmt, 8, errc{}, qnan);
test_from_chars<T>("nan(_09AZaz)", fmt, 12, errc{}, qnan);
test_from_chars<T>("nan(int)", fmt, 8, errc{}, qnan);
test_from_chars<T>("nan(snap)", fmt, 9, errc{}, qnan);
test_from_chars<T>("-NaN", fmt, 4, errc{}, -qnan);
test_from_chars<T>("-nanotech", fmt, 4, errc{}, -qnan);
test_from_chars<T>("-nan(", fmt, 4, errc{}, -qnan);
test_from_chars<T>("-nan(@)", fmt, 4, errc{}, -qnan);
test_from_chars<T>("-nan(()", fmt, 4, errc{}, -qnan);
test_from_chars<T>("-nan(abc", fmt, 4, errc{}, -qnan);
test_from_chars<T>("-nan()", fmt, 6, errc{}, -qnan);
test_from_chars<T>("-nan(abc)def", fmt, 9, errc{}, -qnan);
test_from_chars<T>("-nan(_09AZaz)", fmt, 13, errc{}, -qnan);
test_from_chars<T>("-nan(int)", fmt, 9, errc{}, -qnan);
test_from_chars<T>("-nan(snap)", fmt, 10, errc{}, -qnan);
// The UCRT considers indeterminate NaN to be negative quiet NaN with no payload bits set.
// It parses "nan(ind)" and "-nan(ind)" identically.
test_from_chars<T>("nan(InD)", fmt, 8, errc{}, -qnan);
test_from_chars<T>("-nan(InD)", fmt, 9, errc{}, -qnan);
test_from_chars<T>("nan(SnAn)", fmt, 9, errc{}, nullopt, TestFromCharsMode::SignalingNaN);
test_from_chars<T>("-nan(SnAn)", fmt, 10, errc{}, nullopt, TestFromCharsMode::SignalingNaN);
switch (fmt) {
case chars_format::general:
test_from_chars<T>("1729", fmt, 4, errc{}, T{1729});
test_from_chars<T>("1729e3", fmt, 6, errc{}, T{1729000});
test_from_chars<T>("10", fmt, 2, errc{}, T{10});
test_from_chars<T>("11.", fmt, 3, errc{}, T{11});
test_from_chars<T>("12.13", fmt, 5, errc{}, static_cast<T>(12.13)); // avoid truncation warning
test_from_chars<T>(".14", fmt, 3, errc{}, static_cast<T>(.14)); // avoid truncation warning
test_from_chars<T>("20e5", fmt, 4, errc{}, T{2000000});
test_from_chars<T>("21.e5", fmt, 5, errc{}, T{2100000});
test_from_chars<T>("22.23e5", fmt, 7, errc{}, T{2223000});
test_from_chars<T>(".24e5", fmt, 5, errc{}, T{24000});
test_from_chars<T>("33e+5", fmt, 5, errc{}, T{3300000});
test_from_chars<T>("33e-5", fmt, 5, errc{}, static_cast<T>(.00033)); // avoid truncation warning
test_from_chars<T>("4E7", fmt, 3, errc{}, T{40000000});
test_from_chars<T>("-00123abc", fmt, 6, errc{}, T{-123});
test_from_chars<T>(".0045000", fmt, 8, errc{}, static_cast<T>(.0045)); // avoid truncation warning
test_from_chars<T>("000", fmt, 3, errc{}, T{0});
test_from_chars<T>("0e9999", fmt, 6, errc{}, T{0});
test_from_chars<T>("0e-9999", fmt, 7, errc{}, T{0});
test_from_chars<T>("-000", fmt, 4, errc{}, T{-0.0});
test_from_chars<T>("-0e9999", fmt, 7, errc{}, T{-0.0});
test_from_chars<T>("-0e-9999", fmt, 8, errc{}, T{-0.0});
test_from_chars<T>("1e9999", fmt, 6, errc::result_out_of_range, inf);
test_from_chars<T>("-1e9999", fmt, 7, errc::result_out_of_range, -inf);
test_from_chars<T>("1e-9999", fmt, 7, errc::result_out_of_range, T{0});
test_from_chars<T>("-1e-9999", fmt, 8, errc::result_out_of_range, T{-0.0});
test_from_chars<T>("1" + string(6000, '0'), fmt, 6001, errc::result_out_of_range, inf);
test_from_chars<T>("-1" + string(6000, '0'), fmt, 6002, errc::result_out_of_range, -inf);
test_from_chars<T>("." + string(6000, '0') + "1", fmt, 6002, errc::result_out_of_range, T{0});
test_from_chars<T>("-." + string(6000, '0') + "1", fmt, 6003, errc::result_out_of_range, T{-0.0});
test_from_chars<T>("1" + string(500, '0'), fmt, 501, errc::result_out_of_range, inf);
test_from_chars<T>("-1" + string(500, '0'), fmt, 502, errc::result_out_of_range, -inf);
test_from_chars<T>("." + string(500, '0') + "1", fmt, 502, errc::result_out_of_range, T{0});
test_from_chars<T>("-." + string(500, '0') + "1", fmt, 503, errc::result_out_of_range, T{-0.0});
break;
case chars_format::scientific:
test_from_chars<T>("1729", fmt, 0, inv_arg);
test_from_chars<T>("1729e3", fmt, 6, errc{}, T{1729000});
break;
case chars_format::fixed:
test_from_chars<T>("1729", fmt, 4, errc{}, T{1729});
test_from_chars<T>("1729e3", fmt, 4, errc{}, T{1729});
break;
case chars_format::hex:
test_from_chars<T>("0x123", fmt, 1, errc{}, T{0});
test_from_chars<T>("a0", fmt, 2, errc{}, T{160});
test_from_chars<T>("a1.", fmt, 3, errc{}, T{161});
test_from_chars<T>("a2.a3", fmt, 5, errc{}, T{162.63671875});
test_from_chars<T>(".a4", fmt, 3, errc{}, T{0.640625});
test_from_chars<T>("a0p5", fmt, 4, errc{}, T{5120});
test_from_chars<T>("a1.p5", fmt, 5, errc{}, T{5152});
test_from_chars<T>("a2.a3p5", fmt, 7, errc{}, T{5204.375});
test_from_chars<T>(".a4p5", fmt, 5, errc{}, T{20.5});
test_from_chars<T>("a0p+5", fmt, 5, errc{}, T{5120});
test_from_chars<T>("a0p-5", fmt, 5, errc{}, T{5});
test_from_chars<T>("ABCDEFP3", fmt, 8, errc{}, T{90075000});
test_from_chars<T>("-00cdrom", fmt, 5, errc{}, T{-205});
test_from_chars<T>(".00ef000", fmt, 8, errc{}, T{0.0036468505859375});
test_from_chars<T>("000", fmt, 3, errc{}, T{0});
test_from_chars<T>("0p9999", fmt, 6, errc{}, T{0});
test_from_chars<T>("0p-9999", fmt, 7, errc{}, T{0});
test_from_chars<T>("-000", fmt, 4, errc{}, T{-0.0});
test_from_chars<T>("-0p9999", fmt, 7, errc{}, T{-0.0});
test_from_chars<T>("-0p-9999", fmt, 8, errc{}, T{-0.0});
test_from_chars<T>("1p9999", fmt, 6, errc::result_out_of_range, inf);
test_from_chars<T>("-1p9999", fmt, 7, errc::result_out_of_range, -inf);
test_from_chars<T>("1p-9999", fmt, 7, errc::result_out_of_range, T{0});
test_from_chars<T>("-1p-9999", fmt, 8, errc::result_out_of_range, T{-0.0});
test_from_chars<T>("1" + string(2000, '0'), fmt, 2001, errc::result_out_of_range, inf);
test_from_chars<T>("-1" + string(2000, '0'), fmt, 2002, errc::result_out_of_range, -inf);
test_from_chars<T>("." + string(2000, '0') + "1", fmt, 2002, errc::result_out_of_range, T{0});
test_from_chars<T>("-." + string(2000, '0') + "1", fmt, 2003, errc::result_out_of_range, T{-0.0});
test_from_chars<T>("1" + string(300, '0'), fmt, 301, errc::result_out_of_range, inf);
test_from_chars<T>("-1" + string(300, '0'), fmt, 302, errc::result_out_of_range, -inf);
test_from_chars<T>("." + string(300, '0') + "1", fmt, 302, errc::result_out_of_range, T{0});
test_from_chars<T>("-." + string(300, '0') + "1", fmt, 303, errc::result_out_of_range, T{-0.0});
break;
}
}
#endif
template <typename T>
void test_floating_to_chars(
const T value, const optional<chars_format> opt_fmt, const optional<int> opt_precision, const string_view correct) {
test_common_to_chars(value, opt_fmt, opt_precision, correct);
}
void all_floating_tests(mt19937_64& mt64) {
test_floating_prefixes(mt64);
// TODO Enable once std::from_chars has floating point support.
#if 0
for (const auto& fmt : {chars_format::general, chars_format::scientific, chars_format::fixed, chars_format::hex}) {
test_floating_from_chars<float>(fmt);
test_floating_from_chars<double>(fmt);
}
// Test rounding.
// See float_from_chars_test_cases.hpp in this directory.
for (const auto& t : float_from_chars_test_cases) {
test_from_chars<float>(t.input, t.fmt, t.correct_idx, t.correct_ec, t.correct_value);
}
// See double_from_chars_test_cases.hpp in this directory.
for (const auto& t : double_from_chars_test_cases) {
test_from_chars<double>(t.input, t.fmt, t.correct_idx, t.correct_ec, t.correct_value);
}
{
// See LWG-2403. This number (exactly 0x1.fffffd00000004 in infinite precision) behaves differently
// when parsed as double and converted to float, versus being parsed as float directly.
const char* const lwg_2403 = "1.999999821186065729339276231257827021181583404541015625";
constexpr float correct_float = 0x1.fffffep0f;
constexpr double correct_double = 0x1.fffffdp0;
constexpr float twice_rounded_float = 0x1.fffffcp0f;
test_from_chars<float>(lwg_2403, chars_format::general, 56, errc{}, correct_float);
test_from_chars<double>(lwg_2403, chars_format::general, 56, errc{}, correct_double);
static_assert(static_cast<float>(correct_double) == twice_rounded_float);
}
// See floating_point_test_cases.hpp.
for (const auto& p : floating_point_test_cases_float) {
test_from_chars<float>(p.first, chars_format::general, strlen(p.first), errc{}, _Bit_cast<float>(p.second));
}
for (const auto& p : floating_point_test_cases_double) {
test_from_chars<double>(p.first, chars_format::general, strlen(p.first), errc{}, _Bit_cast<double>(p.second));
}
#endif
// See float_to_chars_test_cases.hpp in this directory.
for (const auto& t : float_to_chars_test_cases) {
if (t.fmt == chars_format{}) {
test_floating_to_chars(t.value, nullopt, nullopt, t.correct);
} else {
test_floating_to_chars(t.value, t.fmt, nullopt, t.correct);
}
}
// See double_to_chars_test_cases.hpp in this directory.
for (const auto& t : double_to_chars_test_cases) {
if (t.fmt == chars_format{}) {
test_floating_to_chars(t.value, nullopt, nullopt, t.correct);
} else {
test_floating_to_chars(t.value, t.fmt, nullopt, t.correct);
}
}
// See corresponding headers in this directory.
for (const auto& t : float_hex_precision_to_chars_test_cases) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
for (const auto& t : float_fixed_precision_to_chars_test_cases) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
for (const auto& t : float_scientific_precision_to_chars_test_cases) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
for (const auto& t : float_general_precision_to_chars_test_cases) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
for (const auto& t : double_hex_precision_to_chars_test_cases) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
for (const auto& t : double_fixed_precision_to_chars_test_cases_1) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
for (const auto& t : double_fixed_precision_to_chars_test_cases_2) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
for (const auto& t : double_fixed_precision_to_chars_test_cases_3) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
for (const auto& t : double_fixed_precision_to_chars_test_cases_4) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
for (const auto& t : double_scientific_precision_to_chars_test_cases_1) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
for (const auto& t : double_scientific_precision_to_chars_test_cases_2) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
for (const auto& t : double_scientific_precision_to_chars_test_cases_3) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
for (const auto& t : double_scientific_precision_to_chars_test_cases_4) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
for (const auto& t : double_general_precision_to_chars_test_cases) {
test_floating_to_chars(t.value, t.fmt, t.precision, t.correct);
}
}
int main(int argc, char** argv) {
const auto start = chrono::steady_clock::now();
mt19937_64 mt64;
initialize_randomness(mt64, argc, argv);
all_integer_tests();
all_floating_tests(mt64);
const auto finish = chrono::steady_clock::now();
const long long ms = chrono::duration_cast<chrono::milliseconds>(finish - start).count();
puts("PASS");
printf("Randomized test cases: %zu\n", static_cast<std::size_t>(PrefixesToTest * Fractions));
printf("Total time: %lld ms\n", ms);
if (ms < 3'000) {
puts("That was fast. Consider tuning PrefixesToTest and FractionBits to test more cases.");
} else if (ms > 30'000) {
puts("That was slow. Consider tuning PrefixesToTest and FractionBits to test fewer cases.");
}
}
Codebase Browser
llvm