coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-10-28 18:07:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'feature/denom-int-to-string' into development

Browse Source
This commit is contained in:
John Wellbelove 2021-09-01 16:48:34 +01:00
commit 2be72e7040
16 changed files with 1389 additions and 453 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

352
include/etl/private/to_string_helper.h
View File

@ -88,7 +88,7 @@ namespace etl
void add_boolean(const bool value,
TIString& str,
const etl::basic_format_spec<TIString>& format,
bool append)
const bool append)
{
typedef typename TIString::value_type type;
typedef typename TIString::iterator iterator;
@ -240,8 +240,31 @@ namespace etl
/// Helper function for floating point integral and fractional.
//***************************************************************************
template <typename TIString>
void add_integral_fractional(const workspace_t integral,
const workspace_t fractional,
void add_integral_and_fractional(const uint32_t integral,
const uint32_t fractional,
TIString& str,
const etl::basic_format_spec<TIString>& integral_format,
const etl::basic_format_spec<TIString>& fractional_format,
const bool negative)
{
typedef typename TIString::value_type type;
etl::private_to_string::add_integral(integral, str, integral_format, true, negative);
if (fractional_format.get_precision() > 0)
{
str.push_back(type('.'));
etl::private_to_string::add_integral(fractional, str, fractional_format, true, false);
}
}
#if ETL_USING_64BIT_TYPES
//***************************************************************************
/// Helper function for floating point integral and fractional.
//***************************************************************************
template <typename TIString>
void add_integral_and_fractional(const uint64_t integral,
const uint64_t fractional,
TIString& str,
const etl::basic_format_spec<TIString>& integral_format,
const etl::basic_format_spec<TIString>& fractional_format,
@ -257,15 +280,16 @@ namespace etl
etl::private_to_string::add_integral(fractional, str, fractional_format, true, false);
}
}
#endif
//***************************************************************************
/// Helper function for floating point.
//***************************************************************************
template <typename T, typename TIString>
void add_floating_point(T value,
void add_floating_point(const T value,
TIString& str,
const etl::basic_format_spec<TIString>& format,
bool append)
const bool append)
{
typedef typename TIString::iterator iterator;
typedef typename TIString::value_type type;
@ -292,7 +316,7 @@ namespace etl
etl::basic_format_spec<TIString> fractional_format = integral_format;
fractional_format.width(integral_format.get_precision()).fill(type('0')).right();
workspace_t multiplier = 1;
uint32_t multiplier = 1U;
for (uint32_t i = 0U; i < fractional_format.get_precision(); ++i)
{
@ -300,25 +324,103 @@ namespace etl
}
// Find the integral part of the floating point
T f_integral = (value < T(0.0) ? ceil(value) : floor(value));
workspace_t integral = static_cast<workspace_t>(f_integral);
T f_integral = floor(etl::absolute(value));
uint32_t integral = static_cast<uint32_t>(f_integral);
// Find the fractional part of the floating point.
workspace_t fractional = etl::absolute(static_cast<workspace_t>(round((value - f_integral) * multiplier)));
uint32_t fractional = static_cast<uint32_t>(round((etl::absolute(value) - f_integral) * multiplier));
// Check for a rounding carry to the integral.
if (fractional == multiplier)
{
++integral;
fractional = 0;
fractional = 0U;
}
etl::private_to_string::add_integral_fractional(integral, fractional, str, integral_format, fractional_format, etl::is_negative(value));
etl::private_to_string::add_integral_and_fractional(integral, fractional, str, integral_format, fractional_format, etl::is_negative(value));
}
etl::private_to_string::add_alignment(str, start, format);
}
//***************************************************************************
/// Helper function for denominated integers.
//***************************************************************************
template <typename T, typename TIString>
void add_integral_denominated(const T value,
const uint32_t denominator_exponent,
TIString& str,
const etl::basic_format_spec<TIString>& format,
const bool append = false)
{
typedef typename TIString::iterator iterator;
typedef typename TIString::value_type type;
typedef typename etl::make_unsigned<T>::type working_t;
if (!append)
{
str.clear();
}
iterator start = str.end();
// Caculate the denominator.
working_t denominator = 1U;
for (uint32_t i = 0U; i < denominator_exponent; ++i)
{
denominator *= 10U;
}
working_t abs_value = etl::absolute(value);
// Figure out how many decimal digits we have in the value.
const uint32_t& original_decimal_digits = denominator_exponent;
// How many decimal digits are we displaying.
const uint32_t displayed_decimal_digits = (format.get_precision() > original_decimal_digits) ? original_decimal_digits : format.get_precision();
// Format for the integral part.
etl::basic_format_spec<TIString> integral_format = format;
integral_format.decimal().width(0U);
// Format for the fractional part.
etl::basic_format_spec<TIString> fractional_format = integral_format;
fractional_format.precision(displayed_decimal_digits).width(displayed_decimal_digits).fill(type('0')).right();
// Do we need to check for rounding?
if (original_decimal_digits > displayed_decimal_digits)
{
// Which digit to adjust?
uint32_t count = original_decimal_digits - fractional_format.get_width();
// The 'round-away-from-zero' value.
uint32_t rounding = 5U;
while (count-- > 1U)
{
rounding *= 10U;
}
abs_value += rounding;
}
// Split the value into integral and fractional.
working_t integral = abs_value / denominator;
working_t fractional = abs_value % denominator;
// Move the fractional part to the right place.
uint32_t count = original_decimal_digits - fractional_format.get_width();
while (count-- > 0U)
{
fractional /= 10U;
}
// Create the string.
etl::private_to_string::add_integral_and_fractional(integral, fractional, str, integral_format, fractional_format, etl::is_negative(value));
etl::private_to_string::add_alignment(str, start, format);
}
//***************************************************************************
/// Helper function for pointers.
//***************************************************************************
@ -326,7 +428,7 @@ namespace etl
void add_pointer(const volatile void* value,
TIString& str,
const etl::basic_format_spec<TIString>& format,
bool append)
const bool append)
{
uintptr_t p = reinterpret_cast<uintptr_t>(value);
@ -340,7 +442,7 @@ namespace etl
void add_string(const TIString& value,
TIString& str,
const etl::basic_format_spec<TIString>& format,
bool append)
const bool append)
{
if (!append)
{
@ -361,7 +463,7 @@ namespace etl
void add_string_view(const TSringView& value,
TIString& str,
const etl::basic_format_spec<TIString>& format,
bool append)
const bool append)
{
if (!append)
{
@ -378,28 +480,13 @@ namespace etl
//*********************************************************************************************************
//***************************************************************************
/// For booleans. Default format spec.
//***************************************************************************
template <typename TIString>
const TIString& to_string(const bool value,
TIString& str,
bool append = false)
{
etl::basic_format_spec<TIString> format;
etl::private_to_string::add_boolean(value, str, format, append);
return str;
}
//***************************************************************************
/// For booleans. Supplied format spec.
/// For booleans.
//***************************************************************************
template <typename TIString>
const TIString& to_string(const bool value,
TIString& str,
const etl::basic_format_spec<TIString>& format,
bool append = false)
const bool append = false)
{
etl::private_to_string::add_boolean(value, str, format, append);
@ -407,244 +494,115 @@ namespace etl
}
//***************************************************************************
/// For pointers. Default format spec.
//***************************************************************************
template <typename TIString>
const TIString& to_string(const volatile void* value,
TIString& str,
bool append = false)
{
etl::basic_format_spec<TIString> format;
etl::private_to_string::add_pointer(value, str, format, append);
return str;
}
//***************************************************************************
/// For pointers. Supplied format spec.
/// For pointers.
//***************************************************************************
template <typename TIString>
const TIString& to_string(const volatile void* value,
TIString& str,
const etl::basic_format_spec<TIString>& format,
bool append = false)
const bool append = false)
{
etl::private_to_string::add_pointer(value, str, format, append);
return str;
}
#if ETL_NOT_USING_64BIT_TYPES
#if ETL_USING_64BIT_TYPES
//***************************************************************************
/// For signed integrals less than 64 bits. Default format spec.
/// For integrals less than 64 bits.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_signed<T>::value &&
!etl::is_same<T, bool>::value>::value, const TIString& > ::type
to_string(const T value, TIString& str, bool append = false)
!etl::is_same<T, bool>::value &&
!etl::is_one_of<T, int64_t, uint64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, const bool append = false)
{
etl::basic_format_spec<TIString> format;
typedef typename etl::conditional<etl::is_signed<T>::value, int32_t, uint32_t>::type type;
etl::private_to_string::add_integral(int32_t(value), str, format, append, etl::is_negative(value));
etl::private_to_string::add_integral(type(value), str, format, append, etl::is_negative(value));
return str;
}
//***************************************************************************
/// For signed integrals less than 64 bits. Supplied format spec.
/// For 64 bit integrals.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_signed<T>::value &&
!etl::is_same<T, bool>::value>::value, const TIString& > ::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, bool append = false)
!etl::is_same<T, bool>::value &&
etl::is_one_of<T, int64_t, uint64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, const bool append = false)
{
etl::private_to_string::add_integral(int32_t(value), str, format, append, etl::is_negative(value));
etl::private_to_string::add_integral(value, str, format, append, etl::is_negative(value));
return str;
}
//***************************************************************************
/// For unsigned integrals less than 64 bits. Default format spec.
/// For denominated integrals less than 64 bits.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_unsigned<T>::value &&
!etl::is_same<T, bool>::value>::value, const TIString& > ::type
to_string(const T value, TIString& str, bool append = false)
!etl::is_same<T, bool>::value &&
!etl::is_one_of<T, int64_t, uint64_t>::value, const TIString&>::type
to_string(const T value, uint32_t denominator_exponant, TIString& str, const etl::basic_format_spec<TIString>& format, const bool append = false)
{
etl::basic_format_spec<TIString> format;
typedef typename etl::conditional<etl::is_signed<T>::value, int32_t, uint32_t>::type type;
etl::private_to_string::add_integral(uint32_t(value), str, format, append, false);
etl::private_to_string::add_integral_denominated(type(value), denominator_exponant, str, format, append);
return str;
}
//***************************************************************************
/// For unsigned integrals less than 64 bits. Supplied format spec.
/// For denominated 64 bit integrals.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_unsigned<T>::value &&
!etl::is_same<T, bool>::value>::value, const TIString& > ::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, bool append = false)
typename etl::enable_if<etl::is_integral<T>::value&&
!etl::is_same<T, bool>::value&&
etl::is_one_of<T, int64_t, uint64_t>::value, const TIString&>::type
to_string(const T value, uint32_t denominator_exponant, TIString& str, const etl::basic_format_spec<TIString>& format, const bool append = false)
{
etl::private_to_string::add_integral(uint32_t(value), str, format, append, false);
etl::private_to_string::add_integral_denominated(value, denominator_exponant, str, format, append);
return str;
}
#else
//***************************************************************************
/// For signed integrals less than 64 bits. Default format spec.
/// For integrals less than 64 bits.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_signed<T>::value &&
!etl::is_same<T, bool>::value &&
!etl::is_same<T, int64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, bool append = false)
!etl::is_same<T, bool>::value>::value, const TIString& > ::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, const bool append = false)
{
etl::basic_format_spec<TIString> format;
typedef typename etl::conditional<etl::is_signed<T>::value, int32_t, uint32_t>::type type;
etl::private_to_string::add_integral(int32_t(value), str, format, append, etl::is_negative(value));
etl::private_to_string::add_integral(type(value), str, format, append, false);
return str;
}
//***************************************************************************
/// For signed integrals less than 64 bits. Supplied format spec.
/// For denominated integrals less than 64 bits.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_signed<T>::value &&
!etl::is_same<T, bool>::value &&
!etl::is_same<T, int64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, bool append = false)
!etl::is_same<T, bool>::value>::value, const TIString& > ::type
to_string(const T value, uint32_t denominator_exponant, TIString& str, const etl::basic_format_spec<TIString>& format, const bool append = false)
{
etl::private_to_string::add_integral(int32_t(value), str, format, append, etl::is_negative(value));
return str;
}
//***************************************************************************
/// For unsigned integrals less than 64 bits. Default format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_unsigned<T>::value &&
!etl::is_same<T, bool>::value &&
!etl::is_same<T, uint64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, bool append = false)
{
etl::basic_format_spec<TIString> format;
etl::private_to_string::add_integral(uint32_t(value), str, format, append, false);
return str;
}
//***************************************************************************
/// For unsigned integrals less than 64 bits. Supplied format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_unsigned<T>::value &&
!etl::is_same<T, bool>::value &&
!etl::is_same<T, uint64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, bool append = false)
{
etl::private_to_string::add_integral(uint32_t(value), str, format, append, false);
return str;
}
//***************************************************************************
/// For signed 64 bit integrals. Default format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_signed<T>::value &&
!etl::is_same<T, bool>::value &&
etl::is_same<T, int64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, bool append = false)
{
etl::basic_format_spec<TIString> format;
etl::private_to_string::add_integral(int64_t(value), str, format, append, etl::is_negative(value));
return str;
}
//***************************************************************************
/// For signed 64 bit integrals. Supplied format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_signed<T>::value &&
!etl::is_same<T, bool>::value &&
etl::is_same<T, int64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, bool append = false)
{
etl::private_to_string::add_integral(int64_t(value), str, format, append, etl::is_negative(value));
return str;
}
//***************************************************************************
/// For unsigned 64 bit integrals. Default format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_unsigned<T>::value &&
!etl::is_same<T, bool>::value &&
etl::is_same<T, uint64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, bool append = false)
{
etl::basic_format_spec<TIString> format;
etl::private_to_string::add_integral(uint64_t(value), str, format, append, false);
return str;
}
//***************************************************************************
/// For unsigned 64 bit integrals. Supplied format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_integral<T>::value &&
etl::is_unsigned<T>::value &&
!etl::is_same<T, bool>::value &&
etl::is_same<T, uint64_t>::value, const TIString&>::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, bool append = false)
{
etl::private_to_string::add_integral(uint64_t(value), str, format, append, false);
etl::private_to_string::add_integral_denominated(type(value), denominator_exponant, str, format, append, false);
return str;
}
#endif
//***************************************************************************
/// For floating point. Default format spec.
/// For floating point.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_floating_point<T>::value, const TIString&>::type
to_string(const T value, TIString& str, bool append = false)
{
etl::basic_format_spec<TIString> format;
etl::private_to_string::add_floating_point(value, str, format, append);
return str;
}
//***************************************************************************
/// For floating point. Supplied format spec.
//***************************************************************************
template <typename T, typename TIString>
typename etl::enable_if<etl::is_floating_point<T>::value, const TIString&>::type
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, bool append = false)
to_string(const T value, TIString& str, const etl::basic_format_spec<TIString>& format, const bool append = false)
{
etl::private_to_string::add_floating_point(value, str, format, append);

24
include/etl/to_string.h
View File

@ -65,6 +65,30 @@ namespace etl
return private_to_string::to_string(value, str, format, append);
}
//***************************************************************************
/// Default format spec.
/// !etl::istring && !etl::string_view
//***************************************************************************
template <typename T>
typename etl::enable_if<!etl::is_same<T, etl::istring>::value && !etl::is_same<T, etl::string_view>::value, const etl::istring&>::type
to_string(const T value, uint32_t denominator_exponent, etl::istring& str, bool append = false)
{
etl::format_spec format;
return private_to_string::to_string(value, denominator_exponent, str, format, append);
}
//***************************************************************************
/// Supplied format spec.
/// !etl::istring && !etl::string_view
//***************************************************************************
template <typename T>
typename etl::enable_if<!etl::is_same<T, etl::istring>::value && !etl::is_same<T, etl::string_view>::value, const etl::istring&>::type
to_string(const T value, uint32_t denominator_exponent, etl::istring& str, const etl::format_spec& format, bool append = false)
{
return private_to_string::to_string(value, denominator_exponent, str, format, append);
}
//***************************************************************************
/// Default format spec.
/// etl::istring

