boost/charconv
2
0
Fork 0
mirror of https://github.com/boostorg/charconv.git synced 2026-01-19 16:12:14 +00:00
Code Issues Projects Releases Wiki Activity
Files
develop
charconv/test/to_chars_float_STL_comp.cpp
Matt Borland e52759e589 Fix boost min/max guidelines violations
2025-01-03 13:26:14 -05:00

333 lines
11 KiB
C++
Raw Permalink Blame History

// Copyright 2023 Matt Borland
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
#include <boost/config.hpp>
// https://en.cppreference.com/w/cpp/compiler_support/17
#if (defined(__GNUC__) && __GNUC__ >= 11) || \
((defined(__clang__) && __clang_major__ >= 14 && !defined(__APPLE__)) || (defined(__clang__) && defined(__APPLE__) && __clang_major__ >= 16)) || \
(defined(_MSC_VER) && _MSC_VER >= 1924)
#include <boost/charconv.hpp>
#include <boost/core/lightweight_test.hpp>
#include <system_error>
#include <charconv>
#include <type_traits>
#include <limits>
#include <random>
#include <string>
#include <iomanip>
#include <iostream>
#include <cstring>
#include <cstdint>
#include <cerrno>
template <typename T>
void test_spot(T val, boost::charconv::chars_format fmt = boost::charconv::chars_format::general, int precision = -1)
{
std::chars_format stl_fmt;
std::string fmt_str;
switch (fmt)
{
case boost::charconv::chars_format::general:
stl_fmt = std::chars_format::general;
fmt_str = "general";
break;
case boost::charconv::chars_format::fixed:
stl_fmt = std::chars_format::fixed;
fmt_str = "fixed";
break;
case boost::charconv::chars_format::scientific:
stl_fmt = std::chars_format::scientific;
fmt_str = "scientific";
break;
case boost::charconv::chars_format::hex:
stl_fmt = std::chars_format::hex;
fmt_str = "hex";
break;
// LCOV_EXCL_START
default:
BOOST_UNREACHABLE_RETURN(fmt);
break;
// LCOV_EXCL_STOP
}
char buffer_boost[256];
char buffer_stl[256];
boost::charconv::to_chars_result r_boost;
std::to_chars_result r_stl;
if (precision == -1)
{
r_boost = boost::charconv::to_chars(buffer_boost, buffer_boost + sizeof(buffer_boost), val, fmt);
r_stl = std::to_chars(buffer_stl, buffer_stl + sizeof(buffer_stl), val, stl_fmt);
}
else
{
r_boost = boost::charconv::to_chars(buffer_boost, buffer_boost + sizeof(buffer_boost), val, fmt, precision);
r_stl = std::to_chars(buffer_stl, buffer_stl + sizeof(buffer_stl), val, stl_fmt, precision);
}
BOOST_TEST(r_boost.ec == std::errc());
if (r_stl.ec != std::errc())
{
// STL failed
return; // LCOV_EXCL_LINE
}
const std::ptrdiff_t diff_boost = r_boost.ptr - buffer_boost;
const std::ptrdiff_t diff_stl = r_stl.ptr - buffer_stl;
*r_stl.ptr = '\0';
*r_boost.ptr = '\0';
constexpr T max_value = std::is_same<T, float>::value ? static_cast<T>(1e33F) : static_cast<T>(1e302);
if (val > max_value)
{
return;
}
else if (!(BOOST_TEST_CSTR_EQ(buffer_boost, buffer_stl) && BOOST_TEST_EQ(diff_boost, diff_stl)))
{
// LCOV_EXCL_START
std::cerr << std::setprecision(std::numeric_limits<T>::max_digits10 + 1)
<< "Value: " << val
<< "\nPrecision: " << precision
<< "\nFormat: " << fmt_str
<< "\nBoost: " << buffer_boost
<< "\n STL: " << buffer_stl << std::endl;
// LCOV_EXCL_STOP
}
}
template <typename T>
void random_test(boost::charconv::chars_format fmt = boost::charconv::chars_format::general, T min_val = 0, T max_val = (std::numeric_limits<T>::max)())
{
std::mt19937_64 gen(42);
std::uniform_real_distribution<T> dist(min_val, max_val);
for (int i = -1; i < std::numeric_limits<T>::digits10; ++i)
{
// TODO(mborland): fix integer part rounding
if (fmt == boost::charconv::chars_format::hex && (i == 0 || i == 1 || i == 2))
{
continue;
}
for (std::size_t j = 0; j < 1000; ++j)
{
test_spot(dist(gen), fmt, i);
}
}
// Test some extended precision arguments
if (fmt != boost::charconv::chars_format::fixed || max_val < T(1e10))
{
for (int i = 40; i < 50; ++i)
{
for (std::size_t j = 0; j < 10; ++j)
{
test_spot(dist(gen), fmt, i);
}
}
}
}
template <typename T>
void non_finite_test(boost::charconv::chars_format fmt = boost::charconv::chars_format::general)
{
for (int i = -1; i <= 0; ++i)
{
test_spot(std::numeric_limits<T>::infinity(), fmt, i);
test_spot(-std::numeric_limits<T>::infinity(), fmt, i);
test_spot(std::numeric_limits<T>::quiet_NaN(), fmt, i);
#if (defined(__clang__) && __clang_major__ >= 16 && defined(__APPLE__)) || defined(_MSC_VER)
//
// Newer apple clang and MSVC both give the following:
//
// -qNaN = -nan(ind)
//
test_spot(-std::numeric_limits<T>::quiet_NaN(), fmt, i);
#endif
#if (defined(__clang__) && __clang_major__ >= 16 && defined(__APPLE__))
//
// Newer clang also gives the following:
//
// sNaN = nan(snan)
// -sNaN = -nan(snan)
//
test_spot(std::numeric_limits<T>::signaling_NaN(), fmt, i);
test_spot(-std::numeric_limits<T>::signaling_NaN(), fmt, i);
#endif
}
}
template <typename T>
void fixed_test()
{
constexpr T upper_bound = std::is_same<T, double>::value ? T((std::numeric_limits<std::uint64_t>::max)()) :
T((std::numeric_limits<std::uint32_t>::max)());
std::mt19937_64 gen(42);
std::uniform_real_distribution<T> dist(1, upper_bound);
for (std::size_t i = 0; i < 1000; ++i)
{
for (int prec = 0; prec < 100; ++prec)
{
test_spot(dist(gen), boost::charconv::chars_format::fixed, prec);
}
}
}
// Clang 16 (most recent at time of writing) only has integral from_chars implemented
#if (defined(__GNUC__) && __GNUC__ >= 11) || (defined(_MSC_VER) && _MSC_VER >= 1924)
template <typename T>
void test_roundtrip( T value )
{
char buffer[ 256 ];
const auto r = std::to_chars( buffer, buffer + sizeof( buffer ), value );
T v2 = 0;
std::from_chars( buffer, r.ptr, v2 );
if( BOOST_TEST_EQ( v2, value ) )
{
}
else
{
// LCOV_EXCL_START
#ifdef BOOST_CHARCONV_DEBUG
std::cerr << std::setprecision(17)
<< " Value: " << value
<< "\n To chars: " << std::string( buffer, r.ptr )
<< "\nFrom chars: " << v2 << std::endl;
#else
std::cerr << "... test failure for value=" << value << "; buffer='" << std::string( buffer, r.ptr ) << "'" << std::endl;
#endif
// LCOV_EXCL_STOP
}
}
#endif
int main()
{
// General format
random_test<float>();
random_test<double>();
#ifndef BOOST_CHARCONV_UNSUPPORTED_LONG_DOUBLE
random_test<long double>();
#endif
test_spot<double>(0.0);
test_spot<double>(-0.0);
// Good for debugging comparison but too many ideosyncracies
//random_test<float>(boost::charconv::chars_format::general, -1e5F, 1e5F);
//random_test<double>(boost::charconv::chars_format::general, -1e5, 1e5);
//random_test<long double>(boost::charconv::chars_format::general, -1e5L, 1e5L);
// Scientific
random_test<float>(boost::charconv::chars_format::scientific);
random_test<double>(boost::charconv::chars_format::scientific);
#ifndef BOOST_CHARCONV_UNSUPPORTED_LONG_DOUBLE
random_test<long double>(boost::charconv::chars_format::scientific);
#endif
test_spot<double>(0.0, boost::charconv::chars_format::scientific);
test_spot<double>(-0.0, boost::charconv::chars_format::scientific);
random_test<float>(boost::charconv::chars_format::scientific, -1e5F, 1e5F);
random_test<double>(boost::charconv::chars_format::scientific, -1e5, 1e5);
// TODO(mborland): Use Ryu to fix terminal rounding rather than string manipulation
//random_test<long double>(boost::charconv::chars_format::scientific, -1e5L, 1e5L);
// Hex
random_test<float>(boost::charconv::chars_format::hex);
random_test<double>(boost::charconv::chars_format::hex);
#ifndef BOOST_CHARCONV_UNSUPPORTED_LONG_DOUBLE
random_test<long double>(boost::charconv::chars_format::hex);
#endif
#if !defined(_LIBCPP_VERSION)
random_test<float>(boost::charconv::chars_format::hex, -1e5F, 1e5F);
random_test<double>(boost::charconv::chars_format::hex, -1e5, 1e5);
#ifndef BOOST_CHARCONV_UNSUPPORTED_LONG_DOUBLE
random_test<long double>(boost::charconv::chars_format::hex, -1e5L, 1e5L);
#endif
#endif
test_spot<double>(-9.52743282403084637e+306, boost::charconv::chars_format::hex);
test_spot<double>(-9.52743282403084637e-306, boost::charconv::chars_format::hex);
test_spot<double>(-9.52743282403084637e+305, boost::charconv::chars_format::hex);
test_spot<double>(-9.52743282403084637e-305, boost::charconv::chars_format::hex);
test_spot<double>(0.0, boost::charconv::chars_format::hex);
test_spot<double>(-0.0, boost::charconv::chars_format::hex);
// Fixed
fixed_test<float>();
fixed_test<double>();
test_spot<double>(0.0, boost::charconv::chars_format::fixed);
test_spot<double>(-0.0, boost::charconv::chars_format::fixed);
test_spot<double>(0.0, boost::charconv::chars_format::fixed, 10);
test_spot<double>(-0.0, boost::charconv::chars_format::fixed, 10);
// Various non-finite values
non_finite_test<float>();
non_finite_test<double>();
non_finite_test<float>(boost::charconv::chars_format::scientific);
non_finite_test<double>(boost::charconv::chars_format::scientific);
non_finite_test<float>(boost::charconv::chars_format::hex);
non_finite_test<double>(boost::charconv::chars_format::hex);
#ifndef BOOST_CHARCONV_UNSUPPORTED_LONG_DOUBLE
non_finite_test<long double>();
non_finite_test<long double>(boost::charconv::chars_format::scientific);
non_finite_test<long double>(boost::charconv::chars_format::hex);
#endif
#if (defined(__GNUC__) && __GNUC__ >= 11) || (defined(_MSC_VER) && _MSC_VER >= 1924)
// Selected additional values
// These are tested on boost in roundtrip.cpp
test_roundtrip<double>(1.10393929655481808e+308);
test_roundtrip<double>(-1.47902377240341038e+308);
test_roundtrip<double>(-2.13177235460600904e+307);
test_roundtrip<double>(8.60473951619578187e+307);
test_roundtrip<double>(-2.97613696314797352e+306);
test_roundtrip<float>(3.197633022e+38F);
test_roundtrip<float>(2.73101834e+38F);
test_roundtrip<float>(3.394053352e+38F);
test_roundtrip<float>(5.549256619e+37F);
test_roundtrip<float>(8.922125027e+34F);
#endif
// Reported in issue #93
test_spot<float>(3.3F);
test_spot<double>(3.3);
#ifndef BOOST_CHARCONV_UNSUPPORTED_LONG_DOUBLE
// Updated tools give weird sporadic rounding errors that I can't duplicate locally
// test_spot<long double>(3.3L);
#endif
return boost::report_errors();
}
#else
int main()
{
return 0;
}
#endif
Reference in New Issue View Git Blame Copy Permalink