From 743d4e32ca0a7bf5c512f4eb6178ff349db1590f Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Mon, 24 Oct 2022 14:24:28 +0100 Subject: [PATCH] Finished floating point conversions and tests --- include/etl/bit.h | 23 +- include/etl/to_arithmetic.h | 406 ++++++----- test/test_bit.cpp | 25 +- test/test_string_to_arithmetic.cpp | 989 -------------------------- test/test_to_arithmetic.cpp | 1020 +++++++++++++++++++++++++++ test/test_to_arithmetic_u16.cpp | 1020 +++++++++++++++++++++++++++ test/test_to_arithmetic_u32.cpp | 1020 +++++++++++++++++++++++++++ test/test_to_arithmetic_wchar_t.cpp | 1020 +++++++++++++++++++++++++++ test/vs2019/etl.vcxproj | 33 +- test/vs2019/etl.vcxproj.filters | 14 +- 10 files changed, 4368 insertions(+), 1202 deletions(-) delete mode 100644 test/test_string_to_arithmetic.cpp create mode 100644 test/test_to_arithmetic.cpp create mode 100644 test/test_to_arithmetic_u16.cpp create mode 100644 test/test_to_arithmetic_u32.cpp create mode 100644 test/test_to_arithmetic_wchar_t.cpp diff --git a/include/etl/bit.h b/include/etl/bit.h index 05ea0769..eb7d5817 100644 --- a/include/etl/bit.h +++ b/include/etl/bit.h @@ -47,12 +47,14 @@ SOFTWARE. namespace etl { //*************************************************************************** - /// bit_cast + /// bit_cast - Type to different type. //*************************************************************************** template - typename etl::enable_if<(sizeof(TDestination) == sizeof(TSource)) && - etl::is_trivially_copyable::value && - etl::is_trivially_copyable::value, TDestination>::type + ETL_NODISCARD + typename etl::enable_if::value&& etl::is_integral::value) && + (sizeof(TDestination) == sizeof(TSource)) && + etl::is_trivially_copyable::value && + etl::is_trivially_copyable::value, TDestination>::type bit_cast(const TSource& source) ETL_NOEXCEPT { TDestination destination; @@ -62,6 +64,19 @@ namespace etl return destination; } + //*************************************************************************** + /// bit_cast - Integral to integral + //*************************************************************************** + template + ETL_NODISCARD + ETL_CONSTEXPR14 + typename etl::enable_if<(etl::is_integral::value && etl::is_integral::value) && + (sizeof(TDestination) == sizeof(TSource)), TDestination>::type + bit_cast(const TSource& source) ETL_NOEXCEPT + { + return static_cast(source); + } + //*************************************************************************** /// byteswap //*************************************************************************** diff --git a/include/etl/to_arithmetic.h b/include/etl/to_arithmetic.h index b13dbffa..3ab2a60d 100644 --- a/include/etl/to_arithmetic.h +++ b/include/etl/to_arithmetic.h @@ -55,6 +55,7 @@ namespace etl { Not_Set, Valid, + Invalid_Radix, Invalid_Format, Invalid_Float, Signed_To_Unsigned, @@ -62,8 +63,9 @@ namespace etl }; ETL_DECLARE_ENUM_TYPE(to_arithmetic_status, int) - ETL_ENUM_TYPE(Not_Set, "Not_Set") + ETL_ENUM_TYPE(Not_Set, "Not Set") ETL_ENUM_TYPE(Valid, "Valid") + ETL_ENUM_TYPE(Invalid_Radix, "Invalid Radix") ETL_ENUM_TYPE(Invalid_Format, "Invalid Format") ETL_ENUM_TYPE(Invalid_Float, "Invalid Float") ETL_ENUM_TYPE(Signed_To_Unsigned, "Signed To Unsigned") @@ -85,6 +87,8 @@ namespace etl //******************************************* /// Default constructor. //******************************************* + ETL_NODISCARD + ETL_CONSTEXPR14 to_arithmetic_result() : conversion_value(static_cast(0)) , conversion_status(status_type::Not_Set) @@ -94,6 +98,8 @@ namespace etl //******************************************* /// Copy constructor. //******************************************* + ETL_NODISCARD + ETL_CONSTEXPR14 to_arithmetic_result(const to_arithmetic_result& other) : conversion_value(other.conversion_value) , conversion_status(other.conversion_status) @@ -103,6 +109,8 @@ namespace etl //******************************************* /// Returns true if the result has a valid value. //******************************************* + ETL_NODISCARD + ETL_CONSTEXPR14 bool has_value() const { return (conversion_status == status_type::Valid); @@ -111,6 +119,8 @@ namespace etl //******************************************* /// Returns true if the result has a valid value. //******************************************* + ETL_NODISCARD + ETL_CONSTEXPR14 operator bool() const { return has_value(); @@ -120,6 +130,8 @@ namespace etl /// Returns the value, if valid. /// Otherwise undefined. //******************************************* + ETL_NODISCARD + ETL_CONSTEXPR14 value_type value() const { return conversion_value; @@ -128,6 +140,7 @@ namespace etl //******************************************* /// Sets the value. //******************************************* + ETL_CONSTEXPR14 void value(value_type value) { conversion_value = value; @@ -137,6 +150,8 @@ namespace etl /// Returns the value, if valid. /// Otherwise undefined. //******************************************* + ETL_NODISCARD + ETL_CONSTEXPR14 operator value_type() const { return value(); @@ -147,10 +162,14 @@ namespace etl /// One of the following:- /// Not_Set /// Valid + /// Invalid_Radix /// Invalid_Format + /// Invalid_Float /// Signed_To_Unsigned /// Overflow //******************************************* + ETL_NODISCARD + ETL_CONSTEXPR14 status_type status() const { return conversion_status; @@ -158,7 +177,16 @@ namespace etl //******************************************* /// Sets the status. + /// One of the following:- + /// Not_Set + /// Valid + /// Invalid_Radix + /// Invalid_Format + /// Invalid_Float + /// Signed_To_Unsigned + /// Overflow //******************************************* + ETL_CONSTEXPR14 void status(status_type status_) { conversion_status = status_; @@ -172,97 +200,88 @@ namespace etl namespace private_to_arithmetic { - //*********************************************************************** - /// - //*********************************************************************** - struct character_set + static ETL_CONSTANT char Positive_Char = '+'; + static ETL_CONSTANT char Negative_Char = '-'; + static ETL_CONSTANT char Radix_Point1_Char = '.'; + static ETL_CONSTANT char Radix_Point2_Char = ','; + static ETL_CONSTANT char Exponential_Char = 'e'; + + //******************************************* + ETL_NODISCARD + inline + ETL_CONSTEXPR14 + bool is_valid(char c, etl::radix::value_type radix) { - typedef char value_type; - typedef const value_type* string_type; - static ETL_CONSTANT string_type Valid_Chars = "+-.,eE0123456789abcdefABCDEF"; - static ETL_CONSTANT int Valid_Length = etl::strlen(Valid_Chars); - static ETL_CONSTANT value_type Positive_Char = '+'; - static ETL_CONSTANT value_type Negative_Char = '-'; - static ETL_CONSTANT value_type Radix_Point1 = '.'; - static ETL_CONSTANT value_type Radix_Point2 = ','; - static ETL_CONSTANT value_type Exponential = 'e'; - static ETL_CONSTANT value_type Unknown_Char = '?'; - - //******************************************* - ETL_NODISCARD - ETL_CONSTEXPR14 - static bool is_valid(char c, etl::radix::value_type radix) + switch (radix) { - switch (radix) + case etl::radix::binary: { - case etl::radix::binary: - { - return (c >= '0') && (c <= '1'); - break; - } + return (c >= '0') && (c <= '1'); + break; + } - case etl::radix::octal: - { - return (c >= '0') && (c <= '7'); - break; - } + case etl::radix::octal: + { + return (c >= '0') && (c <= '7'); + break; + } - case etl::radix::decimal: - { - return (c >= '0') && (c <= '9'); - break; - } + case etl::radix::decimal: + { + return (c >= '0') && (c <= '9'); + break; + } - case etl::radix::hex: - { - return ((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f')); - break; - } + case etl::radix::hex: + { + return ((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f')); + break; + } - default: - { - return false; - break; - } + default: + { + return false; + break; } } + } - //******************************************* - ETL_NODISCARD - ETL_CONSTEXPR14 - static char digit_value(char c, etl::radix::value_type radix) + //******************************************* + ETL_NODISCARD + inline + ETL_CONSTEXPR14 + char digit_value(char c, etl::radix::value_type radix) + { + switch (radix) { - switch (radix) + case etl::radix::binary: + case etl::radix::octal: + case etl::radix::decimal: { - case etl::radix::binary: - case etl::radix::octal: - case etl::radix::decimal: - { + return c - '0'; + break; + } + + case etl::radix::hex: + { + if ((c >= '0') && (c <= '9')) + { return c - '0'; - break; } - - case etl::radix::hex: + else { - if ((c >= '0') && (c <= '9')) - { - return c - '0'; - } - else - { - return (c - 'a') + 10; - } - break; + return (c - 'a') + 10; } + break; + } - default: - { - return 0; - break; - } + default: + { + return 0; + break; } } - }; + } //******************************************* ETL_NODISCARD @@ -279,69 +298,12 @@ namespace etl } //******************************************* + template ETL_NODISCARD - inline ETL_CONSTEXPR14 - char convert(char c) + char convert(TChar c) { - return to_lower(c); - } - - //******************************************* - ETL_NODISCARD - inline - ETL_CONSTEXPR14 - char convert(wchar_t c) - { - ETL_STATIC_CONSTANT wchar_t* Valid_Chars = L"+-.,eE0123456789abcdefABCDEF"; - - for (int i = 0; i < character_set::Valid_Length; ++i) - { - if (c == Valid_Chars[i]) - { - return to_lower(character_set::Valid_Chars[i]); - } - } - - return character_set::Unknown_Char; - } - - //******************************************* - ETL_NODISCARD - inline - ETL_CONSTEXPR14 - char convert(char16_t c) - { - ETL_STATIC_CONSTANT char16_t* Valid_Chars = u"+-.,eE0123456789abcdefABCDEF"; - - for (int i = 0; i < character_set::Valid_Length; ++i) - { - if (c == Valid_Chars[i]) - { - return to_lower(character_set::Valid_Chars[i]); - } - } - - return character_set::Unknown_Char; - } - - //******************************************* - ETL_NODISCARD - inline - ETL_CONSTEXPR14 - char convert(char32_t c) - { - ETL_STATIC_CONSTANT char32_t* Valid_Chars = U"+-.,eE0123456789abcdefABCDEF"; - - for (int i = 0; i < character_set::Valid_Length; ++i) - { - if (c == Valid_Chars[i]) - { - return to_lower(character_set::Valid_Chars[i]); - } - } - - return character_set::Unknown_Char; + return to_lower(static_cast(c)); } //*************************************************************************** @@ -356,8 +318,8 @@ namespace etl { // Check for prefix. const char c = convert(view[0]); - const bool has_positive_prefix = (c == character_set::Positive_Char); - const bool has_negative_prefix = (c == character_set::Negative_Char); + const bool has_positive_prefix = (c == Positive_Char); + const bool has_negative_prefix = (c == Negative_Char); // Step over the prefix, if present. if (has_positive_prefix || has_negative_prefix) @@ -409,7 +371,7 @@ namespace etl bool is_success = false; bool is_not_overflow = false; - const bool is_valid_char = character_set::is_valid(c, radix); + const bool is_valid_char = is_valid(c, radix); if (is_valid_char) { @@ -421,7 +383,7 @@ namespace etl if (is_not_overflow) { - const char digit = character_set::digit_value(c, radix); + const char digit = digit_value(c, radix); // No addition overflow? is_not_overflow = ((maximum - digit) >= integral_value); @@ -449,24 +411,24 @@ namespace etl //********************************* ETL_NODISCARD - ETL_CONSTEXPR14 - bool has_value() const + ETL_CONSTEXPR14 + bool has_value() const { return conversion_status == to_arithmetic_status::Valid; } //********************************* ETL_NODISCARD - ETL_CONSTEXPR14 - TValue value() const + ETL_CONSTEXPR14 + TValue value() const { return integral_value; } //********************************* ETL_NODISCARD - ETL_CONSTEXPR14 - to_arithmetic_status status() const + ETL_CONSTEXPR14 + to_arithmetic_status status() const { return conversion_status; } @@ -492,10 +454,10 @@ namespace etl , floating_point_value(0) , is_negative_mantissa(false) , is_negative_exponent(false) - , exponent_value(0) - , conversion_status(to_arithmetic_status::Valid) - , state(Integral) , expecting_sign(true) + , exponent_value(0) + , state(Integral) + , conversion_status(to_arithmetic_status::Valid) { } @@ -511,26 +473,26 @@ namespace etl //*************************** case Integral: { - if (expecting_sign && ((c == character_set::Positive_Char) || (c == character_set::Negative_Char))) + if (expecting_sign && ((c == Positive_Char) || (c == Negative_Char))) { - is_negative_mantissa = (c == character_set::Negative_Char); + is_negative_mantissa = (c == Negative_Char); expecting_sign = false; } // Radix point? - else if ((c == character_set::Radix_Point1) || (c == character_set::Radix_Point2)) + else if ((c == Radix_Point1_Char) || (c == Radix_Point2_Char)) { expecting_sign = false; state = Fractional; } // Exponential? - else if (c == character_set::Exponential) + else if (c == Exponential_Char) { expecting_sign = true; state = Exponential; } - else if (character_set::is_valid(c, etl::radix::decimal)) + else if (is_valid(c, etl::radix::decimal)) { - const char digit = character_set::digit_value(c, etl::radix::decimal); + const char digit = digit_value(c, etl::radix::decimal); floating_point_value *= 10; is_negative_mantissa ? floating_point_value -= digit : floating_point_value += digit; conversion_status = to_arithmetic_status::Valid; @@ -548,20 +510,20 @@ namespace etl case Fractional: { // Radix point? - if ((c == character_set::Radix_Point1) || (c == character_set::Radix_Point2)) + if ((c == Radix_Point1_Char) || (c == Radix_Point2_Char)) { conversion_status = to_arithmetic_status::Invalid_Format; is_success = false; } // Exponential? - else if (c == character_set::Exponential) + else if (c == Exponential_Char) { expecting_sign = true; state = Exponential; } - else if (character_set::is_valid(c, etl::radix::decimal)) + else if (is_valid(c, etl::radix::decimal)) { - const char digit = character_set::digit_value(c, etl::radix::decimal); + const char digit = digit_value(c, etl::radix::decimal); divisor *= 10; long double fraction = digit / divisor; is_negative_mantissa ? floating_point_value -= fraction : floating_point_value += fraction; @@ -578,20 +540,20 @@ namespace etl //*************************** case Exponential: { - if (expecting_sign && ((c == character_set::Positive_Char) || (c == character_set::Negative_Char))) + if (expecting_sign && ((c == Positive_Char) || (c == Negative_Char))) { - is_negative_exponent = (c == character_set::Negative_Char); + is_negative_exponent = (c == Negative_Char); expecting_sign = false; } // Radix point? - else if ((c == character_set::Radix_Point1) || (c == character_set::Radix_Point2) || (c == character_set::Exponential)) + else if ((c == Radix_Point1_Char) || (c == Radix_Point2_Char) || (c == Exponential_Char)) { conversion_status = to_arithmetic_status::Invalid_Format; is_success = false; } - else if (character_set::is_valid(c, etl::radix::decimal)) + else if (is_valid(c, etl::radix::decimal)) { - const char digit = character_set::digit_value(c, etl::radix::decimal); + const char digit = digit_value(c, etl::radix::decimal); exponent_value *= etl::radix::decimal; is_negative_exponent ? exponent_value -= digit : exponent_value += digit; } @@ -657,23 +619,46 @@ namespace etl long double divisor; long double floating_point_value; - bool is_negative_mantissa; - bool is_negative_exponent; - int exponent_value; - to_arithmetic_status conversion_status; - int state; + bool is_negative_mantissa; + bool is_negative_exponent; bool expecting_sign; + int exponent_value; + int state; + to_arithmetic_status conversion_status; }; //*************************************************************************** // Define an unsigned accumulator type that is at least as large as TValue. //*************************************************************************** - template - struct accumulator_type_select + template + struct accumulator_type_select; + + template <> + struct accumulator_type_select<8U> { - typedef typename etl::smallest_uint_for_bits::bits>::type type; + typedef uint32_t type; }; + template <> + struct accumulator_type_select<16U> + { + typedef uint32_t type; + }; + + template <> + struct accumulator_type_select<32U> + { + typedef uint32_t type; + }; + +#if ETL_USING_64BIT_TYPES + template <> + struct accumulator_type_select<64U> + { + typedef uint64_t type; + }; +#endif + //*************************************************************************** /// Text to integral from view, radix value and maximum. //*************************************************************************** @@ -686,8 +671,8 @@ namespace etl { etl::to_arithmetic_result accumulator_result; - etl::basic_string_view::const_iterator itr = view.begin(); - const etl::basic_string_view::const_iterator itr_end = view.end(); + typename etl::basic_string_view::const_iterator itr = view.begin(); + const typename etl::basic_string_view::const_iterator itr_end = view.end(); integral_accumulator accumulator(radix, maximum); @@ -721,44 +706,55 @@ namespace etl using namespace etl::private_to_arithmetic; etl::to_arithmetic_result result; - - // Is this a negative number? - const bool is_negative = check_and_remove_sign_prefix(view); - if (view.empty()) + if (is_valid_radix(radix)) { - result.status(to_arithmetic_status::Invalid_Format); - } - else - { - // Make sure we're not trying to put a negative value into an unsigned type. - if (is_negative && etl::is_unsigned::value) + // Is this a negative number? + const bool is_negative = check_and_remove_sign_prefix(view); + + if (view.empty()) { - result.status(to_arithmetic_status::Signed_To_Unsigned); + result.status(to_arithmetic_status::Invalid_Format); } else { - const bool is_decimal = (radix == etl::radix::decimal); - - // What's the maximum absolute value for the type value we're trying to convert to? - typedef typename accumulator_type_select::type accumulator_type; - - const accumulator_type maximum = is_negative ? etl::absolute_unsigned(etl::integral_limits::min) - : is_decimal ? etl::integral_limits::max - : etl::integral_limits::type>::max; - // Do the conversion. - etl::to_arithmetic_result accumulator_result = to_arithmetic_integral(view, radix, maximum); - - result.status(accumulator_result.status()); - - // Was it successful? - if (accumulator_result.has_value()) + // Make sure we're not trying to put a negative value into an unsigned type. + if (is_negative && etl::is_unsigned::value) { - // Convert from the accumulator type to the desired type. - result.value(is_negative ? static_cast(0) - accumulator_result.value() : etl::bit_cast(accumulator_result.value())); + result.status(to_arithmetic_status::Signed_To_Unsigned); + } + else + { + const bool is_decimal = (radix == etl::radix::decimal); + + // Select the type we use for the accumulator. + typedef typename accumulator_type_select::bits>::type accumulator_type; + + // Find the maximum absolute value for the type value we're trying to convert to. + const accumulator_type maximum = is_negative ? etl::absolute_unsigned(etl::integral_limits::min) + : is_decimal ? etl::integral_limits::max + : etl::integral_limits::type>::max; + // Do the conversion. + etl::to_arithmetic_result accumulator_result = to_arithmetic_integral(view, radix, maximum); + + result.status(accumulator_result.status()); + + // Was it successful? + if (accumulator_result.has_value()) + { + typedef typename etl::make_unsigned::type uvalue_t; + const uvalue_t uvalue = static_cast(accumulator_result.value()); + + // Convert from the accumulator type to the desired type. + result.value(is_negative ? static_cast(0) - uvalue : etl::bit_cast(uvalue)); + } } } } + else + { + result.status(to_arithmetic_status::Invalid_Radix); + } return result; } @@ -916,8 +912,8 @@ namespace etl { floating_point_accumulator accumulator; - etl::basic_string_view::const_iterator itr = view.begin(); - etl::basic_string_view::const_iterator itr_end = view.end(); + typename etl::basic_string_view::const_iterator itr = view.begin(); + const typename etl::basic_string_view::const_iterator itr_end = view.end(); while ((itr != itr_end) && accumulator.add(convert(*itr))) { @@ -932,14 +928,16 @@ namespace etl TValue value = static_cast(accumulator.value()); int exponent = accumulator.exponent(); - value *= pow(10.0, exponent); + value *= pow(static_cast(10.0), static_cast(exponent)); // Check that the result is a valid floating point number. - if (value == etl::numeric_limits::infinity()) + if ((value == etl::numeric_limits::infinity()) || + (value == -etl::numeric_limits::infinity())) { result.status(to_arithmetic_status::Overflow); } - else if (value == etl::numeric_limits::quiet_NaN()) + // Check for NaN. + else if (value != value) { result.status(to_arithmetic_status::Invalid_Float); } diff --git a/test/test_bit.cpp b/test/test_bit.cpp index 43dae6a1..b73737c1 100644 --- a/test/test_bit.cpp +++ b/test/test_bit.cpp @@ -196,12 +196,31 @@ namespace SUITE(test_bit) { //************************************************************************* - TEST(test_bit_cast) + TEST(test_bit_cast_integrals) { - int32_t i = 0x12345678; - uint32_t ui = etl::bit_cast(i); + int32_t i; + uint32_t ui; + i = 0x12345678; + ui = etl::bit_cast(i); CHECK_EQUAL(i, ui); + + i = -1234567890; + ui = etl::bit_cast(i); + CHECK_EQUAL(i, static_cast(ui)); + } + + //************************************************************************* + TEST(test_bit_cast_different_types) + { + using Int = etl::smallest_int_for_bits_t; + + Int i1; + float f = 123.456789f; + memcpy(&i1, &f, sizeof(float)); + + Int i2 = etl::bit_cast(f); + CHECK_EQUAL(i1, i2); } //************************************************************************* diff --git a/test/test_string_to_arithmetic.cpp b/test/test_string_to_arithmetic.cpp deleted file mode 100644 index 74765190..00000000 --- a/test/test_string_to_arithmetic.cpp +++ /dev/null @@ -1,989 +0,0 @@ -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. -https://github.com/ETLCPP/etl -https://www.etlcpp.com - -Copyright(c) 2019 John Wellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -#include "unit_test_framework.h" - -#include -#include -#include - -#include "etl/to_arithmetic.h" -#include "etl/string.h" -#include "etl/format_spec.h" - -#undef STR -#define STR(x) x - -namespace -{ - //************************************************************************* - template - std::ostream& operator <<(std::ostream& os, const etl::to_arithmetic_result& result) - { - if (result.has_value()) - { - os << result.value(); - } - else - { - os << result.status().c_str(); - } - - return os; - } - - typedef etl::format_spec Format; - - SUITE(test_to_arithmetic) - { - //************************************************************************* - TEST(test_invalid_radixes) - { - const std::string text("128"); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 0)); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 1)); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 3)); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 4)); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 5)); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 6)); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 7)); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 9)); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 11)); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 12)); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 13)); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 14)); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 15)); - CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 17)); - } - - //************************************************************************* - TEST(test_invalid_binary_numerics) - { - const std::string text1(" 101"); - const std::string text2("101 "); - const std::string text3("121"); - const std::string text4(""); - const std::string text5("-101"); - - CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::bin)); - CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::bin)); - CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::bin)); - CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::bin)); - CHECK(!etl::to_arithmetic(text5.c_str(), text5.size(), etl::bin)); - - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text1.c_str(), text1.size(), etl::bin).status()); - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text2.c_str(), text2.size(), etl::bin).status()); - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text3.c_str(), text3.size(), etl::bin).status()); - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text4.c_str(), text4.size(), etl::bin).status()); - CHECK_EQUAL(etl::to_arithmetic_status::Signed_To_Unsigned, etl::to_arithmetic(text5.c_str(), text5.size(), etl::bin).status()); - } - - //************************************************************************* - TEST(test_valid_binary_numerics) - { - const std::string value1("0"); - const std::string value2("1"); - const std::string value3("0101"); - const std::string value4("1010"); - const std::string value5("01010011"); - const std::string value6("10101100"); - const std::string value7("-01010100"); - - CHECK_EQUAL(int(0), int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::bin).value())); - CHECK_EQUAL(int(1), int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::bin).value())); - CHECK_EQUAL(int(5), int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::bin).value())); - CHECK_EQUAL(int(10), int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::bin).value())); - CHECK_EQUAL(int(83), int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::bin).value())); - CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::bin).value())); - CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::bin).value())); - - CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::bin).status())); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::bin).status())); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::bin).status())); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::bin).status())); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::bin).status())); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::bin).status())); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::bin).status())); - } - - //************************************************************************* - TEST(test_maximum_binary_numerics) - { - const std::string int8_max("01111111"); - const std::string int8_min_neg("-10000000"); - const std::string int8_min_2c("10000000"); - - const std::string uint8_max("11111111"); - const std::string uint8_min("00000000"); - - const std::string int16_max("0111111111111111"); - const std::string int16_min_neg("-1000000000000000"); - const std::string int16_min_2c("1000000000000000"); - - const std::string uint16_max("1111111111111111"); - const std::string uint16_min("0000000000000000"); - - const std::string int32_max("01111111111111111111111111111111"); - const std::string int32_min_neg("-10000000000000000000000000000000"); - const std::string int32_min_2c("10000000000000000000000000000000"); - - const std::string uint32_max("11111111111111111111111111111111"); - const std::string uint32_min("0"); - - const std::string int64_max("0111111111111111111111111111111111111111111111111111111111111111"); - const std::string int64_min_neg("-1000000000000000000000000000000000000000000000000000000000000000"); - const std::string int64_min_2c("1000000000000000000000000000000000000000000000000000000000000000"); - - const std::string uint64_max("1111111111111111111111111111111111111111111111111111111111111111"); - const std::string uint64_min("0"); - - CHECK_EQUAL(127, etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::bin)); - CHECK_EQUAL(-128, etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::bin)); - CHECK_EQUAL(-128, etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::bin)); - - CHECK_EQUAL(255, etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::bin)); - CHECK_EQUAL(0, etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::bin)); - - CHECK_EQUAL(32767, etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::bin)); - CHECK_EQUAL(-32768, etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::bin)); - CHECK_EQUAL(-32768, etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::bin)); - - CHECK_EQUAL(65535, etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::bin)); - CHECK_EQUAL(0, etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::bin)); - - CHECK_EQUAL(2147483647LL, etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::bin)); - CHECK_EQUAL(-2147483648LL, etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::bin)); - CHECK_EQUAL(-2147483648LL, etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::bin)); - - CHECK_EQUAL(4294967295, etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::bin)); - CHECK_EQUAL(0, etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::bin)); - - CHECK_EQUAL(9223372036854775807LL, etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::bin)); - CHECK_EQUAL(-9223372036854775808LL, etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::bin)); - CHECK_EQUAL(-9223372036854775808LL, etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::bin)); - - CHECK_EQUAL(18446744073709551615ULL, etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::bin)); - CHECK_EQUAL(0ULL, etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::bin)); - } - - //************************************************************************* - TEST(test_binary_numerics_overflow) - { - const std::string int8_overflow_max("100000000"); - const std::string int8_overflow_min("-100000000"); - - const std::string uint8_overflow_max("100000000"); - - const std::string int16_overflow_max("10000000000000000"); - const std::string int16_overflow_min("-10000000000000000"); - - const std::string uint16_overflow_max("10000000000000000"); - - const std::string int32_overflow_max("100000000000000000000000000000000"); - const std::string int32_overflow_min("-100000000000000000000000000000000"); - - const std::string uint32_overflow_max("100000000000000000000000000000000"); - - const std::string int64_overflow_max("10000000000000000000000000000000000000000000000000000000000000000"); - const std::string int64_overflow_min("-10000000000000000000000000000000000000000000000000000000000000000"); - - const std::string uint64_overflow_max("10000000000000000000000000000000000000000000000000000000000000000"); - - CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::bin)); - CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::bin)); - - CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::bin)); - - CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::bin)); - CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::bin)); - - CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::bin)); - - CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::bin)); - CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::bin)); - - CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::bin)); - - CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::bin)); - CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::bin)); - - CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::bin)); - - - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::bin).status()); - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::bin).status()); - - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::bin).status()); - - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::bin).status()); - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::bin).status()); - - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::bin).status()); - - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::bin).status()); - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::bin).status()); - - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::bin).status()); - - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::bin).status()); - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::bin).status()); - - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::bin).status()); - } - - //************************************************************************* - TEST(test_invalid_octal_numerics) - { - const std::string text1(" 127"); - const std::string text2("127 "); - const std::string text3("187"); - const std::string text4("-187"); - - CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::oct)); - CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::oct)); - CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::oct)); - CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::oct)); - } - - //************************************************************************* - TEST(test_valid_octal_numerics) - { - const std::string value1("0"); - const std::string value2("01"); - const std::string value3("05"); - const std::string value4("012"); - const std::string value5("0123"); - const std::string value6("0254"); - const std::string value7("-0124"); - - CHECK_EQUAL(int(0), int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::oct).value())); - CHECK_EQUAL(int(1), int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::oct).value())); - CHECK_EQUAL(int(5), int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::oct).value())); - CHECK_EQUAL(int(10), int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::oct).value())); - CHECK_EQUAL(int(83), int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::oct).value())); - CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::oct).value())); - CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::oct).value())); - } - - //************************************************************************* - TEST(test_maximum_octal_numerics) - { - const std::string int8_max("177"); - const std::string int8_min_neg("-200"); - const std::string int8_min_2c("200"); - - const std::string uint8_max("377"); - const std::string uint8_min("0"); - - const std::string int16_max("77777"); - const std::string int16_min_neg("-100000"); - const std::string int16_min_2c("100000"); - - const std::string uint16_max("177777"); - const std::string uint16_min("0"); - - const std::string int32_max("17777777777"); - const std::string int32_min_neg("-20000000000"); - const std::string int32_min_2c("20000000000"); - - const std::string uint32_max("37777777777"); - const std::string uint32_min("0"); - - const std::string int64_max("777777777777777777777"); - const std::string int64_min_neg("-1000000000000000000000"); - const std::string int64_min_2c("1000000000000000000000"); - - const std::string uint64_max("1777777777777777777777"); - const std::string uint64_min("0"); - - CHECK_EQUAL(127, etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::oct)); - CHECK_EQUAL(-128, etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::oct)); - CHECK_EQUAL(-128, etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::oct)); - - CHECK_EQUAL(255, etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::oct)); - CHECK_EQUAL(0, etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::oct)); - - CHECK_EQUAL(32767, etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::oct)); - CHECK_EQUAL(-32768, etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::oct)); - CHECK_EQUAL(-32768, etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::oct)); - - CHECK_EQUAL(65535, etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::oct)); - CHECK_EQUAL(0, etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::oct)); - - CHECK_EQUAL(2147483647LL, etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::oct)); - CHECK_EQUAL(-2147483648LL, etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::oct)); - CHECK_EQUAL(-2147483648LL, etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::oct)); - - CHECK_EQUAL(4294967295, etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::oct)); - CHECK_EQUAL(0, etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::oct)); - - CHECK_EQUAL(9223372036854775807LL, etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::oct)); - CHECK_EQUAL(-9223372036854775808LL, etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::oct)); - CHECK_EQUAL(-9223372036854775808LL, etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::oct)); - - CHECK_EQUAL(18446744073709551615ULL, etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::oct)); - CHECK_EQUAL(0ULL, etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::oct)); - } - - //************************************************************************* - TEST(test_octal_numerics_overflow) - { - const std::string int8_overflow_max("400"); - const std::string int8_overflow_min("-400"); - - const std::string uint8_overflow_max("400"); - - const std::string int16_overflow_max("200000"); - const std::string int16_overflow_min("-200000"); - - const std::string uint16_overflow_max("200000"); - - const std::string int32_overflow_max("40000000000"); - const std::string int32_overflow_min("-40000000000"); - - const std::string uint32_overflow_max("40000000000"); - - const std::string int64_overflow_max("2000000000000000000000"); - const std::string int64_overflow_min("-2000000000000000000000"); - - const std::string uint64_overflow_max("2000000000000000000000"); - - CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::oct)); - CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::oct)); - - CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::oct)); - - CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::oct)); - CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::oct)); - - CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::oct)); - - CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::oct)); - CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::oct)); - - CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::oct)); - - CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::oct)); - CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::oct)); - - CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::oct)); - } - - //************************************************************************* - TEST(test_invalid_decimal_numerics) - { - const std::string text1(" 128"); - const std::string text2("128 "); - const std::string text3("1A8"); - const std::string text4("++128"); - const std::string text5("-+128"); - const std::string text6("+-128"); - const std::string text7("--128"); - const std::string text8("+"); - const std::string text9("-"); - const std::string text10(""); - - CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::dec)); - CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::dec)); - CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::dec)); - CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::dec)); - CHECK(!etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec)); - CHECK(!etl::to_arithmetic(text6.c_str(), text6.size(), etl::dec)); - CHECK(!etl::to_arithmetic(text7.c_str(), text7.size(), etl::dec)); - CHECK(!etl::to_arithmetic(text8.c_str(), text8.size(), etl::dec)); - CHECK(!etl::to_arithmetic(text9.c_str(), text9.size(), etl::dec)); - CHECK(!etl::to_arithmetic(text10.c_str(), text10.size(), etl::dec)); - } - - //************************************************************************* - TEST(test_valid_decimal_numerics) - { - const std::string text1("0"); - const std::string text2("1"); - const std::string text3("5"); - const std::string text4("+10"); - const std::string text5("83"); - const std::string text6("-84"); - - CHECK_EQUAL(int(0), int(etl::to_arithmetic(text1.c_str(), text1.size(), etl::dec).value())); - CHECK_EQUAL(int(1), int(etl::to_arithmetic(text2.c_str(), text2.size(), etl::dec).value())); - CHECK_EQUAL(int(5), int(etl::to_arithmetic(text3.c_str(), text3.size(), etl::dec).value())); - CHECK_EQUAL(int(10), int(etl::to_arithmetic(text4.c_str(), text4.size(), etl::dec).value())); - CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec).value())); - CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec).value())); - CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text6.c_str(), text6.size(), etl::dec).value())); - } - - //************************************************************************* - TEST(test_maximum_decimal_numerics) - { - const std::string int8_max("127"); - const std::string int8_min("-128"); - - const std::string uint8_max("255"); - const std::string uint8_min("0"); - - const std::string int16_max("32767"); - const std::string int16_min("-32768"); - - const std::string uint16_max("65535"); - const std::string uint16_min("0"); - - const std::string int32_max("2147483647"); - const std::string int32_min("-2147483648"); - - const std::string uint32_max("4294967295"); - const std::string uint32_min("0"); - - const std::string int64_max("9223372036854775807"); - const std::string int64_min("-9223372036854775808"); - - const std::string uint64_max("18446744073709551615"); - const std::string uint64_min("0"); - - CHECK_EQUAL( 127, etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::dec)); - CHECK_EQUAL(-128, etl::to_arithmetic(int8_min.c_str(), int8_min.size(), etl::dec)); - - CHECK_EQUAL(255, etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::dec)); - CHECK_EQUAL( 0, etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::dec)); - - CHECK_EQUAL( 32767, etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::dec)); - CHECK_EQUAL(-32768, etl::to_arithmetic(int16_min.c_str(), int16_min.size(), etl::dec)); - - CHECK_EQUAL(65535, etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::dec)); - CHECK_EQUAL( 0, etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::dec)); - - CHECK_EQUAL( 2147483647LL, etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::dec)); - CHECK_EQUAL(-2147483648LL, etl::to_arithmetic(int32_min.c_str(), int32_min.size(), etl::dec)); - - CHECK_EQUAL(4294967295ULL, etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::dec)); - CHECK_EQUAL( 0ULL, etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::dec)); - - CHECK_EQUAL( 9223372036854775807LL, etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::dec)); - CHECK_EQUAL(-9223372036854775808LL, etl::to_arithmetic(int64_min.c_str(), int64_min.size(), etl::dec)); - - CHECK_EQUAL(18446744073709551615ULL, etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::dec)); - CHECK_EQUAL( 0ULL, etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::dec)); - } - - //************************************************************************* - TEST(test_decimal_numerics_overflow) - { - const std::string int8_overflow_max("128"); - const std::string int8_overflow_min("-129"); - - const std::string int8_overflow_max_plus("1000"); - const std::string int8_overflow_min_plus("-1000"); - - const std::string uint8_overflow_max("256"); - - const std::string int16_overflow_max("32768"); - const std::string int16_overflow_min("-32769"); - - const std::string uint16_overflow_max("65536"); - - const std::string int32_overflow_max("2147483648"); - const std::string int32_overflow_min("-2147483649"); - - const std::string uint32_overflow_max("4294967296"); - - const std::string int64_overflow_max("9223372036854775808"); - const std::string int64_overflow_min("-9223372036854775809"); - - const std::string uint64_overflow_max("18446744073709551616"); - - CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::dec)); - CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::dec)); - - CHECK(!etl::to_arithmetic(int8_overflow_max_plus.c_str(), int8_overflow_max_plus.size(), etl::dec)); - CHECK(!etl::to_arithmetic(int8_overflow_min_plus.c_str(), int8_overflow_min_plus.size(), etl::dec)); - - CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::dec)); - - CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::dec)); - CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::dec)); - - CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::dec)); - - CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::dec)); - CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::dec)); - - CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::dec)); - - CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::dec)); - CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::dec)); - - CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::dec)); - } - - //************************************************************************* - TEST(test_invalid_hex_numerics) - { - const std::string text1(" 1Af"); - const std::string text2("1Af "); - const std::string text3("1Gf"); - const std::string text4("-1Af"); - - CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::hex)); - CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::hex)); - CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::hex)); - CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::hex)); - } - - //************************************************************************* - TEST(test_valid_hex_numerics) - { - const std::string text1("0"); - const std::string text2("1"); - const std::string text3("5"); - const std::string text4("a"); - const std::string text5("53"); - const std::string text6("Ac"); - const std::string text7("-54"); - - CHECK_EQUAL(int(0), int(etl::to_arithmetic(text1.c_str(), text1.size(), etl::hex).value())); - CHECK_EQUAL(int(1), int(etl::to_arithmetic(text2.c_str(), text2.size(), etl::hex).value())); - CHECK_EQUAL(int(5), int(etl::to_arithmetic(text3.c_str(), text3.size(), etl::hex).value())); - CHECK_EQUAL(int(10), int(etl::to_arithmetic(text4.c_str(), text4.size(), etl::hex).value())); - CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::hex).value())); - CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text6.c_str(), text6.size(), etl::hex).value())); - CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text7.c_str(), text7.size(), etl::hex).value())); - } - - //************************************************************************* - TEST(test_maximum_hex_numerics) - { - const std::string int8_max("7F"); - const std::string int8_min_neg("-80"); - const std::string int8_min_2c("80"); - - const std::string uint8_max("FF"); - const std::string uint8_min("0"); - - const std::string int16_max("7FFF"); - const std::string int16_min_neg("-8000"); - const std::string int16_min_2c("8000"); - - const std::string uint16_max("FFFF"); - const std::string uint16_min("0"); - - const std::string int32_max("7FFFFFFF"); - const std::string int32_min_neg("-80000000"); - const std::string int32_min_2c("80000000"); - - const std::string uint32_max("FFFFFFFF"); - const std::string uint32_min("0"); - - const std::string int64_max("7FFFFFFFFFFFFFFF"); - const std::string int64_min_neg("-8000000000000000"); - const std::string int64_min_2c("8000000000000000"); - - const std::string uint64_max("FFFFFFFFFFFFFFFF"); - const std::string uint64_min("0"); - - CHECK_EQUAL(127, etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::hex)); - CHECK_EQUAL(-128, etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::hex)); - CHECK_EQUAL(-128, etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::hex)); - - CHECK_EQUAL(255, etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::hex)); - CHECK_EQUAL(0, etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::hex)); - - CHECK_EQUAL(32767, etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::hex)); - CHECK_EQUAL(-32768, etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::hex)); - CHECK_EQUAL(-32768, etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::hex)); - - CHECK_EQUAL(65535, etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::hex)); - CHECK_EQUAL(0, etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::hex)); - - CHECK_EQUAL(2147483647LL, etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::hex)); - CHECK_EQUAL(-2147483648LL, etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::hex)); - CHECK_EQUAL(-2147483648LL, etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::hex)); - - CHECK_EQUAL(4294967295, etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::hex)); - CHECK_EQUAL(0, etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::hex)); - - CHECK_EQUAL(9223372036854775807LL, etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::hex)); - CHECK_EQUAL(-9223372036854775808LL, etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::hex)); - CHECK_EQUAL(-9223372036854775808LL, etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::hex)); - - CHECK_EQUAL(18446744073709551615ULL, etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::hex)); - CHECK_EQUAL(0ULL, etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::hex)); - } - - //************************************************************************* - TEST(test_hex_numerics_overflow) - { - const std::string int8_overflow_max("100"); - const std::string int8_overflow_min("-100"); - - const std::string uint8_overflow_max("100"); - - const std::string int16_overflow_max("10000"); - const std::string int16_overflow_min("-10000"); - - const std::string uint16_overflow_max("10000"); - - const std::string int32_overflow_max("100000000"); - const std::string int32_overflow_min("-100000000"); - - const std::string uint32_overflow_max("100000000"); - - const std::string int64_overflow_max("10000000000000000"); - const std::string int64_overflow_min("-10000000000000000"); - - const std::string uint64_overflow_max("10000000000000000"); - - CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::hex)); - CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::hex)); - - CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::hex)); - - CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::hex)); - CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::hex)); - - CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::hex)); - - CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::hex)); - CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::hex)); - - CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::hex)); - - CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::hex)); - CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::hex)); - - CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::hex)); - } - - //************************************************************************* - TEST(test_valid_float) - { - std::string text; - - //********************************* - text = "-123.456789"; - - float f1 = strtof(text.c_str(), nullptr); - float f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "123.456789"; - - f1 = strtof(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-1.23456789e2"; - - f1 = strtof(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-12345.6789e-2"; - - f1 = strtof(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "+12345E-2"; - - f1 = strtof(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "+12345.6789E000"; - - f1 = strtof(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - } - - //************************************************************************* - TEST(test_invalid_float) - { - std::string text; - - //********************************* - text = " -123.456789"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-123.456789 "; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-12A.456789"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-123.456A89"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "123.-456789"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "123E.45"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "123.45E1000"; - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); - } - - //************************************************************************* - TEST(test_valid_double) - { - std::string text; - - //********************************* - text = "-123.45678901234567"; - - double f1 = strtod(text.c_str(), nullptr); - double f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "123.45678901234567"; - - f1 = strtod(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-1.2345678901234567e2"; - - f1 = strtod(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-12345.678901234567e-2"; - - f1 = strtod(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "+12345E-2"; - - f1 = strtod(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "+12345.678901234567E0"; - - f1 = strtod(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - } - - //************************************************************************* - TEST(test_invalid_double) - { - std::string text; - - //********************************* - text = " -123.456789"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-123.456789 "; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-12A.456789"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-123.456A89"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "123.-456789"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "123E.45"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "123.45E1000"; - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); - } - - //************************************************************************* - TEST(test_valid_long_double) - { - std::string text; - - //********************************* - text = "-123.45678901234567"; - - long double f1 = strtold(text.c_str(), nullptr); - long double f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "123.45678901234567"; - - f1 = strtold(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-1.2345678901234567e2"; - - f1 = strtold(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-12345.678901234567e-2"; - - f1 = strtold(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "+12345E-2"; - - f1 = strtold(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "+12345.678901234567E000"; - - f1 = strtold(text.c_str(), nullptr); - f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); - - CHECK_CLOSE(f1, f2, 0.00001); - CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); - } - - //************************************************************************* - TEST(test_invalid_long_double) - { - std::string text; - - //********************************* - text = " -123.456789"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-123.456789 "; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-12A.456789"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "-123.456A89"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "123.-456789"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "123E.45"; - CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); - - //********************************* - text = "123.45E1000"; - CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); - } - - //************************************************************************* - TEST(test_constexpr_integral) - { - // constexpr const char* text{ "123" }; - // constexpr etl::string_view view(text, 3); - - // constexpr etl::optional opt = etl::to_arithmetic(view, etl::radix::decimal); - // constexpr int i = opt.value(); - - // CHECK_EQUAL(123, i); - } - - //************************************************************************* - TEST(test_constexpr_floating_point) - { - //constexpr const char* text{ "123.456789" }; - //constexpr etl::string_view view(text, 3); - - //constexpr etl::optional opt = etl::to_arithmetic(view); - //constexpr double i = opt.value(); - - //CHECK_EQUAL(123, i); - } - } -} - diff --git a/test/test_to_arithmetic.cpp b/test/test_to_arithmetic.cpp new file mode 100644 index 00000000..2cc53838 --- /dev/null +++ b/test/test_to_arithmetic.cpp @@ -0,0 +1,1020 @@ +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 John Wellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#include "unit_test_framework.h" + +#include +#include +#include + +#include "etl/to_arithmetic.h" +#include "etl/string.h" +#include "etl/format_spec.h" + +#undef STR +#define STR(x) x +using Text = std::string; + +namespace +{ + //************************************************************************* + template + std::ostream& operator <<(std::ostream& os, const etl::to_arithmetic_result& result) + { + if (result.has_value()) + { + os << result.value(); + } + else + { + os << result.status().c_str(); + } + + return os; + } + + typedef etl::format_spec Format; + + SUITE(test_to_arithmetic) + { + //************************************************************************* + TEST(test_invalid_radixes) + { + const Text text(STR("128")); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 0)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 1)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 3)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 4)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 5)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 6)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 7)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 9)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 11)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 12)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 13)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 14)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 15)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 17)); + + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 0).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 1).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 3).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 4).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 5).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 6).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 7).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 9).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 11).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 12).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 13).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 14).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 15).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 17).has_value()); + + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 0).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 1).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 3).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 4).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 5).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 6).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 7).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 9).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 11).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 12).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 13).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 14).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 15).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 17).status()); + } + + //************************************************************************* + TEST(test_invalid_binary_numerics) + { + const Text text1(STR(" 101")); + const Text text2(STR("101 ")); + const Text text3(STR("121")); + const Text text4(STR("")); + const Text text5(STR("-101")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text5.c_str(), text5.size(), etl::bin)); + + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text1.c_str(), text1.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text2.c_str(), text2.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text3.c_str(), text3.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text4.c_str(), text4.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Signed_To_Unsigned, etl::to_arithmetic(text5.c_str(), text5.size(), etl::bin).status()); + } + + //************************************************************************* + TEST(test_valid_binary_numerics) + { + const Text value1(STR("0")); + const Text value2(STR("1")); + const Text value3(STR("0101")); + const Text value4(STR("1010")); + const Text value5(STR("01010011")); + const Text value6(STR("10101100")); + const Text value7(STR("-01010100")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::bin).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::bin).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::bin).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::bin).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::bin).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::bin).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::bin).value())); + + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::bin).status())); + } + + //************************************************************************* + TEST(test_maximum_binary_numerics) + { + const Text int8_max(STR("01111111")); + const Text int8_min_neg(STR("-10000000")); + const Text int8_min_2c(STR("10000000")); + + const Text uint8_max(STR("11111111")); + const Text uint8_min(STR("00000000")); + + const Text int16_max(STR("0111111111111111")); + const Text int16_min_neg(STR("-1000000000000000")); + const Text int16_min_2c(STR("1000000000000000")); + + const Text uint16_max(STR("1111111111111111")); + const Text uint16_min(STR("0000000000000000")); + + const Text int32_max(STR("01111111111111111111111111111111")); + const Text int32_min_neg(STR("-10000000000000000000000000000000")); + const Text int32_min_2c(STR("10000000000000000000000000000000")); + + const Text uint32_max(STR("11111111111111111111111111111111")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("0111111111111111111111111111111111111111111111111111111111111111")); + const Text int64_min_neg(STR("-1000000000000000000000000000000000000000000000000000000000000000")); + const Text int64_min_2c(STR("1000000000000000000000000000000000000000000000000000000000000000")); + + const Text uint64_max(STR("1111111111111111111111111111111111111111111111111111111111111111")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::bin).value()); + } + + //************************************************************************* + TEST(test_binary_numerics_overflow) + { + const Text int8_overflow_max(STR("100000000")); + const Text int8_overflow_min(STR("-100000000")); + + const Text uint8_overflow_max(STR("100000000")); + + const Text int16_overflow_max(STR("10000000000000000")); + const Text int16_overflow_min(STR("-10000000000000000")); + + const Text uint16_overflow_max(STR("10000000000000000")); + + const Text int32_overflow_max(STR("100000000000000000000000000000000")); + const Text int32_overflow_min(STR("-100000000000000000000000000000000")); + + const Text uint32_overflow_max(STR("100000000000000000000000000000000")); + + const Text int64_overflow_max(STR("10000000000000000000000000000000000000000000000000000000000000000")); + const Text int64_overflow_min(STR("-10000000000000000000000000000000000000000000000000000000000000000")); + + const Text uint64_overflow_max(STR("10000000000000000000000000000000000000000000000000000000000000000")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::bin)); + + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::bin).status()); + } + + //************************************************************************* + TEST(test_invalid_octal_numerics) + { + const Text text1(STR(" 127")); + const Text text2(STR("127 ")); + const Text text3(STR("187")); + const Text text4(STR("-187")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::oct)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::oct)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::oct)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::oct)); + } + + //************************************************************************* + TEST(test_valid_octal_numerics) + { + const Text value1(STR("0")); + const Text value2(STR("01")); + const Text value3(STR("05")); + const Text value4(STR("012")); + const Text value5(STR("0123")); + const Text value6(STR("0254")); + const Text value7(STR("-0124")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::oct).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::oct).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::oct).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::oct).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::oct).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::oct).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::oct).value())); + } + + //************************************************************************* + TEST(test_maximum_octal_numerics) + { + const Text int8_max(STR("177")); + const Text int8_min_neg(STR("-200")); + const Text int8_min_2c(STR("200")); + + const Text uint8_max(STR("377")); + const Text uint8_min(STR("0")); + + const Text int16_max(STR("77777")); + const Text int16_min_neg(STR("-100000")); + const Text int16_min_2c(STR("100000")); + + const Text uint16_max(STR("177777")); + const Text uint16_min(STR("0")); + + const Text int32_max(STR("17777777777")); + const Text int32_min_neg(STR("-20000000000")); + const Text int32_min_2c(STR("20000000000")); + + const Text uint32_max(STR("37777777777")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("777777777777777777777")); + const Text int64_min_neg(STR("-1000000000000000000000")); + const Text int64_min_2c(STR("1000000000000000000000")); + + const Text uint64_max(STR("1777777777777777777777")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::oct).value()); + } + + //************************************************************************* + TEST(test_octal_numerics_overflow) + { + const Text int8_overflow_max(STR("400")); + const Text int8_overflow_min(STR("-400")); + + const Text uint8_overflow_max(STR("400")); + + const Text int16_overflow_max(STR("200000")); + const Text int16_overflow_min(STR("-200000")); + + const Text uint16_overflow_max(STR("200000")); + + const Text int32_overflow_max(STR("40000000000")); + const Text int32_overflow_min(STR("-40000000000")); + + const Text uint32_overflow_max(STR("40000000000")); + + const Text int64_overflow_max(STR("2000000000000000000000")); + const Text int64_overflow_min(STR("-2000000000000000000000")); + + const Text uint64_overflow_max(STR("2000000000000000000000")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::oct)); + } + + //************************************************************************* + TEST(test_invalid_decimal_numerics) + { + const Text text1(STR(" 128")); + const Text text2(STR("128 ")); + const Text text3(STR("1A8")); + const Text text4(STR("++128")); + const Text text5(STR("-+128")); + const Text text6(STR("+-128")); + const Text text7(STR("--128")); + const Text text8(STR("+")); + const Text text9(STR("-")); + const Text text10(STR("")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text6.c_str(), text6.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text7.c_str(), text7.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text8.c_str(), text8.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text9.c_str(), text9.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text10.c_str(), text10.size(), etl::dec)); + } + + //************************************************************************* + TEST(test_valid_decimal_numerics) + { + const Text text1(STR("0")); + const Text text2(STR("1")); + const Text text3(STR("5")); + const Text text4(STR("+10")); + const Text text5(STR("83")); + const Text text6(STR("-84")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(text1.c_str(), text1.size(), etl::dec).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(text2.c_str(), text2.size(), etl::dec).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(text3.c_str(), text3.size(), etl::dec).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(text4.c_str(), text4.size(), etl::dec).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text6.c_str(), text6.size(), etl::dec).value())); + } + + //************************************************************************* + TEST(test_maximum_decimal_numerics) + { + const Text int8_max(STR("127")); + const Text int8_min(STR("-128")); + + const Text uint8_max(STR("255")); + const Text uint8_min(STR("0")); + + const Text int16_max(STR("32767")); + const Text int16_min(STR("-32768")); + + const Text uint16_max(STR("65535")); + const Text uint16_min(STR("0")); + + const Text int32_max(STR("2147483647")); + const Text int32_min(STR("-2147483648")); + + const Text uint32_max(STR("4294967295")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("9223372036854775807")); + const Text int64_min(STR("-9223372036854775808")); + + const Text uint64_max(STR("18446744073709551615")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min.c_str(), int8_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min.c_str(), int16_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min.c_str(), int32_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min.c_str(), int64_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::dec).value()); + } + + //************************************************************************* + TEST(test_decimal_numerics_overflow) + { + const Text int8_overflow_max(STR("128")); + const Text int8_overflow_min(STR("-129")); + + const Text int8_overflow_max_plus(STR("1000")); + const Text int8_overflow_min_plus(STR("-1000")); + + const Text uint8_overflow_max(STR("256")); + + const Text int16_overflow_max(STR("32768")); + const Text int16_overflow_min(STR("-32769")); + + const Text uint16_overflow_max(STR("65536")); + + const Text int32_overflow_max(STR("2147483648")); + const Text int32_overflow_min(STR("-2147483649")); + + const Text uint32_overflow_max(STR("4294967296")); + + const Text int64_overflow_max(STR("9223372036854775808")); + const Text int64_overflow_min(STR("-9223372036854775809")); + + const Text uint64_overflow_max(STR("18446744073709551616")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int8_overflow_max_plus.c_str(), int8_overflow_max_plus.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int8_overflow_min_plus.c_str(), int8_overflow_min_plus.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::dec)); + } + + //************************************************************************* + TEST(test_invalid_hex_numerics) + { + const Text text1(STR(" 1Af")); + const Text text2(STR("1Af ")); + const Text text3(STR("1Gf")); + const Text text4(STR("-1Af")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::hex)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::hex)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::hex)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::hex)); + } + + //************************************************************************* + TEST(test_valid_hex_numerics) + { + const Text text1(STR("0")); + const Text text2(STR("1")); + const Text text3(STR("5")); + const Text text4(STR("a")); + const Text text5(STR("53")); + const Text text6(STR("Ac")); + const Text text7(STR("-54")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(text1.c_str(), text1.size(), etl::hex).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(text2.c_str(), text2.size(), etl::hex).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(text3.c_str(), text3.size(), etl::hex).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(text4.c_str(), text4.size(), etl::hex).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::hex).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text6.c_str(), text6.size(), etl::hex).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text7.c_str(), text7.size(), etl::hex).value())); + } + + //************************************************************************* + TEST(test_maximum_hex_numerics) + { + const Text int8_max(STR("7F")); + const Text int8_min_neg(STR("-80")); + const Text int8_min_2c(STR("80")); + + const Text uint8_max(STR("FF")); + const Text uint8_min(STR("0")); + + const Text int16_max(STR("7FFF")); + const Text int16_min_neg(STR("-8000")); + const Text int16_min_2c(STR("8000")); + + const Text uint16_max(STR("FFFF")); + const Text uint16_min(STR("0")); + + const Text int32_max(STR("7FFFFFFF")); + const Text int32_min_neg(STR("-80000000")); + const Text int32_min_2c(STR("80000000")); + + const Text uint32_max(STR("FFFFFFFF")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("7FFFFFFFFFFFFFFF")); + const Text int64_min_neg(STR("-8000000000000000")); + const Text int64_min_2c(STR("8000000000000000")); + + const Text uint64_max(STR("FFFFFFFFFFFFFFFF")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::hex).value()); + } + + //************************************************************************* + TEST(test_hex_numerics_overflow) + { + const Text int8_overflow_max(STR("100")); + const Text int8_overflow_min(STR("-100")); + + const Text uint8_overflow_max(STR("100")); + + const Text int16_overflow_max(STR("10000")); + const Text int16_overflow_min(STR("-10000")); + + const Text uint16_overflow_max(STR("10000")); + + const Text int32_overflow_max(STR("100000000")); + const Text int32_overflow_min(STR("-100000000")); + + const Text uint32_overflow_max(STR("100000000")); + + const Text int64_overflow_max(STR("10000000000000000")); + const Text int64_overflow_min(STR("-10000000000000000")); + + const Text uint64_overflow_max(STR("10000000000000000")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::hex)); + } + + //************************************************************************* + TEST(test_valid_float) + { + Text text; + + //********************************* + text = STR("-123.456789"); + + float f1 = strtof("-123.456789", nullptr); + float f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.456789"); + + f1 = strtof("123.456789", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-1.23456789e2"); + + f1 = strtof("-1.23456789e2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12345.6789e-2"); + + f1 = strtof("-12345.6789e-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345E-2"); + + f1 = strtof("+12345E-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345.6789E000"); + + f1 = strtof("+12345.6789E000", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_invalid_float) + { + Text text; + + //********************************* + text = STR(" -123.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456789 "); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12A.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456A89"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.-456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123E.45"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_valid_double) + { + Text text; + + //********************************* + text = STR("-123.45678901234567"); + + double f1 = strtod("-123.45678901234567", nullptr); + double f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45678901234567"); + + f1 = strtod("123.45678901234567", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-1.2345678901234567e7"); + + f1 = strtod("-1.2345678901234567e7", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12345.678901234567e-2"); + + f1 = strtod("-12345.678901234567e-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345E-2"); + + f1 = strtod("+12345E-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345.678901234567E0"); + + f1 = strtod("+12345.678901234567E0", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_invalid_double) + { + Text text; + + //********************************* + text = STR(" -123.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456789 "); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12A.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456A89"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.-456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123E.45"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_valid_long_double) + { + Text text; + + //********************************* + text = STR("-123.45678901234567"); + + long double f1 = strtold("-123.45678901234567", nullptr); + long double f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45678901234567"); + + f1 = strtold("123.45678901234567", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-1.2345678901234567e2"); + + f1 = strtold("-1.2345678901234567e2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12345.678901234567e-2"); + + f1 = strtold("-12345.678901234567e-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345E-2"); + + f1 = strtold("+12345E-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345.678901234567E000"); + + f1 = strtold("+12345.678901234567E000", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_invalid_long_double) + { + Text text; + + //********************************* + text = STR(" -123.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456789 "); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12A.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456A89"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.-456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123E.45"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_constexpr_integral) + { + constexpr const char* text{ "123" }; + constexpr etl::string_view view(text, 3); + + constexpr etl::to_arithmetic_result result = etl::to_arithmetic(view, etl::radix::decimal); + constexpr int i = result.value(); + + CHECK_EQUAL(123, i); + } + } +} + diff --git a/test/test_to_arithmetic_u16.cpp b/test/test_to_arithmetic_u16.cpp new file mode 100644 index 00000000..2aeb24d0 --- /dev/null +++ b/test/test_to_arithmetic_u16.cpp @@ -0,0 +1,1020 @@ +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 John Wellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#include "unit_test_framework.h" + +#include +#include +#include + +#include "etl/to_arithmetic.h" +#include "etl/u16string.h" +#include "etl/format_spec.h" + +#undef STR +#define STR(x) u##x +using Text = std::u16string; + +namespace +{ + //************************************************************************* + template + std::ostream& operator <<(std::ostream& os, const etl::to_arithmetic_result& result) + { + if (result.has_value()) + { + os << result.value(); + } + else + { + os << result.status().c_str(); + } + + return os; + } + + typedef etl::format_spec Format; + + SUITE(test_to_arithmetic) + { + //************************************************************************* + TEST(test_invalid_radixes) + { + const Text text(STR("128")); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 0)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 1)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 3)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 4)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 5)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 6)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 7)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 9)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 11)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 12)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 13)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 14)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 15)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 17)); + + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 0).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 1).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 3).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 4).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 5).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 6).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 7).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 9).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 11).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 12).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 13).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 14).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 15).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 17).has_value()); + + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 0).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 1).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 3).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 4).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 5).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 6).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 7).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 9).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 11).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 12).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 13).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 14).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 15).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 17).status()); + } + + //************************************************************************* + TEST(test_invalid_binary_numerics) + { + const Text text1(STR(" 101")); + const Text text2(STR("101 ")); + const Text text3(STR("121")); + const Text text4(STR("")); + const Text text5(STR("-101")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text5.c_str(), text5.size(), etl::bin)); + + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text1.c_str(), text1.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text2.c_str(), text2.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text3.c_str(), text3.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text4.c_str(), text4.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Signed_To_Unsigned, etl::to_arithmetic(text5.c_str(), text5.size(), etl::bin).status()); + } + + //************************************************************************* + TEST(test_valid_binary_numerics) + { + const Text value1(STR("0")); + const Text value2(STR("1")); + const Text value3(STR("0101")); + const Text value4(STR("1010")); + const Text value5(STR("01010011")); + const Text value6(STR("10101100")); + const Text value7(STR("-01010100")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::bin).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::bin).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::bin).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::bin).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::bin).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::bin).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::bin).value())); + + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::bin).status())); + } + + //************************************************************************* + TEST(test_maximum_binary_numerics) + { + const Text int8_max(STR("01111111")); + const Text int8_min_neg(STR("-10000000")); + const Text int8_min_2c(STR("10000000")); + + const Text uint8_max(STR("11111111")); + const Text uint8_min(STR("00000000")); + + const Text int16_max(STR("0111111111111111")); + const Text int16_min_neg(STR("-1000000000000000")); + const Text int16_min_2c(STR("1000000000000000")); + + const Text uint16_max(STR("1111111111111111")); + const Text uint16_min(STR("0000000000000000")); + + const Text int32_max(STR("01111111111111111111111111111111")); + const Text int32_min_neg(STR("-10000000000000000000000000000000")); + const Text int32_min_2c(STR("10000000000000000000000000000000")); + + const Text uint32_max(STR("11111111111111111111111111111111")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("0111111111111111111111111111111111111111111111111111111111111111")); + const Text int64_min_neg(STR("-1000000000000000000000000000000000000000000000000000000000000000")); + const Text int64_min_2c(STR("1000000000000000000000000000000000000000000000000000000000000000")); + + const Text uint64_max(STR("1111111111111111111111111111111111111111111111111111111111111111")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::bin).value()); + } + + //************************************************************************* + TEST(test_binary_numerics_overflow) + { + const Text int8_overflow_max(STR("100000000")); + const Text int8_overflow_min(STR("-100000000")); + + const Text uint8_overflow_max(STR("100000000")); + + const Text int16_overflow_max(STR("10000000000000000")); + const Text int16_overflow_min(STR("-10000000000000000")); + + const Text uint16_overflow_max(STR("10000000000000000")); + + const Text int32_overflow_max(STR("100000000000000000000000000000000")); + const Text int32_overflow_min(STR("-100000000000000000000000000000000")); + + const Text uint32_overflow_max(STR("100000000000000000000000000000000")); + + const Text int64_overflow_max(STR("10000000000000000000000000000000000000000000000000000000000000000")); + const Text int64_overflow_min(STR("-10000000000000000000000000000000000000000000000000000000000000000")); + + const Text uint64_overflow_max(STR("10000000000000000000000000000000000000000000000000000000000000000")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::bin)); + + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::bin).status()); + } + + //************************************************************************* + TEST(test_invalid_octal_numerics) + { + const Text text1(STR(" 127")); + const Text text2(STR("127 ")); + const Text text3(STR("187")); + const Text text4(STR("-187")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::oct)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::oct)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::oct)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::oct)); + } + + //************************************************************************* + TEST(test_valid_octal_numerics) + { + const Text value1(STR("0")); + const Text value2(STR("01")); + const Text value3(STR("05")); + const Text value4(STR("012")); + const Text value5(STR("0123")); + const Text value6(STR("0254")); + const Text value7(STR("-0124")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::oct).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::oct).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::oct).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::oct).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::oct).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::oct).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::oct).value())); + } + + //************************************************************************* + TEST(test_maximum_octal_numerics) + { + const Text int8_max(STR("177")); + const Text int8_min_neg(STR("-200")); + const Text int8_min_2c(STR("200")); + + const Text uint8_max(STR("377")); + const Text uint8_min(STR("0")); + + const Text int16_max(STR("77777")); + const Text int16_min_neg(STR("-100000")); + const Text int16_min_2c(STR("100000")); + + const Text uint16_max(STR("177777")); + const Text uint16_min(STR("0")); + + const Text int32_max(STR("17777777777")); + const Text int32_min_neg(STR("-20000000000")); + const Text int32_min_2c(STR("20000000000")); + + const Text uint32_max(STR("37777777777")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("777777777777777777777")); + const Text int64_min_neg(STR("-1000000000000000000000")); + const Text int64_min_2c(STR("1000000000000000000000")); + + const Text uint64_max(STR("1777777777777777777777")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::oct).value()); + } + + //************************************************************************* + TEST(test_octal_numerics_overflow) + { + const Text int8_overflow_max(STR("400")); + const Text int8_overflow_min(STR("-400")); + + const Text uint8_overflow_max(STR("400")); + + const Text int16_overflow_max(STR("200000")); + const Text int16_overflow_min(STR("-200000")); + + const Text uint16_overflow_max(STR("200000")); + + const Text int32_overflow_max(STR("40000000000")); + const Text int32_overflow_min(STR("-40000000000")); + + const Text uint32_overflow_max(STR("40000000000")); + + const Text int64_overflow_max(STR("2000000000000000000000")); + const Text int64_overflow_min(STR("-2000000000000000000000")); + + const Text uint64_overflow_max(STR("2000000000000000000000")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::oct)); + } + + //************************************************************************* + TEST(test_invalid_decimal_numerics) + { + const Text text1(STR(" 128")); + const Text text2(STR("128 ")); + const Text text3(STR("1A8")); + const Text text4(STR("++128")); + const Text text5(STR("-+128")); + const Text text6(STR("+-128")); + const Text text7(STR("--128")); + const Text text8(STR("+")); + const Text text9(STR("-")); + const Text text10(STR("")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text6.c_str(), text6.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text7.c_str(), text7.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text8.c_str(), text8.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text9.c_str(), text9.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text10.c_str(), text10.size(), etl::dec)); + } + + //************************************************************************* + TEST(test_valid_decimal_numerics) + { + const Text text1(STR("0")); + const Text text2(STR("1")); + const Text text3(STR("5")); + const Text text4(STR("+10")); + const Text text5(STR("83")); + const Text text6(STR("-84")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(text1.c_str(), text1.size(), etl::dec).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(text2.c_str(), text2.size(), etl::dec).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(text3.c_str(), text3.size(), etl::dec).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(text4.c_str(), text4.size(), etl::dec).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text6.c_str(), text6.size(), etl::dec).value())); + } + + //************************************************************************* + TEST(test_maximum_decimal_numerics) + { + const Text int8_max(STR("127")); + const Text int8_min(STR("-128")); + + const Text uint8_max(STR("255")); + const Text uint8_min(STR("0")); + + const Text int16_max(STR("32767")); + const Text int16_min(STR("-32768")); + + const Text uint16_max(STR("65535")); + const Text uint16_min(STR("0")); + + const Text int32_max(STR("2147483647")); + const Text int32_min(STR("-2147483648")); + + const Text uint32_max(STR("4294967295")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("9223372036854775807")); + const Text int64_min(STR("-9223372036854775808")); + + const Text uint64_max(STR("18446744073709551615")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min.c_str(), int8_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min.c_str(), int16_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min.c_str(), int32_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min.c_str(), int64_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::dec).value()); + } + + //************************************************************************* + TEST(test_decimal_numerics_overflow) + { + const Text int8_overflow_max(STR("128")); + const Text int8_overflow_min(STR("-129")); + + const Text int8_overflow_max_plus(STR("1000")); + const Text int8_overflow_min_plus(STR("-1000")); + + const Text uint8_overflow_max(STR("256")); + + const Text int16_overflow_max(STR("32768")); + const Text int16_overflow_min(STR("-32769")); + + const Text uint16_overflow_max(STR("65536")); + + const Text int32_overflow_max(STR("2147483648")); + const Text int32_overflow_min(STR("-2147483649")); + + const Text uint32_overflow_max(STR("4294967296")); + + const Text int64_overflow_max(STR("9223372036854775808")); + const Text int64_overflow_min(STR("-9223372036854775809")); + + const Text uint64_overflow_max(STR("18446744073709551616")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int8_overflow_max_plus.c_str(), int8_overflow_max_plus.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int8_overflow_min_plus.c_str(), int8_overflow_min_plus.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::dec)); + } + + //************************************************************************* + TEST(test_invalid_hex_numerics) + { + const Text text1(STR(" 1Af")); + const Text text2(STR("1Af ")); + const Text text3(STR("1Gf")); + const Text text4(STR("-1Af")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::hex)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::hex)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::hex)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::hex)); + } + + //************************************************************************* + TEST(test_valid_hex_numerics) + { + const Text text1(STR("0")); + const Text text2(STR("1")); + const Text text3(STR("5")); + const Text text4(STR("a")); + const Text text5(STR("53")); + const Text text6(STR("Ac")); + const Text text7(STR("-54")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(text1.c_str(), text1.size(), etl::hex).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(text2.c_str(), text2.size(), etl::hex).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(text3.c_str(), text3.size(), etl::hex).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(text4.c_str(), text4.size(), etl::hex).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::hex).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text6.c_str(), text6.size(), etl::hex).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text7.c_str(), text7.size(), etl::hex).value())); + } + + //************************************************************************* + TEST(test_maximum_hex_numerics) + { + const Text int8_max(STR("7F")); + const Text int8_min_neg(STR("-80")); + const Text int8_min_2c(STR("80")); + + const Text uint8_max(STR("FF")); + const Text uint8_min(STR("0")); + + const Text int16_max(STR("7FFF")); + const Text int16_min_neg(STR("-8000")); + const Text int16_min_2c(STR("8000")); + + const Text uint16_max(STR("FFFF")); + const Text uint16_min(STR("0")); + + const Text int32_max(STR("7FFFFFFF")); + const Text int32_min_neg(STR("-80000000")); + const Text int32_min_2c(STR("80000000")); + + const Text uint32_max(STR("FFFFFFFF")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("7FFFFFFFFFFFFFFF")); + const Text int64_min_neg(STR("-8000000000000000")); + const Text int64_min_2c(STR("8000000000000000")); + + const Text uint64_max(STR("FFFFFFFFFFFFFFFF")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::hex).value()); + } + + //************************************************************************* + TEST(test_hex_numerics_overflow) + { + const Text int8_overflow_max(STR("100")); + const Text int8_overflow_min(STR("-100")); + + const Text uint8_overflow_max(STR("100")); + + const Text int16_overflow_max(STR("10000")); + const Text int16_overflow_min(STR("-10000")); + + const Text uint16_overflow_max(STR("10000")); + + const Text int32_overflow_max(STR("100000000")); + const Text int32_overflow_min(STR("-100000000")); + + const Text uint32_overflow_max(STR("100000000")); + + const Text int64_overflow_max(STR("10000000000000000")); + const Text int64_overflow_min(STR("-10000000000000000")); + + const Text uint64_overflow_max(STR("10000000000000000")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::hex)); + } + + //************************************************************************* + TEST(test_valid_float) + { + Text text; + + //********************************* + text = STR("-123.456789"); + + float f1 = strtof("-123.456789", nullptr); + float f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.456789"); + + f1 = strtof("123.456789", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-1.23456789e2"); + + f1 = strtof("-1.23456789e2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12345.6789e-2"); + + f1 = strtof("-12345.6789e-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345E-2"); + + f1 = strtof("+12345E-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345.6789E000"); + + f1 = strtof("+12345.6789E000", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_invalid_float) + { + Text text; + + //********************************* + text = STR(" -123.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456789 "); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12A.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456A89"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.-456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123E.45"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_valid_double) + { + Text text; + + //********************************* + text = STR("-123.45678901234567"); + + double f1 = strtod("-123.45678901234567", nullptr); + double f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45678901234567"); + + f1 = strtod("123.45678901234567", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-1.2345678901234567e2"); + + f1 = strtod("-1.2345678901234567e2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12345.678901234567e-2"); + + f1 = strtod("-12345.678901234567e-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345E-2"); + + f1 = strtod("+12345E-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345.678901234567E0"); + + f1 = strtod("+12345.678901234567E0", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_invalid_double) + { + Text text; + + //********************************* + text = STR(" -123.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456789 "); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12A.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456A89"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.-456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123E.45"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_valid_long_double) + { + Text text; + + //********************************* + text = STR("-123.45678901234567"); + + long double f1 = strtold("-123.45678901234567", nullptr); + long double f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45678901234567"); + + f1 = strtold("123.45678901234567", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-1.2345678901234567e2"); + + f1 = strtold("-1.2345678901234567e2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12345.678901234567e-2"); + + f1 = strtold("-12345.678901234567e-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345E-2"); + + f1 = strtold("+12345E-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345.678901234567E000"); + + f1 = strtold("+12345.678901234567E000", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_invalid_long_double) + { + Text text; + + //********************************* + text = STR(" -123.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456789 "); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12A.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456A89"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.-456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123E.45"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_constexpr_integral) + { + constexpr const char* text{ "123" }; + constexpr etl::string_view view(text, 3); + + constexpr etl::to_arithmetic_result result = etl::to_arithmetic(view, etl::radix::decimal); + constexpr int i = result.value(); + + CHECK_EQUAL(123, i); + } + } +} + diff --git a/test/test_to_arithmetic_u32.cpp b/test/test_to_arithmetic_u32.cpp new file mode 100644 index 00000000..6f641e82 --- /dev/null +++ b/test/test_to_arithmetic_u32.cpp @@ -0,0 +1,1020 @@ +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 John Wellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#include "unit_test_framework.h" + +#include +#include +#include + +#include "etl/to_arithmetic.h" +#include "etl/u32string.h" +#include "etl/format_spec.h" + +#undef STR +#define STR(x) U##x +using Text = std::u32string; + +namespace +{ + //************************************************************************* + template + std::ostream& operator <<(std::ostream& os, const etl::to_arithmetic_result& result) + { + if (result.has_value()) + { + os << result.value(); + } + else + { + os << result.status().c_str(); + } + + return os; + } + + typedef etl::format_spec Format; + + SUITE(test_to_arithmetic) + { + //************************************************************************* + TEST(test_invalid_radixes) + { + const Text text(STR("128")); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 0)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 1)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 3)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 4)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 5)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 6)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 7)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 9)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 11)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 12)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 13)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 14)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 15)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 17)); + + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 0).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 1).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 3).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 4).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 5).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 6).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 7).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 9).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 11).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 12).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 13).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 14).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 15).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 17).has_value()); + + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 0).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 1).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 3).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 4).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 5).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 6).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 7).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 9).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 11).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 12).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 13).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 14).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 15).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 17).status()); + } + + //************************************************************************* + TEST(test_invalid_binary_numerics) + { + const Text text1(STR(" 101")); + const Text text2(STR("101 ")); + const Text text3(STR("121")); + const Text text4(STR("")); + const Text text5(STR("-101")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text5.c_str(), text5.size(), etl::bin)); + + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text1.c_str(), text1.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text2.c_str(), text2.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text3.c_str(), text3.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text4.c_str(), text4.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Signed_To_Unsigned, etl::to_arithmetic(text5.c_str(), text5.size(), etl::bin).status()); + } + + //************************************************************************* + TEST(test_valid_binary_numerics) + { + const Text value1(STR("0")); + const Text value2(STR("1")); + const Text value3(STR("0101")); + const Text value4(STR("1010")); + const Text value5(STR("01010011")); + const Text value6(STR("10101100")); + const Text value7(STR("-01010100")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::bin).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::bin).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::bin).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::bin).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::bin).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::bin).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::bin).value())); + + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::bin).status())); + } + + //************************************************************************* + TEST(test_maximum_binary_numerics) + { + const Text int8_max(STR("01111111")); + const Text int8_min_neg(STR("-10000000")); + const Text int8_min_2c(STR("10000000")); + + const Text uint8_max(STR("11111111")); + const Text uint8_min(STR("00000000")); + + const Text int16_max(STR("0111111111111111")); + const Text int16_min_neg(STR("-1000000000000000")); + const Text int16_min_2c(STR("1000000000000000")); + + const Text uint16_max(STR("1111111111111111")); + const Text uint16_min(STR("0000000000000000")); + + const Text int32_max(STR("01111111111111111111111111111111")); + const Text int32_min_neg(STR("-10000000000000000000000000000000")); + const Text int32_min_2c(STR("10000000000000000000000000000000")); + + const Text uint32_max(STR("11111111111111111111111111111111")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("0111111111111111111111111111111111111111111111111111111111111111")); + const Text int64_min_neg(STR("-1000000000000000000000000000000000000000000000000000000000000000")); + const Text int64_min_2c(STR("1000000000000000000000000000000000000000000000000000000000000000")); + + const Text uint64_max(STR("1111111111111111111111111111111111111111111111111111111111111111")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::bin).value()); + } + + //************************************************************************* + TEST(test_binary_numerics_overflow) + { + const Text int8_overflow_max(STR("100000000")); + const Text int8_overflow_min(STR("-100000000")); + + const Text uint8_overflow_max(STR("100000000")); + + const Text int16_overflow_max(STR("10000000000000000")); + const Text int16_overflow_min(STR("-10000000000000000")); + + const Text uint16_overflow_max(STR("10000000000000000")); + + const Text int32_overflow_max(STR("100000000000000000000000000000000")); + const Text int32_overflow_min(STR("-100000000000000000000000000000000")); + + const Text uint32_overflow_max(STR("100000000000000000000000000000000")); + + const Text int64_overflow_max(STR("10000000000000000000000000000000000000000000000000000000000000000")); + const Text int64_overflow_min(STR("-10000000000000000000000000000000000000000000000000000000000000000")); + + const Text uint64_overflow_max(STR("10000000000000000000000000000000000000000000000000000000000000000")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::bin)); + + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::bin).status()); + } + + //************************************************************************* + TEST(test_invalid_octal_numerics) + { + const Text text1(STR(" 127")); + const Text text2(STR("127 ")); + const Text text3(STR("187")); + const Text text4(STR("-187")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::oct)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::oct)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::oct)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::oct)); + } + + //************************************************************************* + TEST(test_valid_octal_numerics) + { + const Text value1(STR("0")); + const Text value2(STR("01")); + const Text value3(STR("05")); + const Text value4(STR("012")); + const Text value5(STR("0123")); + const Text value6(STR("0254")); + const Text value7(STR("-0124")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::oct).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::oct).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::oct).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::oct).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::oct).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::oct).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::oct).value())); + } + + //************************************************************************* + TEST(test_maximum_octal_numerics) + { + const Text int8_max(STR("177")); + const Text int8_min_neg(STR("-200")); + const Text int8_min_2c(STR("200")); + + const Text uint8_max(STR("377")); + const Text uint8_min(STR("0")); + + const Text int16_max(STR("77777")); + const Text int16_min_neg(STR("-100000")); + const Text int16_min_2c(STR("100000")); + + const Text uint16_max(STR("177777")); + const Text uint16_min(STR("0")); + + const Text int32_max(STR("17777777777")); + const Text int32_min_neg(STR("-20000000000")); + const Text int32_min_2c(STR("20000000000")); + + const Text uint32_max(STR("37777777777")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("777777777777777777777")); + const Text int64_min_neg(STR("-1000000000000000000000")); + const Text int64_min_2c(STR("1000000000000000000000")); + + const Text uint64_max(STR("1777777777777777777777")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::oct).value()); + } + + //************************************************************************* + TEST(test_octal_numerics_overflow) + { + const Text int8_overflow_max(STR("400")); + const Text int8_overflow_min(STR("-400")); + + const Text uint8_overflow_max(STR("400")); + + const Text int16_overflow_max(STR("200000")); + const Text int16_overflow_min(STR("-200000")); + + const Text uint16_overflow_max(STR("200000")); + + const Text int32_overflow_max(STR("40000000000")); + const Text int32_overflow_min(STR("-40000000000")); + + const Text uint32_overflow_max(STR("40000000000")); + + const Text int64_overflow_max(STR("2000000000000000000000")); + const Text int64_overflow_min(STR("-2000000000000000000000")); + + const Text uint64_overflow_max(STR("2000000000000000000000")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::oct)); + } + + //************************************************************************* + TEST(test_invalid_decimal_numerics) + { + const Text text1(STR(" 128")); + const Text text2(STR("128 ")); + const Text text3(STR("1A8")); + const Text text4(STR("++128")); + const Text text5(STR("-+128")); + const Text text6(STR("+-128")); + const Text text7(STR("--128")); + const Text text8(STR("+")); + const Text text9(STR("-")); + const Text text10(STR("")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text6.c_str(), text6.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text7.c_str(), text7.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text8.c_str(), text8.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text9.c_str(), text9.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text10.c_str(), text10.size(), etl::dec)); + } + + //************************************************************************* + TEST(test_valid_decimal_numerics) + { + const Text text1(STR("0")); + const Text text2(STR("1")); + const Text text3(STR("5")); + const Text text4(STR("+10")); + const Text text5(STR("83")); + const Text text6(STR("-84")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(text1.c_str(), text1.size(), etl::dec).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(text2.c_str(), text2.size(), etl::dec).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(text3.c_str(), text3.size(), etl::dec).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(text4.c_str(), text4.size(), etl::dec).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text6.c_str(), text6.size(), etl::dec).value())); + } + + //************************************************************************* + TEST(test_maximum_decimal_numerics) + { + const Text int8_max(STR("127")); + const Text int8_min(STR("-128")); + + const Text uint8_max(STR("255")); + const Text uint8_min(STR("0")); + + const Text int16_max(STR("32767")); + const Text int16_min(STR("-32768")); + + const Text uint16_max(STR("65535")); + const Text uint16_min(STR("0")); + + const Text int32_max(STR("2147483647")); + const Text int32_min(STR("-2147483648")); + + const Text uint32_max(STR("4294967295")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("9223372036854775807")); + const Text int64_min(STR("-9223372036854775808")); + + const Text uint64_max(STR("18446744073709551615")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min.c_str(), int8_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min.c_str(), int16_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min.c_str(), int32_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min.c_str(), int64_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::dec).value()); + } + + //************************************************************************* + TEST(test_decimal_numerics_overflow) + { + const Text int8_overflow_max(STR("128")); + const Text int8_overflow_min(STR("-129")); + + const Text int8_overflow_max_plus(STR("1000")); + const Text int8_overflow_min_plus(STR("-1000")); + + const Text uint8_overflow_max(STR("256")); + + const Text int16_overflow_max(STR("32768")); + const Text int16_overflow_min(STR("-32769")); + + const Text uint16_overflow_max(STR("65536")); + + const Text int32_overflow_max(STR("2147483648")); + const Text int32_overflow_min(STR("-2147483649")); + + const Text uint32_overflow_max(STR("4294967296")); + + const Text int64_overflow_max(STR("9223372036854775808")); + const Text int64_overflow_min(STR("-9223372036854775809")); + + const Text uint64_overflow_max(STR("18446744073709551616")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int8_overflow_max_plus.c_str(), int8_overflow_max_plus.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int8_overflow_min_plus.c_str(), int8_overflow_min_plus.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::dec)); + } + + //************************************************************************* + TEST(test_invalid_hex_numerics) + { + const Text text1(STR(" 1Af")); + const Text text2(STR("1Af ")); + const Text text3(STR("1Gf")); + const Text text4(STR("-1Af")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::hex)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::hex)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::hex)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::hex)); + } + + //************************************************************************* + TEST(test_valid_hex_numerics) + { + const Text text1(STR("0")); + const Text text2(STR("1")); + const Text text3(STR("5")); + const Text text4(STR("a")); + const Text text5(STR("53")); + const Text text6(STR("Ac")); + const Text text7(STR("-54")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(text1.c_str(), text1.size(), etl::hex).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(text2.c_str(), text2.size(), etl::hex).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(text3.c_str(), text3.size(), etl::hex).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(text4.c_str(), text4.size(), etl::hex).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::hex).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text6.c_str(), text6.size(), etl::hex).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text7.c_str(), text7.size(), etl::hex).value())); + } + + //************************************************************************* + TEST(test_maximum_hex_numerics) + { + const Text int8_max(STR("7F")); + const Text int8_min_neg(STR("-80")); + const Text int8_min_2c(STR("80")); + + const Text uint8_max(STR("FF")); + const Text uint8_min(STR("0")); + + const Text int16_max(STR("7FFF")); + const Text int16_min_neg(STR("-8000")); + const Text int16_min_2c(STR("8000")); + + const Text uint16_max(STR("FFFF")); + const Text uint16_min(STR("0")); + + const Text int32_max(STR("7FFFFFFF")); + const Text int32_min_neg(STR("-80000000")); + const Text int32_min_2c(STR("80000000")); + + const Text uint32_max(STR("FFFFFFFF")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("7FFFFFFFFFFFFFFF")); + const Text int64_min_neg(STR("-8000000000000000")); + const Text int64_min_2c(STR("8000000000000000")); + + const Text uint64_max(STR("FFFFFFFFFFFFFFFF")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::hex).value()); + } + + //************************************************************************* + TEST(test_hex_numerics_overflow) + { + const Text int8_overflow_max(STR("100")); + const Text int8_overflow_min(STR("-100")); + + const Text uint8_overflow_max(STR("100")); + + const Text int16_overflow_max(STR("10000")); + const Text int16_overflow_min(STR("-10000")); + + const Text uint16_overflow_max(STR("10000")); + + const Text int32_overflow_max(STR("100000000")); + const Text int32_overflow_min(STR("-100000000")); + + const Text uint32_overflow_max(STR("100000000")); + + const Text int64_overflow_max(STR("10000000000000000")); + const Text int64_overflow_min(STR("-10000000000000000")); + + const Text uint64_overflow_max(STR("10000000000000000")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::hex)); + } + + //************************************************************************* + TEST(test_valid_float) + { + Text text; + + //********************************* + text = STR("-123.456789"); + + float f1 = strtof("-123.456789", nullptr); + float f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.456789"); + + f1 = strtof("123.456789", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-1.23456789e2"); + + f1 = strtof("-1.23456789e2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12345.6789e-2"); + + f1 = strtof("-12345.6789e-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345E-2"); + + f1 = strtof("+12345E-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345.6789E000"); + + f1 = strtof("+12345.6789E000", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_invalid_float) + { + Text text; + + //********************************* + text = STR(" -123.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456789 "); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12A.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456A89"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.-456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123E.45"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_valid_double) + { + Text text; + + //********************************* + text = STR("-123.45678901234567"); + + double f1 = strtod("-123.45678901234567", nullptr); + double f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45678901234567"); + + f1 = strtod("123.45678901234567", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-1.2345678901234567e2"); + + f1 = strtod("-1.2345678901234567e2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12345.678901234567e-2"); + + f1 = strtod("-12345.678901234567e-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345E-2"); + + f1 = strtod("+12345E-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345.678901234567E0"); + + f1 = strtod("+12345.678901234567E0", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_invalid_double) + { + Text text; + + //********************************* + text = STR(" -123.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456789 "); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12A.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456A89"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.-456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123E.45"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_valid_long_double) + { + Text text; + + //********************************* + text = STR("-123.45678901234567"); + + long double f1 = strtold("-123.45678901234567", nullptr); + long double f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45678901234567"); + + f1 = strtold("123.45678901234567", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-1.2345678901234567e2"); + + f1 = strtold("-1.2345678901234567e2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12345.678901234567e-2"); + + f1 = strtold("-12345.678901234567e-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345E-2"); + + f1 = strtold("+12345E-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345.678901234567E000"); + + f1 = strtold("+12345.678901234567E000", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_invalid_long_double) + { + Text text; + + //********************************* + text = STR(" -123.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456789 "); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12A.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456A89"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.-456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123E.45"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_constexpr_integral) + { + constexpr const char* text{ "123" }; + constexpr etl::string_view view(text, 3); + + constexpr etl::to_arithmetic_result result = etl::to_arithmetic(view, etl::radix::decimal); + constexpr int i = result.value(); + + CHECK_EQUAL(123, i); + } + } +} + diff --git a/test/test_to_arithmetic_wchar_t.cpp b/test/test_to_arithmetic_wchar_t.cpp new file mode 100644 index 00000000..11c97b4b --- /dev/null +++ b/test/test_to_arithmetic_wchar_t.cpp @@ -0,0 +1,1020 @@ +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2019 John Wellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#include "unit_test_framework.h" + +#include +#include +#include + +#include "etl/to_arithmetic.h" +#include "etl/wstring.h" +#include "etl/format_spec.h" + +#undef STR +#define STR(x) L##x +using Text = std::wstring; + +namespace +{ + //************************************************************************* + template + std::ostream& operator <<(std::ostream& os, const etl::to_arithmetic_result& result) + { + if (result.has_value()) + { + os << result.value(); + } + else + { + os << result.status().c_str(); + } + + return os; + } + + typedef etl::format_spec Format; + + SUITE(test_to_arithmetic) + { + //************************************************************************* + TEST(test_invalid_radixes) + { + const Text text(STR("128")); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 0)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 1)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 3)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 4)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 5)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 6)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 7)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 9)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 11)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 12)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 13)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 14)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 15)); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 17)); + + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 0).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 1).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 3).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 4).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 5).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 6).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 7).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 9).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 11).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 12).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 13).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 14).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 15).has_value()); + CHECK(!etl::to_arithmetic(text.c_str(), text.size(), 17).has_value()); + + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 0).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 1).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 3).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 4).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 5).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 6).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 7).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 9).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 11).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 12).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 13).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 14).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 15).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Radix, etl::to_arithmetic(text.c_str(), text.size(), 17).status()); + } + + //************************************************************************* + TEST(test_invalid_binary_numerics) + { + const Text text1(STR(" 101")); + const Text text2(STR("101 ")); + const Text text3(STR("121")); + const Text text4(STR("")); + const Text text5(STR("-101")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::bin)); + CHECK(!etl::to_arithmetic(text5.c_str(), text5.size(), etl::bin)); + + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text1.c_str(), text1.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text2.c_str(), text2.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text3.c_str(), text3.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text4.c_str(), text4.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Signed_To_Unsigned, etl::to_arithmetic(text5.c_str(), text5.size(), etl::bin).status()); + } + + //************************************************************************* + TEST(test_valid_binary_numerics) + { + const Text value1(STR("0")); + const Text value2(STR("1")); + const Text value3(STR("0101")); + const Text value4(STR("1010")); + const Text value5(STR("01010011")); + const Text value6(STR("10101100")); + const Text value7(STR("-01010100")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::bin).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::bin).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::bin).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::bin).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::bin).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::bin).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::bin).value())); + + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::bin).status())); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::bin).status())); + } + + //************************************************************************* + TEST(test_maximum_binary_numerics) + { + const Text int8_max(STR("01111111")); + const Text int8_min_neg(STR("-10000000")); + const Text int8_min_2c(STR("10000000")); + + const Text uint8_max(STR("11111111")); + const Text uint8_min(STR("00000000")); + + const Text int16_max(STR("0111111111111111")); + const Text int16_min_neg(STR("-1000000000000000")); + const Text int16_min_2c(STR("1000000000000000")); + + const Text uint16_max(STR("1111111111111111")); + const Text uint16_min(STR("0000000000000000")); + + const Text int32_max(STR("01111111111111111111111111111111")); + const Text int32_min_neg(STR("-10000000000000000000000000000000")); + const Text int32_min_2c(STR("10000000000000000000000000000000")); + + const Text uint32_max(STR("11111111111111111111111111111111")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("0111111111111111111111111111111111111111111111111111111111111111")); + const Text int64_min_neg(STR("-1000000000000000000000000000000000000000000000000000000000000000")); + const Text int64_min_2c(STR("1000000000000000000000000000000000000000000000000000000000000000")); + + const Text uint64_max(STR("1111111111111111111111111111111111111111111111111111111111111111")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::bin).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::bin).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::bin).value()); + } + + //************************************************************************* + TEST(test_binary_numerics_overflow) + { + const Text int8_overflow_max(STR("100000000")); + const Text int8_overflow_min(STR("-100000000")); + + const Text uint8_overflow_max(STR("100000000")); + + const Text int16_overflow_max(STR("10000000000000000")); + const Text int16_overflow_min(STR("-10000000000000000")); + + const Text uint16_overflow_max(STR("10000000000000000")); + + const Text int32_overflow_max(STR("100000000000000000000000000000000")); + const Text int32_overflow_min(STR("-100000000000000000000000000000000")); + + const Text uint32_overflow_max(STR("100000000000000000000000000000000")); + + const Text int64_overflow_max(STR("10000000000000000000000000000000000000000000000000000000000000000")); + const Text int64_overflow_min(STR("-10000000000000000000000000000000000000000000000000000000000000000")); + + const Text uint64_overflow_max(STR("10000000000000000000000000000000000000000000000000000000000000000")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::bin)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::bin)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::bin)); + + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::bin).status()); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::bin).status()); + + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::bin).status()); + } + + //************************************************************************* + TEST(test_invalid_octal_numerics) + { + const Text text1(STR(" 127")); + const Text text2(STR("127 ")); + const Text text3(STR("187")); + const Text text4(STR("-187")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::oct)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::oct)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::oct)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::oct)); + } + + //************************************************************************* + TEST(test_valid_octal_numerics) + { + const Text value1(STR("0")); + const Text value2(STR("01")); + const Text value3(STR("05")); + const Text value4(STR("012")); + const Text value5(STR("0123")); + const Text value6(STR("0254")); + const Text value7(STR("-0124")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(value1.c_str(), value1.size(), etl::oct).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(value2.c_str(), value2.size(), etl::oct).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(value3.c_str(), value3.size(), etl::oct).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(value4.c_str(), value4.size(), etl::oct).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(value5.c_str(), value5.size(), etl::oct).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value6.c_str(), value6.size(), etl::oct).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(value7.c_str(), value7.size(), etl::oct).value())); + } + + //************************************************************************* + TEST(test_maximum_octal_numerics) + { + const Text int8_max(STR("177")); + const Text int8_min_neg(STR("-200")); + const Text int8_min_2c(STR("200")); + + const Text uint8_max(STR("377")); + const Text uint8_min(STR("0")); + + const Text int16_max(STR("77777")); + const Text int16_min_neg(STR("-100000")); + const Text int16_min_2c(STR("100000")); + + const Text uint16_max(STR("177777")); + const Text uint16_min(STR("0")); + + const Text int32_max(STR("17777777777")); + const Text int32_min_neg(STR("-20000000000")); + const Text int32_min_2c(STR("20000000000")); + + const Text uint32_max(STR("37777777777")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("777777777777777777777")); + const Text int64_min_neg(STR("-1000000000000000000000")); + const Text int64_min_2c(STR("1000000000000000000000")); + + const Text uint64_max(STR("1777777777777777777777")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::oct).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::oct).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::oct).value()); + } + + //************************************************************************* + TEST(test_octal_numerics_overflow) + { + const Text int8_overflow_max(STR("400")); + const Text int8_overflow_min(STR("-400")); + + const Text uint8_overflow_max(STR("400")); + + const Text int16_overflow_max(STR("200000")); + const Text int16_overflow_min(STR("-200000")); + + const Text uint16_overflow_max(STR("200000")); + + const Text int32_overflow_max(STR("40000000000")); + const Text int32_overflow_min(STR("-40000000000")); + + const Text uint32_overflow_max(STR("40000000000")); + + const Text int64_overflow_max(STR("2000000000000000000000")); + const Text int64_overflow_min(STR("-2000000000000000000000")); + + const Text uint64_overflow_max(STR("2000000000000000000000")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::oct)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::oct)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::oct)); + } + + //************************************************************************* + TEST(test_invalid_decimal_numerics) + { + const Text text1(STR(" 128")); + const Text text2(STR("128 ")); + const Text text3(STR("1A8")); + const Text text4(STR("++128")); + const Text text5(STR("-+128")); + const Text text6(STR("+-128")); + const Text text7(STR("--128")); + const Text text8(STR("+")); + const Text text9(STR("-")); + const Text text10(STR("")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text6.c_str(), text6.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text7.c_str(), text7.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text8.c_str(), text8.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text9.c_str(), text9.size(), etl::dec)); + CHECK(!etl::to_arithmetic(text10.c_str(), text10.size(), etl::dec)); + } + + //************************************************************************* + TEST(test_valid_decimal_numerics) + { + const Text text1(STR("0")); + const Text text2(STR("1")); + const Text text3(STR("5")); + const Text text4(STR("+10")); + const Text text5(STR("83")); + const Text text6(STR("-84")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(text1.c_str(), text1.size(), etl::dec).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(text2.c_str(), text2.size(), etl::dec).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(text3.c_str(), text3.size(), etl::dec).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(text4.c_str(), text4.size(), etl::dec).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::dec).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text6.c_str(), text6.size(), etl::dec).value())); + } + + //************************************************************************* + TEST(test_maximum_decimal_numerics) + { + const Text int8_max(STR("127")); + const Text int8_min(STR("-128")); + + const Text uint8_max(STR("255")); + const Text uint8_min(STR("0")); + + const Text int16_max(STR("32767")); + const Text int16_min(STR("-32768")); + + const Text uint16_max(STR("65535")); + const Text uint16_min(STR("0")); + + const Text int32_max(STR("2147483647")); + const Text int32_min(STR("-2147483648")); + + const Text uint32_max(STR("4294967295")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("9223372036854775807")); + const Text int64_min(STR("-9223372036854775808")); + + const Text uint64_max(STR("18446744073709551615")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min.c_str(), int8_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min.c_str(), int16_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min.c_str(), int32_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min.c_str(), int64_min.size(), etl::dec).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::dec).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::dec).value()); + } + + //************************************************************************* + TEST(test_decimal_numerics_overflow) + { + const Text int8_overflow_max(STR("128")); + const Text int8_overflow_min(STR("-129")); + + const Text int8_overflow_max_plus(STR("1000")); + const Text int8_overflow_min_plus(STR("-1000")); + + const Text uint8_overflow_max(STR("256")); + + const Text int16_overflow_max(STR("32768")); + const Text int16_overflow_min(STR("-32769")); + + const Text uint16_overflow_max(STR("65536")); + + const Text int32_overflow_max(STR("2147483648")); + const Text int32_overflow_min(STR("-2147483649")); + + const Text uint32_overflow_max(STR("4294967296")); + + const Text int64_overflow_max(STR("9223372036854775808")); + const Text int64_overflow_min(STR("-9223372036854775809")); + + const Text uint64_overflow_max(STR("18446744073709551616")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int8_overflow_max_plus.c_str(), int8_overflow_max_plus.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int8_overflow_min_plus.c_str(), int8_overflow_min_plus.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::dec)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::dec)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::dec)); + } + + //************************************************************************* + TEST(test_invalid_hex_numerics) + { + const Text text1(STR(" 1Af")); + const Text text2(STR("1Af ")); + const Text text3(STR("1Gf")); + const Text text4(STR("-1Af")); + + CHECK(!etl::to_arithmetic(text1.c_str(), text1.size(), etl::hex)); + CHECK(!etl::to_arithmetic(text2.c_str(), text2.size(), etl::hex)); + CHECK(!etl::to_arithmetic(text3.c_str(), text3.size(), etl::hex)); + CHECK(!etl::to_arithmetic(text4.c_str(), text4.size(), etl::hex)); + } + + //************************************************************************* + TEST(test_valid_hex_numerics) + { + const Text text1(STR("0")); + const Text text2(STR("1")); + const Text text3(STR("5")); + const Text text4(STR("a")); + const Text text5(STR("53")); + const Text text6(STR("Ac")); + const Text text7(STR("-54")); + + CHECK_EQUAL(int(0), int(etl::to_arithmetic(text1.c_str(), text1.size(), etl::hex).value())); + CHECK_EQUAL(int(1), int(etl::to_arithmetic(text2.c_str(), text2.size(), etl::hex).value())); + CHECK_EQUAL(int(5), int(etl::to_arithmetic(text3.c_str(), text3.size(), etl::hex).value())); + CHECK_EQUAL(int(10), int(etl::to_arithmetic(text4.c_str(), text4.size(), etl::hex).value())); + CHECK_EQUAL(int(83), int(etl::to_arithmetic(text5.c_str(), text5.size(), etl::hex).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text6.c_str(), text6.size(), etl::hex).value())); + CHECK_EQUAL(int(-84), int(etl::to_arithmetic(text7.c_str(), text7.size(), etl::hex).value())); + } + + //************************************************************************* + TEST(test_maximum_hex_numerics) + { + const Text int8_max(STR("7F")); + const Text int8_min_neg(STR("-80")); + const Text int8_min_2c(STR("80")); + + const Text uint8_max(STR("FF")); + const Text uint8_min(STR("0")); + + const Text int16_max(STR("7FFF")); + const Text int16_min_neg(STR("-8000")); + const Text int16_min_2c(STR("8000")); + + const Text uint16_max(STR("FFFF")); + const Text uint16_min(STR("0")); + + const Text int32_max(STR("7FFFFFFF")); + const Text int32_min_neg(STR("-80000000")); + const Text int32_min_2c(STR("80000000")); + + const Text uint32_max(STR("FFFFFFFF")); + const Text uint32_min(STR("0")); + + const Text int64_max(STR("7FFFFFFFFFFFFFFF")); + const Text int64_min_neg(STR("-8000000000000000")); + const Text int64_min_2c(STR("8000000000000000")); + + const Text uint64_max(STR("FFFFFFFFFFFFFFFF")); + const Text uint64_min(STR("0")); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int8_max.c_str(), int8_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_neg.c_str(), int8_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int8_min_2c.c_str(), int8_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint8_max.c_str(), uint8_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint8_min.c_str(), uint8_min.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int16_max.c_str(), int16_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_neg.c_str(), int16_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int16_min_2c.c_str(), int16_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint16_max.c_str(), uint16_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint16_min.c_str(), uint16_min.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int32_max.c_str(), int32_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_neg.c_str(), int32_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int32_min_2c.c_str(), int32_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint32_max.c_str(), uint32_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint32_min.c_str(), uint32_min.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(int64_max.c_str(), int64_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_neg.c_str(), int64_min_neg.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(int64_min_2c.c_str(), int64_min_2c.size(), etl::hex).value()); + + CHECK_EQUAL(std::numeric_limits::max(), etl::to_arithmetic(uint64_max.c_str(), uint64_max.size(), etl::hex).value()); + CHECK_EQUAL(std::numeric_limits::min(), etl::to_arithmetic(uint64_min.c_str(), uint64_min.size(), etl::hex).value()); + } + + //************************************************************************* + TEST(test_hex_numerics_overflow) + { + const Text int8_overflow_max(STR("100")); + const Text int8_overflow_min(STR("-100")); + + const Text uint8_overflow_max(STR("100")); + + const Text int16_overflow_max(STR("10000")); + const Text int16_overflow_min(STR("-10000")); + + const Text uint16_overflow_max(STR("10000")); + + const Text int32_overflow_max(STR("100000000")); + const Text int32_overflow_min(STR("-100000000")); + + const Text uint32_overflow_max(STR("100000000")); + + const Text int64_overflow_max(STR("10000000000000000")); + const Text int64_overflow_min(STR("-10000000000000000")); + + const Text uint64_overflow_max(STR("10000000000000000")); + + CHECK(!etl::to_arithmetic(int8_overflow_max.c_str(), int8_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int8_overflow_min.c_str(), int8_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint8_overflow_max.c_str(), uint8_overflow_max.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(int16_overflow_max.c_str(), int16_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int16_overflow_min.c_str(), int16_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint16_overflow_max.c_str(), uint16_overflow_max.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(int32_overflow_max.c_str(), int32_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int32_overflow_min.c_str(), int32_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint32_overflow_max.c_str(), uint32_overflow_max.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(int64_overflow_max.c_str(), int64_overflow_max.size(), etl::hex)); + CHECK(!etl::to_arithmetic(int64_overflow_min.c_str(), int64_overflow_min.size(), etl::hex)); + + CHECK(!etl::to_arithmetic(uint64_overflow_max.c_str(), uint64_overflow_max.size(), etl::hex)); + } + + //************************************************************************* + TEST(test_valid_float) + { + Text text; + + //********************************* + text = STR("-123.456789"); + + float f1 = strtof("-123.456789", nullptr); + float f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.456789"); + + f1 = strtof("123.456789", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-1.23456789e2"); + + f1 = strtof("-1.23456789e2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12345.6789e-2"); + + f1 = strtof("-12345.6789e-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345E-2"); + + f1 = strtof("+12345E-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345.6789E000"); + + f1 = strtof("+12345.6789E000", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_invalid_float) + { + Text text; + + //********************************* + text = STR(" -123.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456789 "); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12A.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456A89"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.-456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123E.45"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_valid_double) + { + Text text; + + //********************************* + text = STR("-123.45678901234567"); + + double f1 = strtod("-123.45678901234567", nullptr); + double f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45678901234567"); + + f1 = strtod("123.45678901234567", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-1.2345678901234567e2"); + + f1 = strtod("-1.2345678901234567e2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12345.678901234567e-2"); + + f1 = strtod("-12345.678901234567e-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345E-2"); + + f1 = strtod("+12345E-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345.678901234567E0"); + + f1 = strtod("+12345.678901234567E0", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_invalid_double) + { + Text text; + + //********************************* + text = STR(" -123.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456789 "); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12A.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456A89"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.-456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123E.45"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_valid_long_double) + { + Text text; + + //********************************* + text = STR("-123.45678901234567"); + + long double f1 = strtold("-123.45678901234567", nullptr); + long double f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45678901234567"); + + f1 = strtold("123.45678901234567", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-1.2345678901234567e2"); + + f1 = strtold("-1.2345678901234567e2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12345.678901234567e-2"); + + f1 = strtold("-12345.678901234567e-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345E-2"); + + f1 = strtold("+12345E-2", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("+12345.678901234567E000"); + + f1 = strtold("+12345.678901234567E000", nullptr); + f2 = etl::to_arithmetic(text.c_str(), text.size()).value(); + + CHECK_CLOSE(f1, f2, 0.00001); + CHECK_EQUAL(etl::to_arithmetic_status::Valid, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_invalid_long_double) + { + Text text; + + //********************************* + text = STR(" -123.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456789 "); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-12A.456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.456A89"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.-456789"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123E.45"); + CHECK_EQUAL(etl::to_arithmetic_status::Invalid_Format, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + + //********************************* + text = STR("-123.45E10000"); + CHECK_EQUAL(etl::to_arithmetic_status::Overflow, etl::to_arithmetic(text.c_str(), text.size()).status()); + } + + //************************************************************************* + TEST(test_constexpr_integral) + { + constexpr const char* text{ "123" }; + constexpr etl::string_view view(text, 3); + + constexpr etl::to_arithmetic_result result = etl::to_arithmetic(view, etl::radix::decimal); + constexpr int i = result.value(); + + CHECK_EQUAL(123, i); + } + } +} + diff --git a/test/vs2019/etl.vcxproj b/test/vs2019/etl.vcxproj index b011749c..63d366d5 100644 --- a/test/vs2019/etl.vcxproj +++ b/test/vs2019/etl.vcxproj @@ -10195,6 +10195,34 @@ true true + + true + true + true + true + true + true + true + true + true + true + true + true + true + true + true + true + true + true + true + true + true + true + true + true + true + true + true true @@ -12108,7 +12136,6 @@ - @@ -12130,6 +12157,10 @@ + + + + diff --git a/test/vs2019/etl.vcxproj.filters b/test/vs2019/etl.vcxproj.filters index 29ca6e71..bb5c004e 100644 --- a/test/vs2019/etl.vcxproj.filters +++ b/test/vs2019/etl.vcxproj.filters @@ -3374,9 +3374,21 @@ Tests\Binary - + Tests\Strings + + Tests\Strings + + + Tests\Strings + + + Tests\Strings + + + Tests\Sanity Checks\Source +