25
include/etl/to_u16string.h
View File

@ -65,6 +65,31 @@ namespace etl
return private_to_string::to_string(value, str, format, append);
}
//***************************************************************************
/// Default format spec.
/// !etl::iu16string && !etl::u16string_view
//***************************************************************************
template <typename T>
typename etl::enable_if<!etl::is_same<T, etl::iu16string>::value && !etl::is_same<T, etl::u16string_view>::value, const etl::iu16string&>::type
to_string(const T value, uint32_t denominator_exponent, etl::iu16string& str, bool append = false)
{
etl::u16format_spec format;
return private_to_string::to_string(value, denominator_exponent, str, format, append);
}
//***************************************************************************
/// Supplied format spec.
/// !etl::u16string_view && !etl::u16string_view
//***************************************************************************
template <typename T>
typename etl::enable_if<!etl::is_same<T, etl::iu16string>::value && !etl::is_same<T, etl::u16string_view>::value, const etl::iu16string&>::type
to_string(const T value, uint32_t denominator_exponent, etl::iu16string& str, const etl::u16format_spec& format, bool append = false)
{
return private_to_string::to_string(value, denominator_exponent, str, format, append);
}
//***************************************************************************
/// Default format spec.
/// etl::iu16string

24
include/etl/to_u32string.h
View File

@ -65,6 +65,30 @@ namespace etl
return private_to_string::to_string(value, str, format, append);
}
//***************************************************************************
/// Default format spec.
/// !etl::iu32string && !etl::u16string_view
//***************************************************************************
template <typename T>
typename etl::enable_if<!etl::is_same<T, etl::iu32string>::value && !etl::is_same<T, etl::u16string_view>::value, const etl::iu32string&>::type
to_string(const T value, uint32_t denominator_exponent, etl::iu32string& str, bool append = false)
{
etl::u32format_spec format;
return private_to_string::to_string(value, denominator_exponent, str, format, append);
}
//***************************************************************************
/// Supplied format spec.
/// !etl::u16string_view && !etl::u16string_view
//***************************************************************************
template <typename T>
typename etl::enable_if<!etl::is_same<T, etl::iu32string>::value && !etl::is_same<T, etl::u16string_view>::value, const etl::iu32string&>::type
to_string(const T value, uint32_t denominator_exponent, etl::iu32string& str, const etl::u32format_spec& format, bool append = false)
{
return private_to_string::to_string(value, denominator_exponent, str, format, append);
}
//***************************************************************************
/// Default format spec.
/// etl::iu32string

24
include/etl/to_wstring.h
View File

@ -65,6 +65,30 @@ namespace etl
return private_to_string::to_string(value, str, format, append);
}
//***************************************************************************
/// Default format spec.
/// !etl::iu32string && !etl::u16string_view
//***************************************************************************
template <typename T>
typename etl::enable_if<!etl::is_same<T, etl::iwstring>::value && !etl::is_same<T, etl::u16string_view>::value, const etl::iwstring&>::type
to_string(const T value, uint32_t denominator_exponent, etl::iwstring& str, bool append = false)
{
etl::wformat_spec format;
return private_to_string::to_string(value, denominator_exponent, str, format, append);
}
//***************************************************************************
/// Supplied format spec.
/// !etl::u16string_view && !etl::u16string_view
//***************************************************************************
template <typename T>
typename etl::enable_if<!etl::is_same<T, etl::iwstring>::value && !etl::is_same<T, etl::u16string_view>::value, const etl::iwstring&>::type
to_string(const T value, uint32_t denominator_exponent, etl::iwstring& str, const etl::wformat_spec& format, bool append = false)
{
return private_to_string::to_string(value, denominator_exponent, str, format, append);
}
//***************************************************************************
/// Default format spec.
/// etl::iwstring

2
include/etl/variant.h
View File

@ -31,6 +31,8 @@ SOFTWARE.
#ifndef ETL_VARIANT_INCLUDED
#define ETL_VARIANT_INCLUDED
#include "platform.h"
#if !ETL_CPP11_SUPPORTED || ETL_USE_LEGACY_VARIANT
#include "private/variant_legacy.h"
#else

2
include/etl/version.h
View File

@ -39,7 +39,7 @@ SOFTWARE.
#define ETL_VERSION_MAJOR 20
#define ETL_VERSION_MINOR 16
#define ETL_VERSION_PATCH 1
#define ETL_VERSION_PATCH 2
#define ETL_VERSION ETL_STRINGIFY(ETL_VERSION_MAJOR) "." ETL_STRINGIFY(ETL_VERSION_MINOR) "." ETL_STRINGIFY(ETL_VERSION_PATCH)
#define ETL_VERSION_W ETL_STRINGIFY(ETL_VERSION_MAJOR) L"." ETL_STRINGIFY(ETL_VERSION_MINOR) L"." ETL_STRINGIFY(ETL_VERSION_PATCH)
#define ETL_VERSION_U16 ETL_STRINGIFY(ETL_VERSION_MAJOR) u"." ETL_STRINGIFY(ETL_VERSION_MINOR) u"." ETL_STRINGIFY(ETL_VERSION_PATCH)

2
library.json
View File

@ -1,6 +1,6 @@
{
"name": "ETL Embedded Template Library",
"version": "20.16.1",
"version": "20.16.2",
"author s": {
"name": "John Wellbelove",
"email": "john.wellbelove@etlcpp.com"

2
library.properties
View File

@ -1,5 +1,5 @@
name=Embedded Template Library ETL
version=20.16.1
version=20.16.2
author= John Wellbelove <john.wellbelove@etlcpp.com>
maintainer=John Wellbelove <john.wellbelove@etlcpp.com>
license=MIT

2
meson.build
View File

@ -8,7 +8,7 @@ project('PROJECT_NAME',
'cpp_std=c++17', 'build.cpp_std=c++17',
],
meson_version: '>=0.54.0',
version: '20.16.1'
version: '20.16.2'
)
######################

3
support/Release notes.txt
View File

@ -1,3 +1,6 @@
===============================================================================
20.16.2 Fixed incomplete template specialisations in type_traits.h for C++11
===============================================================================
20.16.1
Fix for etl::mutex::try_lock() for GCC

349
test/test_to_string.cpp
View File

@ -69,15 +69,15 @@ namespace
CHECK(etl::string<20>(STR("2147483648")) == etl::to_string(uint32_t(2147483648ul), str));
CHECK(etl::string<20>(STR("9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str));
CHECK(etl::string<20>(STR("127")) == etl::to_string(int8_t(127), str));
CHECK(etl::string<20>(STR("32767")) == etl::to_string(int16_t(32767), str));
CHECK(etl::string<20>(STR("2147483647")) == etl::to_string(int32_t(2147483647ll), str));
CHECK(etl::string<20>(STR("9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str));
CHECK(etl::string<20>(STR("127")) == etl::to_string(int8_t(INT8_MAX), str));
CHECK(etl::string<20>(STR("32767")) == etl::to_string(int16_t(INT16_MAX), str));
CHECK(etl::string<20>(STR("2147483647")) == etl::to_string(int32_t(INT32_MAX), str));
CHECK(etl::string<20>(STR("9223372036854775807")) == etl::to_string(int64_t(INT64_MAX), str));
CHECK(etl::string<20>(STR("-128")) == etl::to_string(int8_t(-128), str));
CHECK(etl::string<20>(STR("-32768")) == etl::to_string(int16_t(-32768), str));
CHECK(etl::string<20>(STR("-2147483648")) == etl::to_string(int32_t(-2147483648ll), str));
CHECK(etl::string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str));
CHECK(etl::string<20>(STR("-128")) == etl::to_string(int8_t(INT8_MIN), str));
CHECK(etl::string<20>(STR("-32768")) == etl::to_string(int16_t(INT16_MIN), str));
CHECK(etl::string<20>(STR("-2147483648")) == etl::to_string(int32_t(INT32_MIN), str));
CHECK(etl::string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str));
}
//*************************************************************************
@ -85,7 +85,7 @@ namespace
{
etl::string<120> str;
CHECK(etl::string<120>(STR("0")) == etl::to_string(uint8_t(0), str, true));
CHECK(etl::string<120>(STR("0")) == etl::to_string(uint8_t(0), str, true));
CHECK(etl::string<120>(STR("00")) == etl::to_string(uint16_t(0), str, true));
CHECK(etl::string<120>(STR("000")) == etl::to_string(uint32_t(0), str, true));
CHECK(etl::string<120>(STR("0000")) == etl::to_string(uint64_t(0), str, true));
@ -95,15 +95,15 @@ namespace
CHECK(etl::string<120>(STR("0000128327682147483648")) == etl::to_string(uint32_t(2147483648ul), str, true));
CHECK(etl::string<120>(STR("00001283276821474836489223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, true));
CHECK(etl::string<120>(STR("00001283276821474836489223372036854775808127")) == etl::to_string(int8_t(127), str, true));
CHECK(etl::string<120>(STR("0000128327682147483648922337203685477580812732767")) == etl::to_string(int16_t(32767), str, true));
CHECK(etl::string<120>(STR("00001283276821474836489223372036854775808127327672147483647")) == etl::to_string(int32_t(2147483647ll), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, true));
CHECK(etl::string<120>(STR("00001283276821474836489223372036854775808127")) == etl::to_string(int8_t(INT8_MAX), str, true));
CHECK(etl::string<120>(STR("0000128327682147483648922337203685477580812732767")) == etl::to_string(int16_t(INT16_MAX), str, true));
CHECK(etl::string<120>(STR("00001283276821474836489223372036854775808127327672147483647")) == etl::to_string(int32_t(INT32_MAX), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")) == etl::to_string(int64_t(INT64_MAX), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")) == etl::to_string(int8_t(-128), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")) == etl::to_string(int16_t(-32768), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")) == etl::to_string(int8_t(INT8_MIN), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")) == etl::to_string(int16_t(INT16_MIN), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")) == etl::to_string(int32_t(INT32_MIN), str, true));
CHECK(etl::string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str, true));
}
//*************************************************************************
@ -115,7 +115,7 @@ namespace
etl::to_string(uint8_t(0), str, format);
CHECK(etl::string<20>(STR("###################0")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::string<20>(STR("###################0")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::string<20>(STR("###################0")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::string<20>(STR("###################0")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::string<20>(STR("###################0")) == etl::to_string(uint64_t(0), str, format));
@ -125,15 +125,15 @@ namespace
CHECK(etl::string<20>(STR("##########2147483648")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::string<20>(STR("#9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::string<20>(STR("#################127")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::string<20>(STR("###############32767")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::string<20>(STR("##########2147483647")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::string<20>(STR("#9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::string<20>(STR("#################127")) == etl::to_string(int8_t(INT8_MAX), str, format));
CHECK(etl::string<20>(STR("###############32767")) == etl::to_string(int16_t(INT16_MAX), str, format));
CHECK(etl::string<20>(STR("##########2147483647")) == etl::to_string(int32_t(INT32_MAX), str, format));
CHECK(etl::string<20>(STR("#9223372036854775807")) == etl::to_string(int64_t(INT64_MAX), str, format));
CHECK(etl::string<20>(STR("################-128")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::string<20>(STR("##############-32768")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::string<20>(STR("#########-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::string<20>(STR("################-128")) == etl::to_string(int8_t(INT8_MIN), str, format));
CHECK(etl::string<20>(STR("##############-32768")) == etl::to_string(int16_t(INT16_MIN), str, format));
CHECK(etl::string<20>(STR("#########-2147483648")) == etl::to_string(int32_t(INT32_MIN), str, format));
CHECK(etl::string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str, format));
}
//*************************************************************************
@ -143,7 +143,7 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#')).left();
CHECK(etl::string<20>(STR("0###################")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::string<20>(STR("0###################")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::string<20>(STR("0###################")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::string<20>(STR("0###################")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::string<20>(STR("0###################")) == etl::to_string(uint64_t(0), str, format));
@ -153,15 +153,15 @@ namespace
CHECK(etl::string<20>(STR("2147483648##########")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::string<20>(STR("9223372036854775808#")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::string<20>(STR("127#################")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::string<20>(STR("32767###############")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::string<20>(STR("2147483647##########")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::string<20>(STR("9223372036854775807#")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::string<20>(STR("127#################")) == etl::to_string(int8_t(INT8_MAX), str, format));
CHECK(etl::string<20>(STR("32767###############")) == etl::to_string(int16_t(INT16_MAX), str, format));
CHECK(etl::string<20>(STR("2147483647##########")) == etl::to_string(int32_t(INT32_MAX), str, format));
CHECK(etl::string<20>(STR("9223372036854775807#")) == etl::to_string(int64_t(INT64_MAX), str, format));
CHECK(etl::string<20>(STR("-128################")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::string<20>(STR("-32768##############")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::string<20>(STR("-2147483648#########")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::string<20>(STR("-128################")) == etl::to_string(int8_t(INT8_MIN), str, format));
CHECK(etl::string<20>(STR("-32768##############")) == etl::to_string(int16_t(INT16_MIN), str, format));
CHECK(etl::string<20>(STR("-2147483648#########")) == etl::to_string(int32_t(INT32_MIN), str, format));
CHECK(etl::string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str, format));
}
//*************************************************************************
@ -169,7 +169,7 @@ namespace
{
etl::string<64> str;
CHECK(etl::string<64>(STR("00000000")) == etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::string<64>(STR("00000000")) == etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::string<64>(STR("0000000000000000")) == etl::to_string(uint16_t(0), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::string<64>(STR("00000000000000000000000000000000")) == etl::to_string(uint32_t(0), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::string<64>(STR("0000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(2).width(64).fill(STR('0'))));
@ -179,15 +179,15 @@ namespace
CHECK(etl::string<64>(STR("10000000000000000000000000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::string<64>(STR("01111111")) == etl::to_string(int8_t(127), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::string<64>(STR("0111111111111111")) == etl::to_string(int16_t(32767), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::string<64>(STR("01111111111111111111111111111111")) == etl::to_string(int32_t(2147483647ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::string<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::string<64>(STR("01111111")) == etl::to_string(int8_t(INT8_MAX), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::string<64>(STR("0111111111111111")) == etl::to_string(int16_t(INT16_MAX), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::string<64>(STR("01111111111111111111111111111111")) == etl::to_string(int32_t(INT32_MAX), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::string<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")) == etl::to_string(int64_t(INT64_MAX), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::string<64>(STR("10000000")) == etl::to_string(int8_t(-128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::string<64>(STR("1000000000000000")) == etl::to_string(int16_t(-32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::string<64>(STR("10000000000000000000000000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::string<64>(STR("10000000")) == etl::to_string(int8_t(INT8_MIN), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::string<64>(STR("1000000000000000")) == etl::to_string(int16_t(INT16_MIN), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::string<64>(STR("10000000000000000000000000000000")) == etl::to_string(int32_t(INT32_MIN), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(int64_t(INT64_MIN), str, Format().base(2).width(64).fill(STR('0'))));
}
//*************************************************************************
@ -195,7 +195,7 @@ namespace
{
etl::string<22> str;
CHECK(etl::string<22>(STR("000")) == etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::string<22>(STR("000")) == etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::string<22>(STR("000000")) == etl::to_string(uint16_t(0), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::string<22>(STR("00000000000")) == etl::to_string(uint32_t(0), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::string<22>(STR("0000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(8).width(22).fill(STR('0'))));
@ -205,15 +205,15 @@ namespace
CHECK(etl::string<22>(STR("20000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::string<22>(STR("1000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::string<22>(STR("177")) == etl::to_string(int8_t(127), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::string<22>(STR("077777")) == etl::to_string(int16_t(32767), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::string<22>(STR("17777777777")) == etl::to_string(int32_t(2147483647ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::string<22>(STR("0777777777777777777777")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::string<22>(STR("177")) == etl::to_string(int8_t(INT8_MAX), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::string<22>(STR("077777")) == etl::to_string(int16_t(INT16_MAX), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::string<22>(STR("17777777777")) == etl::to_string(int32_t(INT32_MAX), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::string<22>(STR("0777777777777777777777")) == etl::to_string(int64_t(INT64_MAX), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::string<22>(STR("200")) == etl::to_string(int8_t(-128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::string<22>(STR("100000")) == etl::to_string(int16_t(-32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::string<22>(STR("20000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::string<22>(STR("1000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::string<22>(STR("200")) == etl::to_string(int8_t(INT8_MIN), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::string<22>(STR("100000")) == etl::to_string(int16_t(INT16_MIN), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::string<22>(STR("20000000000")) == etl::to_string(int32_t(INT32_MIN), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::string<22>(STR("1000000000000000000000")) == etl::to_string(int64_t(INT64_MIN), str, Format().base(8).width(22).fill(STR('0'))));
}
//*************************************************************************
@ -221,7 +221,7 @@ namespace
{
etl::string<16> str;
CHECK(etl::string<16>(STR("00")) == etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::string<16>(STR("00")) == etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::string<16>(STR("0000")) == etl::to_string(uint16_t(0), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::string<16>(STR("00000000")) == etl::to_string(uint32_t(0), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::string<16>(STR("0000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(16).width(16).fill(STR('0'))));
@ -231,15 +231,15 @@ namespace
CHECK(etl::string<16>(STR("80000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::string<16>(STR("8000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::string<16>(STR("7f")) == etl::to_string(int8_t(127), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::string<16>(STR("7fff")) == etl::to_string(int16_t(32767), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::string<16>(STR("7fffffff")) == etl::to_string(int32_t(2147483647ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::string<16>(STR("7fffffffffffffff")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::string<16>(STR("7f")) == etl::to_string(int8_t(INT8_MAX), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::string<16>(STR("7fff")) == etl::to_string(int16_t(INT16_MAX), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::string<16>(STR("7fffffff")) == etl::to_string(int32_t(INT32_MAX), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::string<16>(STR("7fffffffffffffff")) == etl::to_string(int64_t(INT64_MAX), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::string<16>(STR("80")) == etl::to_string(int8_t(-128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::string<16>(STR("8000")) == etl::to_string(int16_t(-32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::string<16>(STR("80000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::string<16>(STR("8000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::string<16>(STR("80")) == etl::to_string(int8_t(INT8_MIN), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::string<16>(STR("8000")) == etl::to_string(int16_t(INT16_MIN), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::string<16>(STR("80000000")) == etl::to_string(int32_t(INT32_MIN), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::string<16>(STR("8000000000000000")) == etl::to_string(int64_t(INT64_MIN), str, Format().base(16).width(16).fill(STR('0'))));
}
//*************************************************************************
@ -278,6 +278,14 @@ namespace
CHECK(etl::string<20>(STR(" -0.123456")) == etl::to_string(-0.123456, str, Format().precision(6).width(10).right()));
CHECK(etl::string<20>(STR("-0.123456 ")) == etl::to_string(-0.123456, str, Format().precision(6).width(10).left()));
// Positive rollover
CHECK(etl::string<20>(STR(" 2.000000")) == etl::to_string(1.9999996, str, Format().precision(6).width(10).right()));
CHECK(etl::string<20>(STR("2.000000 ")) == etl::to_string(1.9999996, str, Format().precision(6).width(10).left()));
// Negative rollover
CHECK(etl::string<20>(STR(" -2.000000")) == etl::to_string(-1.9999996, str, Format().precision(6).width(10).right()));
CHECK(etl::string<20>(STR("-2.000000 ")) == etl::to_string(-1.9999996, str, Format().precision(6).width(10).left()));
}
//*************************************************************************
@ -425,6 +433,223 @@ namespace
to_string(&cvi, str, Format().hex().width(10).left().fill(STR('0')), true);
CHECK(compare == str);
}
//*************************************************************************
TEST(test_integer_denominator_default_format)
{
etl::string<20> result;
int value = -1234567;
etl::to_string(value, 6U, result);
CHECK_EQUAL(etl::string<20>(STR("-1")).c_str(), result.c_str());
}
//*************************************************************************
TEST(test_integer_denominator_huge_precision)
{
etl::string<20> result;
int value = -1234560;
Format format = Format().precision(100);
etl::to_string(value, 6U, result, format);
CHECK_EQUAL(etl::string<20>(STR("-1.234560")).c_str(), result.c_str());
}
//*************************************************************************
TEST(test_integer_denominator_huge_precision_64bit)
{
etl::string<20> result;
int64_t value = INT64_MIN;
Format format = Format().precision(100);
etl::to_string(value, 12U, result, format);
CHECK_EQUAL(etl::string<20>(STR("-9223372.036854775808")).c_str(), result.c_str());
}
//*************************************************************************
TEST(test_integer_denominator_zero_fractional)
{
etl::string<20> result_i;
int value_i = -1000000;
etl::string<20> result_d;
double value_d = -1.000000;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK_EQUAL(etl::string<20>(STR("-1.0000")).c_str(), result_i.c_str());
CHECK_EQUAL(result_d.c_str(), result_i.c_str());
}
//*************************************************************************
TEST(test_integer_denominator_zero_value)
{
etl::string<20> result_i;
int value_i = 0;
etl::string<20> result_d;
double value_d = -0.000000;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK_EQUAL(etl::string<20>(STR("0.0000")).c_str(), result_i.c_str());
CHECK_EQUAL(result_d.c_str(), result_i.c_str());
}
//*************************************************************************
TEST(test_integer_denominator_zero_integral_small_fractional)
{
etl::string<20> result_i;
int value_i = -400;
etl::string<20> result_d;
double value_d = -0.000400;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK_EQUAL(etl::string<20>(STR("-0.0004")).c_str(), result_i.c_str());
CHECK_EQUAL(result_d.c_str(), result_i.c_str());
}
//*************************************************************************
TEST(test_integer_denominator_small_fractional)
{
etl::string<20> result_i;
int value_i = -123000400;
etl::string<20> result_d;
double value_d = -123.000400;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK_EQUAL(etl::string<20>(STR("-123.0004")).c_str(), result_i.c_str());
CHECK_EQUAL(result_d.c_str(), result_i.c_str());
}
//*************************************************************************
TEST(test_integer_denominator_very_small_fractional)
{
etl::string<20> result_i;
int value_i = -123000004;
etl::string<20> result_d;
double value_d = -123.000004;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK_EQUAL(etl::string<20>(STR("-123.0000")).c_str(), result_i.c_str());
CHECK_EQUAL(result_d.c_str(), result_i.c_str());
}
//*************************************************************************
TEST(test_integer_denominator_very_small_fractional_rounded_up)
{
etl::string<20> result_i;
int value_i = -123000050;
etl::string<20> result_d;
double value_d = -123.000050;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK_EQUAL(etl::string<20>(STR("-123.0001")).c_str(), result_i.c_str());
CHECK_EQUAL(result_d.c_str(), result_i.c_str());
}
//*************************************************************************
TEST(test_integer_denominator_shorter_width)
{
etl::string<20> result_i;
int value_i = -123456780;
etl::string<20> result_d;
double value_d = -123.456780;
Format format = Format().precision(4).width(6).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK_EQUAL(etl::string<20>(STR("-123.4568")).c_str(), result_i.c_str());
CHECK_EQUAL(result_d.c_str(), result_i.c_str());
}
//*************************************************************************
TEST(test_integer_denominator_larger_width)
{
etl::string<20> result_i;
int value_i = -123456780;
etl::string<20> result_d;
double value_d = -123.456780;
Format format = Format().precision(4).width(15).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK_EQUAL(etl::string<20>(STR(" -123.4568")).c_str(), result_i.c_str());
CHECK_EQUAL(result_d.c_str(), result_i.c_str());
}
//*************************************************************************
TEST(test_integer_denominator_positive_rollover)
{
etl::string<20> result_i;
int value_i = 123999990;
etl::string<20> result_d;
double value_d = 123.999990;
Format format = Format().precision(4).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK_EQUAL(etl::string<20>(STR("124.0000")).c_str(), result_i.c_str());
CHECK_EQUAL(result_d.c_str(), result_i.c_str());
}
//*************************************************************************
TEST(test_integer_denominator_negative_rollover)
{
etl::string<20> result_i;
int value_i = -123999990;
etl::string<20> result_d;
double value_d = -123.999990;
Format format = Format().precision(4).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK_EQUAL(etl::string<20>(STR("-124.0000")).c_str(), result_i.c_str());
CHECK_EQUAL(result_d.c_str(), result_i.c_str());
}
};
}

341
test/test_to_u16string.cpp
View File

@ -56,15 +56,15 @@ namespace
CHECK(etl::u16string<20>(STR("2147483648")) == etl::to_string(uint32_t(2147483648ul), str));
CHECK(etl::u16string<20>(STR("9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str));
CHECK(etl::u16string<20>(STR("127")) == etl::to_string(int8_t(127), str));
CHECK(etl::u16string<20>(STR("32767")) == etl::to_string(int16_t(32767), str));
CHECK(etl::u16string<20>(STR("2147483647")) == etl::to_string(int32_t(2147483647ll), str));
CHECK(etl::u16string<20>(STR("9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str));
CHECK(etl::u16string<20>(STR("127")) == etl::to_string(int8_t(INT8_MAX), str));
CHECK(etl::u16string<20>(STR("32767")) == etl::to_string(int16_t(INT16_MAX), str));
CHECK(etl::u16string<20>(STR("2147483647")) == etl::to_string(int32_t(INT32_MAX), str));
CHECK(etl::u16string<20>(STR("9223372036854775807")) == etl::to_string(int64_t(INT64_MAX), str));
CHECK(etl::u16string<20>(STR("-128")) == etl::to_string(int8_t(-128), str));
CHECK(etl::u16string<20>(STR("-32768")) == etl::to_string(int16_t(-32768), str));
CHECK(etl::u16string<20>(STR("-2147483648")) == etl::to_string(int32_t(-2147483648ll), str));
CHECK(etl::u16string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str));
CHECK(etl::u16string<20>(STR("-128")) == etl::to_string(int8_t(INT8_MIN), str));
CHECK(etl::u16string<20>(STR("-32768")) == etl::to_string(int16_t(INT16_MIN), str));
CHECK(etl::u16string<20>(STR("-2147483648")) == etl::to_string(int32_t(INT32_MIN), str));
CHECK(etl::u16string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str));
}
//*************************************************************************
@ -72,7 +72,7 @@ namespace
{
etl::u16string<120> str;
CHECK(etl::u16string<120>(STR("0")) == etl::to_string(uint8_t(0), str, true));
CHECK(etl::u16string<120>(STR("0")) == etl::to_string(uint8_t(0), str, true));
CHECK(etl::u16string<120>(STR("00")) == etl::to_string(uint16_t(0), str, true));
CHECK(etl::u16string<120>(STR("000")) == etl::to_string(uint32_t(0), str, true));
CHECK(etl::u16string<120>(STR("0000")) == etl::to_string(uint64_t(0), str, true));
@ -82,15 +82,15 @@ namespace
CHECK(etl::u16string<120>(STR("0000128327682147483648")) == etl::to_string(uint32_t(2147483648ul), str, true));
CHECK(etl::u16string<120>(STR("00001283276821474836489223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, true));
CHECK(etl::u16string<120>(STR("00001283276821474836489223372036854775808127")) == etl::to_string(int8_t(127), str, true));
CHECK(etl::u16string<120>(STR("0000128327682147483648922337203685477580812732767")) == etl::to_string(int16_t(32767), str, true));
CHECK(etl::u16string<120>(STR("00001283276821474836489223372036854775808127327672147483647")) == etl::to_string(int32_t(2147483647ll), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, true));
CHECK(etl::u16string<120>(STR("00001283276821474836489223372036854775808127")) == etl::to_string(int8_t(INT8_MAX), str, true));
CHECK(etl::u16string<120>(STR("0000128327682147483648922337203685477580812732767")) == etl::to_string(int16_t(INT16_MAX), str, true));
CHECK(etl::u16string<120>(STR("00001283276821474836489223372036854775808127327672147483647")) == etl::to_string(int32_t(INT32_MAX), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")) == etl::to_string(int64_t(INT64_MAX), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")) == etl::to_string(int8_t(-128), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")) == etl::to_string(int16_t(-32768), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")) == etl::to_string(int8_t(INT8_MIN), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")) == etl::to_string(int16_t(INT16_MIN), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")) == etl::to_string(int32_t(INT32_MIN), str, true));
CHECK(etl::u16string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str, true));
}
//*************************************************************************
@ -100,7 +100,7 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#'));
CHECK(etl::u16string<20>(STR("###################0")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::u16string<20>(STR("###################0")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::u16string<20>(STR("###################0")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::u16string<20>(STR("###################0")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::u16string<20>(STR("###################0")) == etl::to_string(uint64_t(0), str, format));
@ -110,15 +110,15 @@ namespace
CHECK(etl::u16string<20>(STR("##########2147483648")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::u16string<20>(STR("#9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::u16string<20>(STR("#################127")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::u16string<20>(STR("###############32767")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::u16string<20>(STR("##########2147483647")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::u16string<20>(STR("#9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::u16string<20>(STR("#################127")) == etl::to_string(int8_t(INT8_MAX), str, format));
CHECK(etl::u16string<20>(STR("###############32767")) == etl::to_string(int16_t(INT16_MAX), str, format));
CHECK(etl::u16string<20>(STR("##########2147483647")) == etl::to_string(int32_t(INT32_MAX), str, format));
CHECK(etl::u16string<20>(STR("#9223372036854775807")) == etl::to_string(int64_t(INT64_MAX), str, format));
CHECK(etl::u16string<20>(STR("################-128")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::u16string<20>(STR("##############-32768")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::u16string<20>(STR("#########-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::u16string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::u16string<20>(STR("################-128")) == etl::to_string(int8_t(INT8_MIN), str, format));
CHECK(etl::u16string<20>(STR("##############-32768")) == etl::to_string(int16_t(INT16_MIN), str, format));
CHECK(etl::u16string<20>(STR("#########-2147483648")) == etl::to_string(int32_t(INT32_MIN), str, format));
CHECK(etl::u16string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str, format));
}
//*************************************************************************
@ -128,7 +128,7 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#')).left();
CHECK(etl::u16string<20>(STR("0###################")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::u16string<20>(STR("0###################")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::u16string<20>(STR("0###################")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::u16string<20>(STR("0###################")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::u16string<20>(STR("0###################")) == etl::to_string(uint64_t(0), str, format));
@ -138,15 +138,15 @@ namespace
CHECK(etl::u16string<20>(STR("2147483648##########")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::u16string<20>(STR("9223372036854775808#")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::u16string<20>(STR("127#################")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::u16string<20>(STR("32767###############")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::u16string<20>(STR("2147483647##########")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::u16string<20>(STR("9223372036854775807#")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::u16string<20>(STR("127#################")) == etl::to_string(int8_t(INT8_MAX), str, format));
CHECK(etl::u16string<20>(STR("32767###############")) == etl::to_string(int16_t(INT16_MAX), str, format));
CHECK(etl::u16string<20>(STR("2147483647##########")) == etl::to_string(int32_t(INT32_MAX), str, format));
CHECK(etl::u16string<20>(STR("9223372036854775807#")) == etl::to_string(int64_t(INT64_MAX), str, format));
CHECK(etl::u16string<20>(STR("-128################")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::u16string<20>(STR("-32768##############")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::u16string<20>(STR("-2147483648#########")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::u16string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::u16string<20>(STR("-128################")) == etl::to_string(int8_t(INT8_MIN), str, format));
CHECK(etl::u16string<20>(STR("-32768##############")) == etl::to_string(int16_t(INT16_MIN), str, format));
CHECK(etl::u16string<20>(STR("-2147483648#########")) == etl::to_string(int32_t(INT32_MIN), str, format));
CHECK(etl::u16string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str, format));
}
//*************************************************************************
@ -154,7 +154,7 @@ namespace
{
etl::u16string<64> str;
CHECK(etl::u16string<64>(STR("00000000")) == etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("00000000")) == etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("0000000000000000")) == etl::to_string(uint16_t(0), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("00000000000000000000000000000000")) == etl::to_string(uint32_t(0), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("0000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(2).width(64).fill(STR('0'))));
@ -164,15 +164,15 @@ namespace
CHECK(etl::u16string<64>(STR("10000000000000000000000000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("01111111")) == etl::to_string(int8_t(127), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("0111111111111111")) == etl::to_string(int16_t(32767), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("01111111111111111111111111111111")) == etl::to_string(int32_t(2147483647ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("01111111")) == etl::to_string(int8_t(INT8_MAX), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("0111111111111111")) == etl::to_string(int16_t(INT16_MAX), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("01111111111111111111111111111111")) == etl::to_string(int32_t(INT32_MAX), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")) == etl::to_string(int64_t(INT64_MAX), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("10000000")) == etl::to_string(int8_t(-128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("1000000000000000")) == etl::to_string(int16_t(-32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("10000000000000000000000000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("10000000")) == etl::to_string(int8_t(INT8_MIN), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("1000000000000000")) == etl::to_string(int16_t(INT16_MIN), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("10000000000000000000000000000000")) == etl::to_string(int32_t(INT32_MIN), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u16string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(int64_t(INT64_MIN), str, Format().base(2).width(64).fill(STR('0'))));
}
//*************************************************************************
@ -180,7 +180,7 @@ namespace
{
etl::u16string<22> str;
CHECK(etl::u16string<22>(STR("000")) == etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("000")) == etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("000000")) == etl::to_string(uint16_t(0), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("00000000000")) == etl::to_string(uint32_t(0), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("0000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(8).width(22).fill(STR('0'))));
@ -190,15 +190,15 @@ namespace
CHECK(etl::u16string<22>(STR("20000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("1000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("177")) == etl::to_string(int8_t(127), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("077777")) == etl::to_string(int16_t(32767), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("17777777777")) == etl::to_string(int32_t(2147483647ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("0777777777777777777777")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("177")) == etl::to_string(int8_t(INT8_MAX), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("077777")) == etl::to_string(int16_t(INT16_MAX), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("17777777777")) == etl::to_string(int32_t(INT32_MAX), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("0777777777777777777777")) == etl::to_string(int64_t(INT64_MAX), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("200")) == etl::to_string(int8_t(-128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("100000")) == etl::to_string(int16_t(-32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("20000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("1000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("200")) == etl::to_string(int8_t(INT8_MIN), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("100000")) == etl::to_string(int16_t(INT16_MIN), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("20000000000")) == etl::to_string(int32_t(INT32_MIN), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u16string<22>(STR("1000000000000000000000")) == etl::to_string(int64_t(INT64_MIN), str, Format().base(8).width(22).fill(STR('0'))));
}
//*************************************************************************
@ -206,7 +206,7 @@ namespace
{
etl::u16string<16> str;
CHECK(etl::u16string<16>(STR("00")) == etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("00")) == etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("0000")) == etl::to_string(uint16_t(0), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("00000000")) == etl::to_string(uint32_t(0), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("0000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(16).width(16).fill(STR('0'))));
@ -216,15 +216,15 @@ namespace
CHECK(etl::u16string<16>(STR("80000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("8000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("7f")) == etl::to_string(int8_t(127), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("7fff")) == etl::to_string(int16_t(32767), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("7fffffff")) == etl::to_string(int32_t(2147483647ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("7fffffffffffffff")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("7f")) == etl::to_string(int8_t(INT8_MAX), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("7fff")) == etl::to_string(int16_t(INT16_MAX), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("7fffffff")) == etl::to_string(int32_t(INT32_MAX), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("7fffffffffffffff")) == etl::to_string(int64_t(INT64_MAX), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("80")) == etl::to_string(int8_t(-128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("8000")) == etl::to_string(int16_t(-32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("80000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("8000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("80")) == etl::to_string(int8_t(INT8_MIN), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("8000")) == etl::to_string(int16_t(INT16_MIN), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("80000000")) == etl::to_string(int32_t(INT32_MIN), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u16string<16>(STR("8000000000000000")) == etl::to_string(int64_t(INT64_MIN), str, Format().base(16).width(16).fill(STR('0'))));
}
//*************************************************************************
@ -348,6 +348,223 @@ namespace
str.assign(STR("Result "));
CHECK(etl::u16string<20>(STR("Result true ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(true), true));
}
//*************************************************************************
TEST(test_integer_denominator_default_format)
{
etl::u16string<20> result;
int value = -1234567;
etl::to_string(value, 6U, result);
CHECK(etl::u16string<20>(STR("-1")) == result);
}
//*************************************************************************
TEST(test_integer_denominator_huge_precision)
{
etl::u16string<20> result;
int value = -1234560;
Format format = Format().precision(100);
etl::to_string(value, 6U, result, format);
CHECK(etl::u16string<20>(STR("-1.234560")) == result);
}
//*************************************************************************
TEST(test_integer_denominator_huge_precision_64bit)
{
etl::u16string<20> result;
int64_t value = INT64_MIN;
Format format = Format().precision(100);
etl::to_string(value, 12U, result, format);
CHECK(etl::u16string<20>(STR("-9223372.036854775808")) == result);
}
//*************************************************************************
TEST(test_integer_denominator_zero_fractional)
{
etl::u16string<20> result_i;
int value_i = -1000000;
etl::u16string<20> result_d;
double value_d = -1.000000;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u16string<20>(STR("-1.0000")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_zero_value)
{
etl::u16string<20> result_i;
int value_i = 0;
etl::u16string<20> result_d;
double value_d = -0.000000;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u16string<20>(STR("0.0000")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_zero_integral_small_fractional)
{
etl::u16string<20> result_i;
int value_i = -400;
etl::u16string<20> result_d;
double value_d = -0.000400;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u16string<20>(STR("-0.0004")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_small_fractional)
{
etl::u16string<20> result_i;
int value_i = -123000400;
etl::u16string<20> result_d;
double value_d = -123.000400;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u16string<20>(STR("-123.0004")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_very_small_fractional)
{
etl::u16string<20> result_i;
int value_i = -123000004;
etl::u16string<20> result_d;
double value_d = -123.000004;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u16string<20>(STR("-123.0000")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_very_small_fractional_rounded_up)
{
etl::u16string<20> result_i;
int value_i = -123000050;
etl::u16string<20> result_d;
double value_d = -123.000050;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u16string<20>(STR("-123.0001")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_shorter_width)
{
etl::u16string<20> result_i;
int value_i = -123456780;
etl::u16string<20> result_d;
double value_d = -123.456780;
Format format = Format().precision(4).width(6).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u16string<20>(STR("-123.4568")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_larger_width)
{
etl::u16string<20> result_i;
int value_i = -123456780;
etl::u16string<20> result_d;
double value_d = -123.456780;
Format format = Format().precision(4).width(15).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u16string<20>(STR(" -123.4568")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_positive_rollover)
{
etl::u16string<20> result_i;
int value_i = 123999990;
etl::u16string<20> result_d;
double value_d = 123.999990;
Format format = Format().precision(4).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u16string<20>(STR("124.0000")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_negative_rollover)
{
etl::u16string<20> result_i;
int value_i = -123999990;
etl::u16string<20> result_d;
double value_d = -123.999990;
Format format = Format().precision(4).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u16string<20>(STR("-124.0000")) == result_i);
CHECK(result_d == result_i);
}
};
}

341
test/test_to_u32string.cpp
View File

@ -58,15 +58,15 @@ namespace
CHECK(etl::u32string<20>(STR("2147483648")) == etl::to_string(uint32_t(2147483648ul), str));
CHECK(etl::u32string<20>(STR("9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str));
CHECK(etl::u32string<20>(STR("127")) == etl::to_string(int8_t(127), str));
CHECK(etl::u32string<20>(STR("32767")) == etl::to_string(int16_t(32767), str));
CHECK(etl::u32string<20>(STR("2147483647")) == etl::to_string(int32_t(2147483647ll), str));
CHECK(etl::u32string<20>(STR("9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str));
CHECK(etl::u32string<20>(STR("127")) == etl::to_string(int8_t(INT8_MAX), str));
CHECK(etl::u32string<20>(STR("32767")) == etl::to_string(int16_t(INT16_MAX), str));
CHECK(etl::u32string<20>(STR("2147483647")) == etl::to_string(int32_t(INT32_MAX), str));
CHECK(etl::u32string<20>(STR("9223372036854775807")) == etl::to_string(int64_t(INT64_MAX), str));
CHECK(etl::u32string<20>(STR("-128")) == etl::to_string(int8_t(-128), str));
CHECK(etl::u32string<20>(STR("-32768")) == etl::to_string(int16_t(-32768), str));
CHECK(etl::u32string<20>(STR("-2147483648")) == etl::to_string(int32_t(-2147483648ll), str));
CHECK(etl::u32string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str));
CHECK(etl::u32string<20>(STR("-128")) == etl::to_string(int8_t(INT8_MIN), str));
CHECK(etl::u32string<20>(STR("-32768")) == etl::to_string(int16_t(INT16_MIN), str));
CHECK(etl::u32string<20>(STR("-2147483648")) == etl::to_string(int32_t(INT32_MIN), str));
CHECK(etl::u32string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str));
}
//*************************************************************************
@ -74,7 +74,7 @@ namespace
{
etl::u32string<120> str;
CHECK(etl::u32string<120>(STR("0")) == etl::to_string(uint8_t(0), str, true));
CHECK(etl::u32string<120>(STR("0")) == etl::to_string(uint8_t(0), str, true));
CHECK(etl::u32string<120>(STR("00")) == etl::to_string(uint16_t(0), str, true));
CHECK(etl::u32string<120>(STR("000")) == etl::to_string(uint32_t(0), str, true));
CHECK(etl::u32string<120>(STR("0000")) == etl::to_string(uint64_t(0), str, true));
@ -84,15 +84,15 @@ namespace
CHECK(etl::u32string<120>(STR("0000128327682147483648")) == etl::to_string(uint32_t(2147483648ul), str, true));
CHECK(etl::u32string<120>(STR("00001283276821474836489223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, true));
CHECK(etl::u32string<120>(STR("00001283276821474836489223372036854775808127")) == etl::to_string(int8_t(127), str, true));
CHECK(etl::u32string<120>(STR("0000128327682147483648922337203685477580812732767")) == etl::to_string(int16_t(32767), str, true));
CHECK(etl::u32string<120>(STR("00001283276821474836489223372036854775808127327672147483647")) == etl::to_string(int32_t(2147483647ll), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, true));
CHECK(etl::u32string<120>(STR("00001283276821474836489223372036854775808127")) == etl::to_string(int8_t(INT8_MAX), str, true));
CHECK(etl::u32string<120>(STR("0000128327682147483648922337203685477580812732767")) == etl::to_string(int16_t(INT16_MAX), str, true));
CHECK(etl::u32string<120>(STR("00001283276821474836489223372036854775808127327672147483647")) == etl::to_string(int32_t(INT32_MAX), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")) == etl::to_string(int64_t(INT64_MAX), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")) == etl::to_string(int8_t(-128), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")) == etl::to_string(int16_t(-32768), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")) == etl::to_string(int8_t(INT8_MIN), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")) == etl::to_string(int16_t(INT16_MIN), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")) == etl::to_string(int32_t(INT32_MIN), str, true));
CHECK(etl::u32string<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str, true));
}
//*************************************************************************
@ -102,7 +102,7 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#'));
CHECK(etl::u32string<20>(STR("###################0")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::u32string<20>(STR("###################0")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::u32string<20>(STR("###################0")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::u32string<20>(STR("###################0")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::u32string<20>(STR("###################0")) == etl::to_string(uint64_t(0), str, format));
@ -112,15 +112,15 @@ namespace
CHECK(etl::u32string<20>(STR("##########2147483648")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::u32string<20>(STR("#9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::u32string<20>(STR("#################127")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::u32string<20>(STR("###############32767")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::u32string<20>(STR("##########2147483647")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::u32string<20>(STR("#9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::u32string<20>(STR("#################127")) == etl::to_string(int8_t(INT8_MAX), str, format));
CHECK(etl::u32string<20>(STR("###############32767")) == etl::to_string(int16_t(INT16_MAX), str, format));
CHECK(etl::u32string<20>(STR("##########2147483647")) == etl::to_string(int32_t(INT32_MAX), str, format));
CHECK(etl::u32string<20>(STR("#9223372036854775807")) == etl::to_string(int64_t(INT64_MAX), str, format));
CHECK(etl::u32string<20>(STR("################-128")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::u32string<20>(STR("##############-32768")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::u32string<20>(STR("#########-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::u32string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::u32string<20>(STR("################-128")) == etl::to_string(int8_t(INT8_MIN), str, format));
CHECK(etl::u32string<20>(STR("##############-32768")) == etl::to_string(int16_t(INT16_MIN), str, format));
CHECK(etl::u32string<20>(STR("#########-2147483648")) == etl::to_string(int32_t(INT32_MIN), str, format));
CHECK(etl::u32string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str, format));
}
//*************************************************************************
@ -130,7 +130,7 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#')).left();
CHECK(etl::u32string<20>(STR("0###################")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::u32string<20>(STR("0###################")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::u32string<20>(STR("0###################")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::u32string<20>(STR("0###################")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::u32string<20>(STR("0###################")) == etl::to_string(uint64_t(0), str, format));
@ -140,15 +140,15 @@ namespace
CHECK(etl::u32string<20>(STR("2147483648##########")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::u32string<20>(STR("9223372036854775808#")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::u32string<20>(STR("127#################")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::u32string<20>(STR("32767###############")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::u32string<20>(STR("2147483647##########")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::u32string<20>(STR("9223372036854775807#")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::u32string<20>(STR("127#################")) == etl::to_string(int8_t(INT8_MAX), str, format));
CHECK(etl::u32string<20>(STR("32767###############")) == etl::to_string(int16_t(INT16_MAX), str, format));
CHECK(etl::u32string<20>(STR("2147483647##########")) == etl::to_string(int32_t(INT32_MAX), str, format));
CHECK(etl::u32string<20>(STR("9223372036854775807#")) == etl::to_string(int64_t(INT64_MAX), str, format));
CHECK(etl::u32string<20>(STR("-128################")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::u32string<20>(STR("-32768##############")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::u32string<20>(STR("-2147483648#########")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::u32string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::u32string<20>(STR("-128################")) == etl::to_string(int8_t(INT8_MIN), str, format));
CHECK(etl::u32string<20>(STR("-32768##############")) == etl::to_string(int16_t(INT16_MIN), str, format));
CHECK(etl::u32string<20>(STR("-2147483648#########")) == etl::to_string(int32_t(INT32_MIN), str, format));
CHECK(etl::u32string<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str, format));
}
//*************************************************************************
@ -156,7 +156,7 @@ namespace
{
etl::u32string<64> str;
CHECK(etl::u32string<64>(STR("00000000")) == etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("00000000")) == etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("0000000000000000")) == etl::to_string(uint16_t(0), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("00000000000000000000000000000000")) == etl::to_string(uint32_t(0), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("0000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(2).width(64).fill(STR('0'))));
@ -166,15 +166,15 @@ namespace
CHECK(etl::u32string<64>(STR("10000000000000000000000000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("01111111")) == etl::to_string(int8_t(127), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("0111111111111111")) == etl::to_string(int16_t(32767), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("01111111111111111111111111111111")) == etl::to_string(int32_t(2147483647ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("01111111")) == etl::to_string(int8_t(INT8_MAX), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("0111111111111111")) == etl::to_string(int16_t(INT16_MAX), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("01111111111111111111111111111111")) == etl::to_string(int32_t(INT32_MAX), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")) == etl::to_string(int64_t(INT64_MAX), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("10000000")) == etl::to_string(int8_t(-128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("1000000000000000")) == etl::to_string(int16_t(-32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("10000000000000000000000000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("10000000")) == etl::to_string(int8_t(INT8_MIN), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("1000000000000000")) == etl::to_string(int16_t(INT16_MIN), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("10000000000000000000000000000000")) == etl::to_string(int32_t(INT32_MIN), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::u32string<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(int64_t(INT64_MIN), str, Format().base(2).width(64).fill(STR('0'))));
}
//*************************************************************************
@ -182,7 +182,7 @@ namespace
{
etl::u32string<22> str;
CHECK(etl::u32string<22>(STR("000")) == etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("000")) == etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("000000")) == etl::to_string(uint16_t(0), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("00000000000")) == etl::to_string(uint32_t(0), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("0000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(8).width(22).fill(STR('0'))));
@ -192,15 +192,15 @@ namespace
CHECK(etl::u32string<22>(STR("20000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("1000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("177")) == etl::to_string(int8_t(127), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("077777")) == etl::to_string(int16_t(32767), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("17777777777")) == etl::to_string(int32_t(2147483647ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("0777777777777777777777")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("177")) == etl::to_string(int8_t(INT8_MAX), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("077777")) == etl::to_string(int16_t(INT16_MAX), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("17777777777")) == etl::to_string(int32_t(INT32_MAX), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("0777777777777777777777")) == etl::to_string(int64_t(INT64_MAX), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("200")) == etl::to_string(int8_t(-128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("100000")) == etl::to_string(int16_t(-32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("20000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("1000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("200")) == etl::to_string(int8_t(INT8_MIN), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("100000")) == etl::to_string(int16_t(INT16_MIN), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("20000000000")) == etl::to_string(int32_t(INT32_MIN), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::u32string<22>(STR("1000000000000000000000")) == etl::to_string(int64_t(INT64_MIN), str, Format().base(8).width(22).fill(STR('0'))));
}
//*************************************************************************
@ -208,7 +208,7 @@ namespace
{
etl::u32string<16> str;
CHECK(etl::u32string<16>(STR("00")) == etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("00")) == etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("0000")) == etl::to_string(uint16_t(0), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("00000000")) == etl::to_string(uint32_t(0), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("0000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(16).width(16).fill(STR('0'))));
@ -218,15 +218,15 @@ namespace
CHECK(etl::u32string<16>(STR("80000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("8000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("7f")) == etl::to_string(int8_t(127), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("7fff")) == etl::to_string(int16_t(32767), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("7fffffff")) == etl::to_string(int32_t(2147483647ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("7fffffffffffffff")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("7f")) == etl::to_string(int8_t(INT8_MAX), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("7fff")) == etl::to_string(int16_t(INT16_MAX), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("7fffffff")) == etl::to_string(int32_t(INT32_MAX), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("7fffffffffffffff")) == etl::to_string(int64_t(INT64_MAX), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("80")) == etl::to_string(int8_t(-128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("8000")) == etl::to_string(int16_t(-32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("80000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("8000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("80")) == etl::to_string(int8_t(INT8_MIN), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("8000")) == etl::to_string(int16_t(INT16_MIN), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("80000000")) == etl::to_string(int32_t(INT32_MIN), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::u32string<16>(STR("8000000000000000")) == etl::to_string(int64_t(INT64_MIN), str, Format().base(16).width(16).fill(STR('0'))));
}
@ -353,6 +353,223 @@ namespace
str.assign(STR("Result "));
CHECK(etl::u32string<20>(STR("Result true ")) == to_string(true, str, Format().precision(6).width(10).left().boolalpha(true), true));
}
//*************************************************************************
TEST(test_integer_denominator_default_format)
{
etl::u32string<20> result;
int value = -1234567;
etl::to_string(value, 6U, result);
CHECK(etl::u32string<20>(STR("-1")) == result);
}
//*************************************************************************
TEST(test_integer_denominator_huge_precision)
{
etl::u32string<20> result;
int value = -1234560;
Format format = Format().precision(100);
etl::to_string(value, 6U, result, format);
CHECK(etl::u32string<20>(STR("-1.234560")) == result);
}
//*************************************************************************
TEST(test_integer_denominator_huge_precision_64bit)
{
etl::u32string<20> result;
int64_t value = INT64_MIN;
Format format = Format().precision(100);
etl::to_string(value, 12U, result, format);
CHECK(etl::u32string<20>(STR("-9223372.036854775808")) == result);
}
//*************************************************************************
TEST(test_integer_denominator_zero_fractional)
{
etl::u32string<20> result_i;
int value_i = -1000000;
etl::u32string<20> result_d;
double value_d = -1.000000;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u32string<20>(STR("-1.0000")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_zero_value)
{
etl::u32string<20> result_i;
int value_i = 0;
etl::u32string<20> result_d;
double value_d = -0.000000;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u32string<20>(STR("0.0000")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_zero_integral_small_fractional)
{
etl::u32string<20> result_i;
int value_i = -400;
etl::u32string<20> result_d;
double value_d = -0.000400;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u32string<20>(STR("-0.0004")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_small_fractional)
{
etl::u32string<20> result_i;
int value_i = -123000400;
etl::u32string<20> result_d;
double value_d = -123.000400;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u32string<20>(STR("-123.0004")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_very_small_fractional)
{
etl::u32string<20> result_i;
int value_i = -123000004;
etl::u32string<20> result_d;
double value_d = -123.000004;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u32string<20>(STR("-123.0000")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_very_small_fractional_rounded_up)
{
etl::u32string<20> result_i;
int value_i = -123000050;
etl::u32string<20> result_d;
double value_d = -123.000050;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u32string<20>(STR("-123.0001")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_shorter_width)
{
etl::u32string<20> result_i;
int value_i = -123456780;
etl::u32string<20> result_d;
double value_d = -123.456780;
Format format = Format().precision(4).width(6).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u32string<20>(STR("-123.4568")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_larger_width)
{
etl::u32string<20> result_i;
int value_i = -123456780;
etl::u32string<20> result_d;
double value_d = -123.456780;
Format format = Format().precision(4).width(15).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u32string<20>(STR(" -123.4568")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_positive_rollover)
{
etl::u32string<20> result_i;
int value_i = 123999990;
etl::u32string<20> result_d;
double value_d = 123.999990;
Format format = Format().precision(4).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u32string<20>(STR("124.0000")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_negative_rollover)
{
etl::u32string<20> result_i;
int value_i = -123999990;
etl::u32string<20> result_d;
double value_d = -123.999990;
Format format = Format().precision(4).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::u32string<20>(STR("-124.0000")) == result_i);
CHECK(result_d == result_i);
}
};
}

341
test/test_to_wstring.cpp
View File

@ -60,15 +60,15 @@ namespace
CHECK(etl::wstring<20>(STR("2147483648")) == etl::to_string(uint32_t(2147483648ul), str));
CHECK(etl::wstring<20>(STR("9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str));
CHECK(etl::wstring<20>(STR("127")) == etl::to_string(int8_t(127), str));
CHECK(etl::wstring<20>(STR("32767")) == etl::to_string(int16_t(32767), str));
CHECK(etl::wstring<20>(STR("2147483647")) == etl::to_string(int32_t(2147483647ll), str));
CHECK(etl::wstring<20>(STR("9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str));
CHECK(etl::wstring<20>(STR("127")) == etl::to_string(int8_t(INT8_MAX), str));
CHECK(etl::wstring<20>(STR("32767")) == etl::to_string(int16_t(INT16_MAX), str));
CHECK(etl::wstring<20>(STR("2147483647")) == etl::to_string(int32_t(INT32_MAX), str));
CHECK(etl::wstring<20>(STR("9223372036854775807")) == etl::to_string(int64_t(INT64_MAX), str));
CHECK(etl::wstring<20>(STR("-128")) == etl::to_string(int8_t(-128), str));
CHECK(etl::wstring<20>(STR("-32768")) == etl::to_string(int16_t(-32768), str));
CHECK(etl::wstring<20>(STR("-2147483648")) == etl::to_string(int32_t(-2147483648ll), str));
CHECK(etl::wstring<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str));
CHECK(etl::wstring<20>(STR("-128")) == etl::to_string(int8_t(INT8_MIN), str));
CHECK(etl::wstring<20>(STR("-32768")) == etl::to_string(int16_t(INT16_MIN), str));
CHECK(etl::wstring<20>(STR("-2147483648")) == etl::to_string(int32_t(INT32_MIN), str));
CHECK(etl::wstring<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str));
}
//*************************************************************************
@ -76,7 +76,7 @@ namespace
{
etl::wstring<120> str;
CHECK(etl::wstring<120>(STR("0")) == etl::to_string(uint8_t(0), str, true));
CHECK(etl::wstring<120>(STR("0")) == etl::to_string(uint8_t(0), str, true));
CHECK(etl::wstring<120>(STR("00")) == etl::to_string(uint16_t(0), str, true));
CHECK(etl::wstring<120>(STR("000")) == etl::to_string(uint32_t(0), str, true));
CHECK(etl::wstring<120>(STR("0000")) == etl::to_string(uint64_t(0), str, true));
@ -86,15 +86,15 @@ namespace
CHECK(etl::wstring<120>(STR("0000128327682147483648")) == etl::to_string(uint32_t(2147483648ul), str, true));
CHECK(etl::wstring<120>(STR("00001283276821474836489223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, true));
CHECK(etl::wstring<120>(STR("00001283276821474836489223372036854775808127")) == etl::to_string(int8_t(127), str, true));
CHECK(etl::wstring<120>(STR("0000128327682147483648922337203685477580812732767")) == etl::to_string(int16_t(32767), str, true));
CHECK(etl::wstring<120>(STR("00001283276821474836489223372036854775808127327672147483647")) == etl::to_string(int32_t(2147483647ll), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, true));
CHECK(etl::wstring<120>(STR("00001283276821474836489223372036854775808127")) == etl::to_string(int8_t(INT8_MAX), str, true));
CHECK(etl::wstring<120>(STR("0000128327682147483648922337203685477580812732767")) == etl::to_string(int16_t(INT16_MAX), str, true));
CHECK(etl::wstring<120>(STR("00001283276821474836489223372036854775808127327672147483647")) == etl::to_string(int32_t(INT32_MAX), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807")) == etl::to_string(int64_t(INT64_MAX), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")) == etl::to_string(int8_t(-128), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")) == etl::to_string(int16_t(-32768), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128")) == etl::to_string(int8_t(INT8_MIN), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768")) == etl::to_string(int16_t(INT16_MIN), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648")) == etl::to_string(int32_t(INT32_MIN), str, true));
CHECK(etl::wstring<120>(STR("000012832768214748364892233720368547758081273276721474836479223372036854775807-128-32768-2147483648-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str, true));
}
//*************************************************************************
@ -104,7 +104,7 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#'));
CHECK(etl::wstring<20>(STR("###################0")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::wstring<20>(STR("###################0")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::wstring<20>(STR("###################0")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::wstring<20>(STR("###################0")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::wstring<20>(STR("###################0")) == etl::to_string(uint64_t(0), str, format));
@ -114,15 +114,15 @@ namespace
CHECK(etl::wstring<20>(STR("##########2147483648")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::wstring<20>(STR("#9223372036854775808")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::wstring<20>(STR("#################127")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::wstring<20>(STR("###############32767")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::wstring<20>(STR("##########2147483647")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::wstring<20>(STR("#9223372036854775807")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::wstring<20>(STR("#################127")) == etl::to_string(int8_t(INT8_MAX), str, format));
CHECK(etl::wstring<20>(STR("###############32767")) == etl::to_string(int16_t(INT16_MAX), str, format));
CHECK(etl::wstring<20>(STR("##########2147483647")) == etl::to_string(int32_t(INT32_MAX), str, format));
CHECK(etl::wstring<20>(STR("#9223372036854775807")) == etl::to_string(int64_t(INT64_MAX), str, format));
CHECK(etl::wstring<20>(STR("################-128")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::wstring<20>(STR("##############-32768")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::wstring<20>(STR("#########-2147483648")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::wstring<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::wstring<20>(STR("################-128")) == etl::to_string(int8_t(INT8_MIN), str, format));
CHECK(etl::wstring<20>(STR("##############-32768")) == etl::to_string(int16_t(INT16_MIN), str, format));
CHECK(etl::wstring<20>(STR("#########-2147483648")) == etl::to_string(int32_t(INT32_MIN), str, format));
CHECK(etl::wstring<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str, format));
}
//*************************************************************************
@ -132,7 +132,7 @@ namespace
Format format = Format().base(10).width(20).fill(STR('#')).left();
CHECK(etl::wstring<20>(STR("0###################")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::wstring<20>(STR("0###################")) == etl::to_string(uint8_t(0), str, format));
CHECK(etl::wstring<20>(STR("0###################")) == etl::to_string(uint16_t(0), str, format));
CHECK(etl::wstring<20>(STR("0###################")) == etl::to_string(uint32_t(0), str, format));
CHECK(etl::wstring<20>(STR("0###################")) == etl::to_string(uint64_t(0), str, format));
@ -142,15 +142,15 @@ namespace
CHECK(etl::wstring<20>(STR("2147483648##########")) == etl::to_string(uint32_t(2147483648ul), str, format));
CHECK(etl::wstring<20>(STR("9223372036854775808#")) == etl::to_string(uint64_t(9223372036854775808ull), str, format));
CHECK(etl::wstring<20>(STR("127#################")) == etl::to_string(int8_t(127), str, format));
CHECK(etl::wstring<20>(STR("32767###############")) == etl::to_string(int16_t(32767), str, format));
CHECK(etl::wstring<20>(STR("2147483647##########")) == etl::to_string(int32_t(2147483647ll), str, format));
CHECK(etl::wstring<20>(STR("9223372036854775807#")) == etl::to_string(int64_t(9223372036854775807ll), str, format));
CHECK(etl::wstring<20>(STR("127#################")) == etl::to_string(int8_t(INT8_MAX), str, format));
CHECK(etl::wstring<20>(STR("32767###############")) == etl::to_string(int16_t(INT16_MAX), str, format));
CHECK(etl::wstring<20>(STR("2147483647##########")) == etl::to_string(int32_t(INT32_MAX), str, format));
CHECK(etl::wstring<20>(STR("9223372036854775807#")) == etl::to_string(int64_t(INT64_MAX), str, format));
CHECK(etl::wstring<20>(STR("-128################")) == etl::to_string(int8_t(-128), str, format));
CHECK(etl::wstring<20>(STR("-32768##############")) == etl::to_string(int16_t(-32768), str, format));
CHECK(etl::wstring<20>(STR("-2147483648#########")) == etl::to_string(int32_t(-2147483648ll), str, format));
CHECK(etl::wstring<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, format));
CHECK(etl::wstring<20>(STR("-128################")) == etl::to_string(int8_t(INT8_MIN), str, format));
CHECK(etl::wstring<20>(STR("-32768##############")) == etl::to_string(int16_t(INT16_MIN), str, format));
CHECK(etl::wstring<20>(STR("-2147483648#########")) == etl::to_string(int32_t(INT32_MIN), str, format));
CHECK(etl::wstring<20>(STR("-9223372036854775808")) == etl::to_string(int64_t(INT64_MIN), str, format));
}
//*************************************************************************
@ -158,7 +158,7 @@ namespace
{
etl::wstring<64> str;
CHECK(etl::wstring<64>(STR("00000000")) == etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("00000000")) == etl::to_string(uint8_t(0), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("0000000000000000")) == etl::to_string(uint16_t(0), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("00000000000000000000000000000000")) == etl::to_string(uint32_t(0), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("0000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(2).width(64).fill(STR('0'))));
@ -168,15 +168,15 @@ namespace
CHECK(etl::wstring<64>(STR("10000000000000000000000000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("01111111")) == etl::to_string(int8_t(127), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("0111111111111111")) == etl::to_string(int16_t(32767), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("01111111111111111111111111111111")) == etl::to_string(int32_t(2147483647ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("01111111")) == etl::to_string(int8_t(INT8_MAX), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("0111111111111111")) == etl::to_string(int16_t(INT16_MAX), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("01111111111111111111111111111111")) == etl::to_string(int32_t(INT32_MAX), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("0111111111111111111111111111111111111111111111111111111111111111")) == etl::to_string(int64_t(INT64_MAX), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("10000000")) == etl::to_string(int8_t(-128), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("1000000000000000")) == etl::to_string(int16_t(-32768), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("10000000000000000000000000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(2).width(64).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("10000000")) == etl::to_string(int8_t(INT8_MIN), str, Format().base(2).width(8).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("1000000000000000")) == etl::to_string(int16_t(INT16_MIN), str, Format().base(2).width(16).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("10000000000000000000000000000000")) == etl::to_string(int32_t(INT32_MIN), str, Format().base(2).width(32).fill(STR('0'))));
CHECK(etl::wstring<64>(STR("1000000000000000000000000000000000000000000000000000000000000000")) == etl::to_string(int64_t(INT64_MIN), str, Format().base(2).width(64).fill(STR('0'))));
}
//*************************************************************************
@ -184,7 +184,7 @@ namespace
{
etl::wstring<22> str;
CHECK(etl::wstring<22>(STR("000")) == etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("000")) == etl::to_string(uint8_t(0), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("000000")) == etl::to_string(uint16_t(0), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("00000000000")) == etl::to_string(uint32_t(0), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("0000000000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(8).width(22).fill(STR('0'))));
@ -194,15 +194,15 @@ namespace
CHECK(etl::wstring<22>(STR("20000000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("1000000000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("177")) == etl::to_string(int8_t(127), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("077777")) == etl::to_string(int16_t(32767), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("17777777777")) == etl::to_string(int32_t(2147483647ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("0777777777777777777777")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("177")) == etl::to_string(int8_t(INT8_MAX), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("077777")) == etl::to_string(int16_t(INT16_MAX), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("17777777777")) == etl::to_string(int32_t(INT32_MAX), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("0777777777777777777777")) == etl::to_string(int64_t(INT64_MAX), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("200")) == etl::to_string(int8_t(-128), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("100000")) == etl::to_string(int16_t(-32768), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("20000000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("1000000000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(8).width(22).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("200")) == etl::to_string(int8_t(INT8_MIN), str, Format().base(8).width(3).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("100000")) == etl::to_string(int16_t(INT16_MIN), str, Format().base(8).width(6).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("20000000000")) == etl::to_string(int32_t(INT32_MIN), str, Format().base(8).width(11).fill(STR('0'))));
CHECK(etl::wstring<22>(STR("1000000000000000000000")) == etl::to_string(int64_t(INT64_MIN), str, Format().base(8).width(22).fill(STR('0'))));
}
//*************************************************************************
@ -210,7 +210,7 @@ namespace
{
etl::wstring<16> str;
CHECK(etl::wstring<16>(STR("00")) == etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("00")) == etl::to_string(uint8_t(0), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("0000")) == etl::to_string(uint16_t(0), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("00000000")) == etl::to_string(uint32_t(0), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("0000000000000000")) == etl::to_string(uint64_t(0), str, Format().base(16).width(16).fill(STR('0'))));
@ -220,15 +220,15 @@ namespace
CHECK(etl::wstring<16>(STR("80000000")) == etl::to_string(uint32_t(2147483648ul), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("8000000000000000")) == etl::to_string(uint64_t(9223372036854775808ull), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("7f")) == etl::to_string(int8_t(127), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("7fff")) == etl::to_string(int16_t(32767), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("7fffffff")) == etl::to_string(int32_t(2147483647ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("7fffffffffffffff")) == etl::to_string(int64_t(9223372036854775807ll), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("7f")) == etl::to_string(int8_t(INT8_MAX), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("7fff")) == etl::to_string(int16_t(INT16_MAX), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("7fffffff")) == etl::to_string(int32_t(INT32_MAX), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("7fffffffffffffff")) == etl::to_string(int64_t(INT64_MAX), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("80")) == etl::to_string(int8_t(-128), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("8000")) == etl::to_string(int16_t(-32768), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("80000000")) == etl::to_string(int32_t(-2147483648ll), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("8000000000000000")) == etl::to_string(int64_t(-9223372036854775807ll - 1), str, Format().base(16).width(16).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("80")) == etl::to_string(int8_t(INT8_MIN), str, Format().base(16).width(2).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("8000")) == etl::to_string(int16_t(INT16_MIN), str, Format().base(16).width(4).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("80000000")) == etl::to_string(int32_t(INT32_MIN), str, Format().base(16).width(8).fill(STR('0'))));
CHECK(etl::wstring<16>(STR("8000000000000000")) == etl::to_string(int64_t(INT64_MIN), str, Format().base(16).width(16).fill(STR('0'))));
}
//*************************************************************************
@ -415,6 +415,223 @@ namespace
to_string(&cvi, str, Format().hex().width(10).left().fill(STR('0')), true);
CHECK(compare == str);
}
//*************************************************************************
TEST(test_integer_denominator_default_format)
{
etl::wstring<20> result;
int value = -1234567;
etl::to_string(value, 6U, result);
CHECK(etl::wstring<20>(STR("-1")) == result);
}
//*************************************************************************
TEST(test_integer_denominator_huge_precision)
{
etl::wstring<20> result;
int value = -1234560;
Format format = Format().precision(100);
etl::to_string(value, 6U, result, format);
CHECK(etl::wstring<20>(STR("-1.234560")) == result);
}
//*************************************************************************
TEST(test_integer_denominator_huge_precision_64bit)
{
etl::wstring<20> result;
int64_t value = INT64_MIN;
Format format = Format().precision(100);
etl::to_string(value, 12U, result, format);
CHECK(etl::wstring<20>(STR("-9223372.036854775808")) == result);
}
//*************************************************************************
TEST(test_integer_denominator_zero_fractional)
{
etl::wstring<20> result_i;
int value_i = -1000000;
etl::wstring<20> result_d;
double value_d = -1.000000;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::wstring<20>(STR("-1.0000")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_zero_value)
{
etl::wstring<20> result_i;
int value_i = 0;
etl::wstring<20> result_d;
double value_d = -0.000000;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::wstring<20>(STR("0.0000")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_zero_integral_small_fractional)
{
etl::wstring<20> result_i;
int value_i = -400;
etl::wstring<20> result_d;
double value_d = -0.000400;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::wstring<20>(STR("-0.0004")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_small_fractional)
{
etl::wstring<20> result_i;
int value_i = -123000400;
etl::wstring<20> result_d;
double value_d = -123.000400;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::wstring<20>(STR("-123.0004")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_very_small_fractional)
{
etl::wstring<20> result_i;
int value_i = -123000004;
etl::wstring<20> result_d;
double value_d = -123.000004;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::wstring<20>(STR("-123.0000")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_very_small_fractional_rounded_up)
{
etl::wstring<20> result_i;
int value_i = -123000050;
etl::wstring<20> result_d;
double value_d = -123.000050;
Format format = Format().precision(4);
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::wstring<20>(STR("-123.0001")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_shorter_width)
{
etl::wstring<20> result_i;
int value_i = -123456780;
etl::wstring<20> result_d;
double value_d = -123.456780;
Format format = Format().precision(4).width(6).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::wstring<20>(STR("-123.4568")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_larger_width)
{
etl::wstring<20> result_i;
int value_i = -123456780;
etl::wstring<20> result_d;
double value_d = -123.456780;
Format format = Format().precision(4).width(15).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::wstring<20>(STR(" -123.4568")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_positive_rollover)
{
etl::wstring<20> result_i;
int value_i = 123999990;
etl::wstring<20> result_d;
double value_d = 123.999990;
Format format = Format().precision(4).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::wstring<20>(STR("124.0000")) == result_i);
CHECK(result_d == result_i);
}
//*************************************************************************
TEST(test_integer_denominator_negative_rollover)
{
etl::wstring<20> result_i;
int value_i = -123999990;
etl::wstring<20> result_d;
double value_d = -123.999990;
Format format = Format().precision(4).right();
etl::to_string(value_i, 6U, result_i, format);
etl::to_string(value_d, result_d, format);
CHECK(etl::wstring<20>(STR("-124.0000")) == result_i);
CHECK(result_d == result_i);
}
};
}

8
test/vs2019/etl.vcxproj.filters
View File

@ -2990,12 +2990,12 @@
<ClCompile Include="..\sanity-check\wstring_stream.h.t.cpp">
<Filter>Source Files\Sanity Checks</Filter>
</ClCompile>
<ClCompile Include="..\sanity-check\bip_buffer_spsc_atomic.h.t.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_bip_buffer_spsc_atomic.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\sanity-check\bip_buffer_spsc_atomic.h.t.cpp">
<Filter>Source Files\Sanity Checks</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<None Include="..\..\library.properties">
@ -3140,4 +3140,4 @@
<Filter>Resource Files</Filter>
</Natvis>
</ItemGroup>
</Project>
</Project>