From ce48e56f2c642a6a459afa0feb7e69b3507e69d7 Mon Sep 17 00:00:00 2001 From: E Sequeira <5458743+geseq@users.noreply.github.com> Date: Sun, 24 Dec 2023 16:26:41 -0500 Subject: [PATCH] rename to decimal (#23) --- CMakeLists.txt | 19 +- README.md | 30 +- include/{udecimal.hpp => decimal.hpp} | 10 +- test/{udecimal_test.cpp => decimal_test.cpp} | 822 +++++++++---------- 4 files changed, 443 insertions(+), 438 deletions(-) rename include/{udecimal.hpp => decimal.hpp} (99%) rename test/{udecimal_test.cpp => decimal_test.cpp} (55%) diff --git a/CMakeLists.txt b/CMakeLists.txt index aac6f37..a969762 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,13 +1,18 @@ cmake_minimum_required(VERSION 3.20 FATAL_ERROR) -project(udecimal LANGUAGES CXX) +set(CPP_DECIMAL cpp-decimal) + +project(${CPP_DECIMAL} LANGUAGES CXX) enable_testing() -set(CMAKE_CXX_STANDARD 17) +if(NOT "${CMAKE_CXX_STANDARD}") + set(CMAKE_CXX_STANDARD 17) +endif() +message(STATUS "CMAKE_CXX_STANDARD: ${CMAKE_CXX_STANDARD}") -add_library(udecimal INTERFACE) -target_sources(udecimal INTERFACE include/udecimal.hpp) -target_include_directories(udecimal INTERFACE include/) +add_library(${CPP_DECIMAL} INTERFACE) +target_sources(${CPP_DECIMAL} INTERFACE include/decimal.hpp) +target_include_directories(${CPP_DECIMAL} INTERFACE include/) option(ENABLE_TESTING "Enable test target generation" OFF) option(BENCHMARK_ENABLE_TESTING "run benchmarks" OFF) @@ -27,7 +32,7 @@ if (ENABLE_TESTING) message("Adding test: " ${test_name}) add_executable(${test_name} ${PROJECT_SOURCE_DIR}/test/${test_name}) target_link_libraries(${test_name} ${CMAKE_THREAD_LIBS_INIT}) - target_link_libraries(${test_name} PRIVATE udecimal gtest gtest_main) + target_link_libraries(${test_name} PRIVATE ${CPP_DECIMAL} gtest gtest_main) add_test(${test_name} ${test_name}) set_property(TEST ${test_name} PROPERTY LABELS "test") ENDFOREACH () @@ -47,7 +52,7 @@ if (ENABLE_TESTING) get_filename_component(test_name ${test} NAME) message("Adding bench: " ${test_name}) add_executable(${test_name} ${PROJECT_SOURCE_DIR}/bench/${test_name}) - target_link_libraries(${test_name} PRIVATE ${CMAKE_THREAD_LIBS_INIT} benchmark::benchmark udecimal) + target_link_libraries(${test_name} PRIVATE ${CMAKE_THREAD_LIBS_INIT} benchmark::benchmark ${CPP_DECIMAL}) add_test(${test_name} ${test_name}) set_property(TEST ${test_name} PROPERTY LABELS "bench") list(APPEND ignore_tests ${test_name}) diff --git a/README.md b/README.md index d3bb6fc..c6ed037 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# cpp-udecimal +# cpp-decimal A fixed place signed/unsigned numeric library. Unsigned by default. @@ -6,29 +6,29 @@ A fixed place signed/unsigned numeric library. Unsigned by default. ``` // 8 decimal places, unsigned -auto f = udecimal::U8("123.456"); // 123.456 -auto f = udecimal::U8(123456, 3); // 123.456 -auto f = udecimal::U8::FromExp(123456, -3); // 123.456 -auto f = udecimal::U8(123.456); // 123.456 +auto f = decimal::U8("123.456"); // 123.456 +auto f = decimal::U8(123456, 3); // 123.456 +auto f = decimal::U8::FromExp(123456, -3); // 123.456 +auto f = decimal::U8(123.456); // 123.456 // 9 decimal places, unsigned -auto f = udecimal::U9("123.456"); // 123.456 -auto f = udecimal::U9(123456, 3); // 123.456 -auto f = udecimal::U9::FromExp(123456, -3); // 123.456 -auto f = udecimal::U9(123.456); // 123.456 +auto f = decimal::U9("123.456"); // 123.456 +auto f = decimal::U9(123456, 3); // 123.456 +auto f = decimal::U9::FromExp(123456, -3); // 123.456 +auto f = decimal::U9(123.456); // 123.456 // 9 decimal places, signed -auto f = udecimal::I9("123.456"); // 123.456 -auto f = udecimal::I9(123456, 3); // 123.456 -auto f = udecimal::I9::FromExp(123456, -3); // 123.456 -auto f = udecimal::I9(123.456); // 123.456 +auto f = decimal::I9("123.456"); // 123.456 +auto f = decimal::I9(123456, 3); // 123.456 +auto f = decimal::I9::FromExp(123456, -3); // 123.456 +auto f = decimal::I9(123.456); // 123.456 // Convert from one precision level to another auto g = f.convert_precision<2>(); // 123.45 // Alternatively, 8 decimal places, unsigned -auto f = udecimal::Decimal<8, udecimal::Unsigned>("123.456"); // 123.456 +auto f = decimal::Decimal<8, decimal::Unsigned>("123.456"); // 123.456 // Alternatively, 8 decimal places, signed -auto f = udecimal::Decimal<8, udecimal::Signed>("123.456"); // 123.456 +auto f = decimal::Decimal<8, decimal::Signed>("123.456"); // 123.456 ``` diff --git a/include/udecimal.hpp b/include/decimal.hpp similarity index 99% rename from include/udecimal.hpp rename to include/decimal.hpp index e8ace28..92d21f7 100644 --- a/include/udecimal.hpp +++ b/include/decimal.hpp @@ -1,5 +1,5 @@ -#ifndef UDECIMAL_H -#define UDECIMAL_H +#ifndef CPP_DECIMAL_H +#define CPP_DECIMAL_H #include @@ -16,7 +16,7 @@ #include #include -namespace udecimal { +namespace decimal { #if defined(__GNUC__) || defined(__clang__) #define likely(x) __builtin_expect(!!(x), 1) @@ -687,6 +687,6 @@ using I15 = Decimal<15, Signed>; using I16 = Decimal<16, Signed>; using I17 = Decimal<17, Signed>; -} // namespace udecimal +} // namespace decimal -#endif // UDECIMAL_H +#endif // CPP_DECIMAL_H diff --git a/test/udecimal_test.cpp b/test/decimal_test.cpp similarity index 55% rename from test/udecimal_test.cpp rename to test/decimal_test.cpp index 2ddbfa1..5579d62 100644 --- a/test/udecimal_test.cpp +++ b/test/decimal_test.cpp @@ -1,5 +1,3 @@ -#include "udecimal.hpp" - #include #include @@ -7,7 +5,9 @@ #include #include -using udecimal::Decimal; +#include "decimal.hpp" + +using decimal::Decimal; class DecimalTest : public ::testing::Test { protected: @@ -17,8 +17,8 @@ class DecimalTest : public ::testing::Test { }; TEST_F(DecimalTest, BasicU8) { - udecimal::U8 f0 = udecimal::U8("123.456"); - udecimal::U8 f1 = udecimal::U8("123.456"); + decimal::U8 f0 = decimal::U8("123.456"); + decimal::U8 f1 = decimal::U8("123.456"); ASSERT_EQ(f0, f1); ASSERT_EQ(f1, f0); @@ -27,20 +27,20 @@ TEST_F(DecimalTest, BasicU8) { ASSERT_EQ(f0.to_string(), "123.456"); ASSERT_EQ(f1.to_string(), "123.456"); - f0 = udecimal::U8(1, 0); - f1 = udecimal::U8(.5) + (udecimal::U8(.5)); - udecimal::U8 f2 = udecimal::U8(.3) + udecimal::U8(.3) + udecimal::U8(.4); + f0 = decimal::U8(1, 0); + f1 = decimal::U8(.5) + (decimal::U8(.5)); + decimal::U8 f2 = decimal::U8(.3) + decimal::U8(.3) + decimal::U8(.4); ASSERT_EQ(f0, f1); ASSERT_EQ(f0, f2); - f0 = udecimal::U8(.999); + f0 = decimal::U8(.999); ASSERT_EQ(f0.to_string(), "0.999"); } TEST_F(DecimalTest, BasicI8) { - udecimal::I8 f0 = udecimal::I8("-123.456"); - udecimal::I8 f1 = udecimal::I8("-123.456"); + decimal::I8 f0 = decimal::I8("-123.456"); + decimal::I8 f1 = decimal::I8("-123.456"); ASSERT_EQ(f0, f1); ASSERT_EQ(f1, f0); @@ -49,8 +49,8 @@ TEST_F(DecimalTest, BasicI8) { ASSERT_EQ(f0.to_string(), "-123.456"); ASSERT_EQ(f1.to_string(), "-123.456"); - f0 = udecimal::I8("123.456"); - f1 = udecimal::I8("123.456"); + f0 = decimal::I8("123.456"); + f1 = decimal::I8("123.456"); ASSERT_EQ(f0, f1); ASSERT_EQ(f1, f0); @@ -59,43 +59,43 @@ TEST_F(DecimalTest, BasicI8) { ASSERT_EQ(f0.to_string(), "123.456"); ASSERT_EQ(f1.to_string(), "123.456"); - f0 = udecimal::I8(-1, 0); - f1 = udecimal::I8(-.5) + udecimal::I8(-.5); - udecimal::I8 f2 = udecimal::I8(-.3) + udecimal::I8(-.3) + udecimal::I8(-.4); + f0 = decimal::I8(-1, 0); + f1 = decimal::I8(-.5) + decimal::I8(-.5); + decimal::I8 f2 = decimal::I8(-.3) + decimal::I8(-.3) + decimal::I8(-.4); ASSERT_EQ(f0, f1); ASSERT_EQ(f0, f2); - f0 = udecimal::I8(-.999); + f0 = decimal::I8(-.999); ASSERT_EQ(f0.to_string(), "-0.999"); - f0 = udecimal::I8(1, 0); - f1 = udecimal::I8(.5) + (udecimal::I8(.5)); - f2 = udecimal::I8(.3) + udecimal::I8(.3) + udecimal::I8(.4); + f0 = decimal::I8(1, 0); + f1 = decimal::I8(.5) + (decimal::I8(.5)); + f2 = decimal::I8(.3) + decimal::I8(.3) + decimal::I8(.4); ASSERT_EQ(f0, f1); ASSERT_EQ(f0, f2); - f0 = udecimal::I8(.999); + f0 = decimal::I8(.999); ASSERT_EQ(f0.to_string(), "0.999"); } TEST_F(DecimalTest, EqualU8) { - udecimal::U8 f0{}; - udecimal::U8 f1("123.456"); + decimal::U8 f0{}; + decimal::U8 f1("123.456"); ASSERT_NE(f0, f1); ASSERT_NE(f1, f0); - f1 = udecimal::U8(0, 0); + f1 = decimal::U8(0, 0); ASSERT_EQ(f0, f1); ASSERT_EQ(f0.to_int(), 0); } TEST_F(DecimalTest, EqualI8) { - udecimal::I8 f0{}; - udecimal::I8 f1("123.456"); - udecimal::I8 f2("-123.456"); + decimal::I8 f0{}; + decimal::I8 f1("123.456"); + decimal::I8 f2("-123.456"); ASSERT_NE(f0, f1); ASSERT_NE(f0, f2); @@ -104,101 +104,101 @@ TEST_F(DecimalTest, EqualI8) { ASSERT_NE(f2, f0); ASSERT_NE(f2, f1); - f1 = udecimal::I8(0, 0); + f1 = decimal::I8(0, 0); ASSERT_EQ(f0, f1); ASSERT_EQ(f0.to_int(), 0); - f1 = udecimal::I8(-123456, 3); + f1 = decimal::I8(-123456, 3); ASSERT_EQ(f2, f1); ASSERT_EQ(f2.to_int(), -123); } TEST_F(DecimalTest, FromExpU8) { - auto f = udecimal::U8::FromExp(123, 1); + auto f = decimal::U8::FromExp(123, 1); ASSERT_EQ(f.to_string(), "1230"); - f = udecimal::U8::FromExp(123, 0); + f = decimal::U8::FromExp(123, 0); ASSERT_EQ(f.to_string(), "123"); - f = udecimal::U8::FromExp(123, -1); + f = decimal::U8::FromExp(123, -1); ASSERT_EQ(f.to_string(), "12.3"); - f = udecimal::U8::FromExp(123456789001, -9); + f = decimal::U8::FromExp(123456789001, -9); ASSERT_EQ(f.to_string(), "123.456789"); - f = udecimal::U8::FromExp(123456789012, -9); + f = decimal::U8::FromExp(123456789012, -9); ASSERT_EQ(f.to_string(7), "123.4567890"); - f = udecimal::U8::FromExp(123456789012, -9); + f = decimal::U8::FromExp(123456789012, -9); ASSERT_EQ(f.to_string(8), "123.45678901"); } TEST_F(DecimalTest, FromExpI8) { - auto f = udecimal::I8::FromExp(123, 1); + auto f = decimal::I8::FromExp(123, 1); ASSERT_EQ(f.to_string(), "1230"); - f = udecimal::I8::FromExp(123, 0); + f = decimal::I8::FromExp(123, 0); ASSERT_EQ(f.to_string(), "123"); - f = udecimal::I8::FromExp(123, -1); + f = decimal::I8::FromExp(123, -1); ASSERT_EQ(f.to_string(), "12.3"); - f = udecimal::I8::FromExp(123456789001, -9); + f = decimal::I8::FromExp(123456789001, -9); ASSERT_EQ(f.to_string(), "123.456789"); - f = udecimal::I8::FromExp(123456789012, -9); + f = decimal::I8::FromExp(123456789012, -9); ASSERT_EQ(f.to_string(7), "123.4567890"); - f = udecimal::I8::FromExp(123456789012, -9); + f = decimal::I8::FromExp(123456789012, -9); ASSERT_EQ(f.to_string(8), "123.45678901"); - f = udecimal::I8::FromExp(-123, 1); + f = decimal::I8::FromExp(-123, 1); ASSERT_EQ(f.to_string(), "-1230"); - f = udecimal::I8::FromExp(-123, 0); + f = decimal::I8::FromExp(-123, 0); ASSERT_EQ(f.to_string(), "-123"); - f = udecimal::I8::FromExp(-123, -1); + f = decimal::I8::FromExp(-123, -1); ASSERT_EQ(f.to_string(), "-12.3"); - f = udecimal::I8::FromExp(-123456789001, -9); + f = decimal::I8::FromExp(-123456789001, -9); ASSERT_EQ(f.to_string(), "-123.456789"); - f = udecimal::I8::FromExp(-123456789012, -9); + f = decimal::I8::FromExp(-123456789012, -9); ASSERT_EQ(f.to_string(7), "-123.4567890"); - f = udecimal::I8::FromExp(-123456789012, -9); + f = decimal::I8::FromExp(-123456789012, -9); ASSERT_EQ(f.to_string(8), "-123.45678901"); } TEST_F(DecimalTest, Parse) { - ASSERT_NO_THROW(udecimal::U8("123")); - ASSERT_NO_THROW(udecimal::I8("123")); + ASSERT_NO_THROW(decimal::U8("123")); + ASSERT_NO_THROW(decimal::I8("123")); - ASSERT_THROW(udecimal::U8(",123456"), std::invalid_argument); - ASSERT_THROW(udecimal::I8(",123456"), std::invalid_argument); - ASSERT_THROW(udecimal::U8("abc"), std::invalid_argument); - ASSERT_THROW(udecimal::I8("abc"), std::invalid_argument); + ASSERT_THROW(decimal::U8(",123456"), std::invalid_argument); + ASSERT_THROW(decimal::I8(",123456"), std::invalid_argument); + ASSERT_THROW(decimal::U8("abc"), std::invalid_argument); + ASSERT_THROW(decimal::I8("abc"), std::invalid_argument); } TEST_F(DecimalTest, NewIU8) { - udecimal::U8 f = udecimal::U8(123, 1); + decimal::U8 f = decimal::U8(123, 1); ASSERT_EQ(f.to_string(), "12.3"); - f = udecimal::U8(123, 0); + f = decimal::U8(123, 0); ASSERT_EQ(f.to_string(), "123"); - f = udecimal::U8(123, 5); + f = decimal::U8(123, 5); ASSERT_EQ(f.to_string(), "0.00123"); - f = udecimal::U8(123456789001, 9); + f = decimal::U8(123456789001, 9); ASSERT_EQ(f.to_string(), "123.456789"); - f = udecimal::U8(123456789012, 9); + f = decimal::U8(123456789012, 9); ASSERT_EQ(f.to_string(7), "123.4567890"); ASSERT_EQ(f.to_string(), "123.45678901"); - f = udecimal::U8(123456789012, 9); + f = decimal::U8(123456789012, 9); ASSERT_EQ(f.to_string(8), "123.45678901"); auto g = Decimal<3>(123, 5); @@ -206,258 +206,258 @@ TEST_F(DecimalTest, NewIU8) { } TEST_F(DecimalTest, NewII8) { - udecimal::I8 f = udecimal::I8(123, 1); + decimal::I8 f = decimal::I8(123, 1); ASSERT_EQ(f.to_string(), "12.3"); - f = udecimal::I8(123, 0); + f = decimal::I8(123, 0); ASSERT_EQ(f.to_string(), "123"); - f = udecimal::I8(123, 5); + f = decimal::I8(123, 5); ASSERT_EQ(f.to_string(), "0.00123"); - f = udecimal::I8(123456789001, 9); + f = decimal::I8(123456789001, 9); ASSERT_EQ(f.to_string(), "123.456789"); - f = udecimal::I8(123456789012, 9); + f = decimal::I8(123456789012, 9); ASSERT_EQ(f.to_string(7), "123.4567890"); ASSERT_EQ(f.to_string(), "123.45678901"); - f = udecimal::I8(123456789012, 9); + f = decimal::I8(123456789012, 9); ASSERT_EQ(f.to_string(8), "123.45678901"); - f = udecimal::I8(-123, 1); + f = decimal::I8(-123, 1); ASSERT_EQ(f.to_string(), "-12.3"); - f = udecimal::I8(-123, 0); + f = decimal::I8(-123, 0); ASSERT_EQ(f.to_string(), "-123"); - f = udecimal::I8(-123, 5); + f = decimal::I8(-123, 5); ASSERT_EQ(f.to_string(), "-0.00123"); - f = udecimal::I8(-123456789001, 9); + f = decimal::I8(-123456789001, 9); ASSERT_EQ(f.to_string(), "-123.456789"); - f = udecimal::I8(-123456789012, 9); + f = decimal::I8(-123456789012, 9); ASSERT_EQ(f.to_string(7), "-123.4567890"); ASSERT_EQ(f.to_string(), "-123.45678901"); - f = udecimal::I8(-123456789012, 9); + f = decimal::I8(-123456789012, 9); ASSERT_EQ(f.to_string(8), "-123.45678901"); - auto g = Decimal<3, udecimal::Signed>(123, 5); + auto g = Decimal<3, decimal::Signed>(123, 5); ASSERT_EQ(g.to_string(), "0.001"); - g = Decimal<3, udecimal::Signed>(-123, 5); + g = Decimal<3, decimal::Signed>(-123, 5); ASSERT_EQ(g.to_string(), "-0.001"); } TEST_F(DecimalTest, MaxValueU8) { - udecimal::U8 f0 = udecimal::U8("12345678901"); + decimal::U8 f0 = decimal::U8("12345678901"); ASSERT_EQ(f0.MAX, 99999999999.99999999); ASSERT_EQ(f0.to_string(), "12345678901"); - ASSERT_THROW(udecimal::U8("123456789012"), std::overflow_error); - ASSERT_THROW(udecimal::U8("-12345678901"), std::overflow_error); - ASSERT_THROW(udecimal::U8("-123456789012"), std::overflow_error); + ASSERT_THROW(decimal::U8("123456789012"), std::overflow_error); + ASSERT_THROW(decimal::U8("-12345678901"), std::overflow_error); + ASSERT_THROW(decimal::U8("-123456789012"), std::overflow_error); - f0 = udecimal::U8("99999999999"); + f0 = decimal::U8("99999999999"); ASSERT_EQ(f0.to_string(), "99999999999"); - f0 = udecimal::U8("9.99999999"); + f0 = decimal::U8("9.99999999"); ASSERT_EQ(f0.to_string(), "9.99999999"); - f0 = udecimal::U8("99999999999.99999999"); + f0 = decimal::U8("99999999999.99999999"); ASSERT_EQ(f0.to_string(), "99999999999.99999999"); - f0 = udecimal::U8("99999999999.12345678901234567890"); + f0 = decimal::U8("99999999999.12345678901234567890"); ASSERT_EQ(f0.to_string(), "99999999999.12345678"); } TEST_F(DecimalTest, MaxValueI8) { - udecimal::I8 f0 = udecimal::I8("1234567890"); + decimal::I8 f0 = decimal::I8("1234567890"); ASSERT_EQ(f0.MAX, 9999999999.99999999); ASSERT_EQ(f0.to_string(), "1234567890"); - ASSERT_THROW(udecimal::I8("12345678901"), std::overflow_error); - ASSERT_THROW(udecimal::I8("123456789012"), std::overflow_error); + ASSERT_THROW(decimal::I8("12345678901"), std::overflow_error); + ASSERT_THROW(decimal::I8("123456789012"), std::overflow_error); - f0 = udecimal::I8("9999999999"); + f0 = decimal::I8("9999999999"); ASSERT_EQ(f0.to_string(), "9999999999"); - f0 = udecimal::I8("9.99999999"); + f0 = decimal::I8("9.99999999"); ASSERT_EQ(f0.to_string(), "9.99999999"); - f0 = udecimal::I8("9999999999.99999999"); + f0 = decimal::I8("9999999999.99999999"); ASSERT_EQ(f0.to_string(), "9999999999.99999999"); - f0 = udecimal::I8("9999999999.12345678901234567890"); + f0 = decimal::I8("9999999999.12345678901234567890"); ASSERT_EQ(f0.to_string(), "9999999999.12345678"); - f0 = udecimal::I8("-1234567890"); + f0 = decimal::I8("-1234567890"); ASSERT_EQ(f0.MAX, 9999999999.99999999); ASSERT_EQ(f0.to_string(), "-1234567890"); - ASSERT_THROW(udecimal::I8("-12345678901"), std::overflow_error); - ASSERT_THROW(udecimal::I8("-123456789012"), std::overflow_error); + ASSERT_THROW(decimal::I8("-12345678901"), std::overflow_error); + ASSERT_THROW(decimal::I8("-123456789012"), std::overflow_error); - f0 = udecimal::I8("-9999999999"); + f0 = decimal::I8("-9999999999"); ASSERT_EQ(f0.to_string(), "-9999999999"); - f0 = udecimal::I8("-9.99999999"); + f0 = decimal::I8("-9.99999999"); ASSERT_EQ(f0.to_string(), "-9.99999999"); - f0 = udecimal::I8("-9999999999.99999999"); + f0 = decimal::I8("-9999999999.99999999"); ASSERT_EQ(f0.to_string(), "-9999999999.99999999"); - f0 = udecimal::I8("-9999999999.12345678901234567890"); + f0 = decimal::I8("-9999999999.12345678901234567890"); ASSERT_EQ(f0.to_string(), "-9999999999.12345678"); } TEST_F(DecimalTest, ToDoubleU8) { - auto f0 = udecimal::U8("123.456"); - auto f1 = udecimal::U8(123.456); + auto f0 = decimal::U8("123.456"); + auto f1 = decimal::U8(123.456); ASSERT_EQ(f0, f1); - f1 = udecimal::U8(0.0001); + f1 = decimal::U8(0.0001); ASSERT_EQ(f1.to_string(), "0.0001"); - f1 = udecimal::U8(".1"); + f1 = decimal::U8(".1"); ASSERT_EQ(f1.to_string(), "0.1"); - auto f2 = udecimal::U8(udecimal::U8(f1.to_double()).to_string()); + auto f2 = decimal::U8(decimal::U8(f1.to_double()).to_string()); ASSERT_EQ(f1, f2); } TEST_F(DecimalTest, ToDoubleI8) { - auto f0 = udecimal::I8("123.456"); - auto f1 = udecimal::I8(123.456); + auto f0 = decimal::I8("123.456"); + auto f1 = decimal::I8(123.456); ASSERT_EQ(f0, f1); - f1 = udecimal::I8(0.0001); + f1 = decimal::I8(0.0001); ASSERT_EQ(f1.to_string(), "0.0001"); - f1 = udecimal::I8(".1"); + f1 = decimal::I8(".1"); ASSERT_EQ(f1.to_string(), "0.1"); - auto f2 = udecimal::I8(udecimal::I8(f1.to_double()).to_string()); + auto f2 = decimal::I8(decimal::I8(f1.to_double()).to_string()); ASSERT_EQ(f1, f2); - f0 = udecimal::I8("-123.456"); - f1 = udecimal::I8(-123.456); + f0 = decimal::I8("-123.456"); + f1 = decimal::I8(-123.456); ASSERT_EQ(f0, f1); - f1 = udecimal::I8(-0.0001); + f1 = decimal::I8(-0.0001); ASSERT_EQ(f1.to_string(), "-0.0001"); - f1 = udecimal::I8("-.1"); + f1 = decimal::I8("-.1"); ASSERT_EQ(f1.to_string(), "-0.1"); - auto b = udecimal::I8(f1.to_double()).to_string(); - f2 = udecimal::I8(udecimal::I8(f1.to_double()).to_string()); + auto b = decimal::I8(f1.to_double()).to_string(); + f2 = decimal::I8(decimal::I8(f1.to_double()).to_string()); ASSERT_EQ(f1, f2); } TEST_F(DecimalTest, InfiniteU8) { - auto f0 = udecimal::U8("0.10"); - auto f1 = udecimal::U8(0.10); + auto f0 = decimal::U8("0.10"); + auto f1 = decimal::U8(0.10); ASSERT_EQ(f0, f1); - auto f2 = udecimal::U8(0.0); + auto f2 = decimal::U8(0.0); for (int i = 0; i < 3; i++) { - f2 = f2 + udecimal::U8(0.10); + f2 = f2 + decimal::U8(0.10); } ASSERT_EQ(f2.to_string(), "0.3"); - f2 = udecimal::U8(0.0); + f2 = decimal::U8(0.0); for (int i = 0; i < 10; i++) { - f2 = f2 + udecimal::U8(0.10); + f2 = f2 + decimal::U8(0.10); } ASSERT_EQ(f2.to_string(), "1"); } TEST_F(DecimalTest, InfiniteI8) { - auto f0 = udecimal::I8("0.10"); - auto f1 = udecimal::I8(0.10); + auto f0 = decimal::I8("0.10"); + auto f1 = decimal::I8(0.10); ASSERT_EQ(f0, f1); - auto f2 = udecimal::I8(0.0); + auto f2 = decimal::I8(0.0); for (int i = 0; i < 3; i++) { - f2 = f2 + udecimal::I8(0.10); + f2 = f2 + decimal::I8(0.10); } ASSERT_EQ(f2.to_string(), "0.3"); - f2 = udecimal::I8(0.0); + f2 = decimal::I8(0.0); for (int i = 0; i < 10; i++) { - f2 = f2 + udecimal::I8(0.10); + f2 = f2 + decimal::I8(0.10); } ASSERT_EQ(f2.to_string(), "1"); - f0 = udecimal::I8("-0.10"); - f1 = udecimal::I8(-0.10); + f0 = decimal::I8("-0.10"); + f1 = decimal::I8(-0.10); ASSERT_EQ(f0, f1); - f2 = udecimal::I8(0.0); + f2 = decimal::I8(0.0); for (int i = 0; i < 3; i++) { - f2 = f2 - udecimal::I8(0.10); + f2 = f2 - decimal::I8(0.10); } ASSERT_EQ(f2.to_string(), "-0.3"); - f2 = udecimal::I8(0.0); + f2 = decimal::I8(0.0); for (int i = 0; i < 10; i++) { - f2 = f2 - udecimal::I8(0.10); + f2 = f2 - decimal::I8(0.10); } ASSERT_EQ(f2.to_string(), "-1"); } TEST_F(DecimalTest, AddSubU8) { - udecimal::U8 f0 = udecimal::U8("1"); - udecimal::U8 f1 = udecimal::U8("0.3333333"); + decimal::U8 f0 = decimal::U8("1"); + decimal::U8 f1 = decimal::U8("0.3333333"); - udecimal::U8 f2 = f0 - f1; + decimal::U8 f2 = f0 - f1; f2 = f2 - f1; f2 -= f1; ASSERT_EQ(f2.to_string(), "0.0000001"); - f2 = f2 - udecimal::U8("0.0000001"); + f2 = f2 - decimal::U8("0.0000001"); ASSERT_EQ(f2.to_string(), "0"); - f0 = udecimal::U8("0"); + f0 = decimal::U8("0"); for (int i = 0; i < 5; i++) { - f0 = f0 + udecimal::U8("0.1"); - f0 += udecimal::U8("0.1"); + f0 = f0 + decimal::U8("0.1"); + f0 += decimal::U8("0.1"); } ASSERT_EQ(f0.to_string(), "1"); } TEST_F(DecimalTest, AddSubI8) { - udecimal::I8 f0 = udecimal::I8("1"); - udecimal::I8 f1 = udecimal::I8("0.3333333"); + decimal::I8 f0 = decimal::I8("1"); + decimal::I8 f1 = decimal::I8("0.3333333"); - udecimal::I8 f2 = f0 - f1; + decimal::I8 f2 = f0 - f1; f2 = f2 - f1; f2 = f2 - f1; ASSERT_EQ(f2.to_string(), "0.0000001"); - f2 = f2 - udecimal::I8("0.0000001"); + f2 = f2 - decimal::I8("0.0000001"); ASSERT_EQ(f2.to_string(), "0"); - f0 = udecimal::I8("0"); + f0 = decimal::I8("0"); for (int i = 0; i < 10; i++) { - f0 = f0 + udecimal::I8("0.1"); + f0 = f0 + decimal::I8("0.1"); } ASSERT_EQ(f0.to_string(), "1"); - f0 = udecimal::I8("-1"); - f1 = udecimal::I8("-0.3333333"); + f0 = decimal::I8("-1"); + f1 = decimal::I8("-0.3333333"); f2 = f0 - f1; f2 = f2 - f1; @@ -465,31 +465,31 @@ TEST_F(DecimalTest, AddSubI8) { ASSERT_EQ(f2.to_string(), "-0.0000001"); - f2 = f2 - udecimal::I8("-0.0000001"); + f2 = f2 - decimal::I8("-0.0000001"); ASSERT_EQ(f2.to_string(), "0"); - f0 = udecimal::I8("0"); + f0 = decimal::I8("0"); for (int i = 0; i < 10; i++) { - f0 = f0 + udecimal::I8("0.1"); // Note: Adding to a negative + f0 = f0 + decimal::I8("0.1"); // Note: Adding to a negative } ASSERT_EQ(f0.to_string(), "1"); } TEST_F(DecimalTest, MulDivU8) { - udecimal::U8 f0("123.456"); - udecimal::U8 f1("1000"); + decimal::U8 f0("123.456"); + decimal::U8 f1("1000"); - udecimal::U8 f2 = f0 * f1; + decimal::U8 f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "123456"); - f0 = udecimal::U8("123456"); - f1 = udecimal::U8("0.0001"); + f0 = decimal::U8("123456"); + f1 = decimal::U8("0.0001"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "12.3456"); - f0 = udecimal::U8("10000.1"); - f1 = udecimal::U8("10000"); + f0 = decimal::U8("10000.1"); + f1 = decimal::U8("10000"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "100001000"); @@ -503,46 +503,46 @@ TEST_F(DecimalTest, MulDivU8) { f2 /= f1; ASSERT_EQ(f2, f0); - f0 = udecimal::U8("2"); - f1 = udecimal::U8("3"); + f0 = decimal::U8("2"); + f1 = decimal::U8("3"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "0.66666667"); - f0 = udecimal::U8("1000"); - f1 = udecimal::U8("10"); + f0 = decimal::U8("1000"); + f1 = decimal::U8("10"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "100"); - f0 = udecimal::U8("1000"); - f1 = udecimal::U8("0.1"); + f0 = decimal::U8("1000"); + f1 = decimal::U8("0.1"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "10000"); - f0 = udecimal::U8("1"); - f1 = udecimal::U8("0.1"); + f0 = decimal::U8("1"); + f1 = decimal::U8("0.1"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "0.1"); } TEST_F(DecimalTest, MulDivI8) { - udecimal::I8 f0("123.456"); - udecimal::I8 f1("1000"); + decimal::I8 f0("123.456"); + decimal::I8 f1("1000"); - udecimal::I8 f2 = f0 * f1; + decimal::I8 f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "123456"); - f0 = udecimal::I8("123456"); - f1 = udecimal::I8("0.0001"); + f0 = decimal::I8("123456"); + f1 = decimal::I8("0.0001"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "12.3456"); - f0 = udecimal::I8("10000.1"); - f1 = udecimal::I8("10000"); + f0 = decimal::I8("10000.1"); + f1 = decimal::I8("10000"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "100001000"); @@ -556,45 +556,45 @@ TEST_F(DecimalTest, MulDivI8) { f2 /= f1; ASSERT_EQ(f2, f0); - f0 = udecimal::I8("2"); - f1 = udecimal::I8("3"); + f0 = decimal::I8("2"); + f1 = decimal::I8("3"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "0.66666667"); - f0 = udecimal::I8("1000"); - f1 = udecimal::I8("10"); + f0 = decimal::I8("1000"); + f1 = decimal::I8("10"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "100"); - f0 = udecimal::I8("1000"); - f1 = udecimal::I8("0.1"); + f0 = decimal::I8("1000"); + f1 = decimal::I8("0.1"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "10000"); - f0 = udecimal::I8("1"); - f1 = udecimal::I8("0.1"); + f0 = decimal::I8("1"); + f1 = decimal::I8("0.1"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "0.1"); // Negative-Positive cases (resulting in negative) - f0 = udecimal::I8("-123.456"); - f1 = udecimal::I8("1000"); + f0 = decimal::I8("-123.456"); + f1 = decimal::I8("1000"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "-123456"); - f0 = udecimal::I8("-123456"); - f1 = udecimal::I8("0.0001"); + f0 = decimal::I8("-123456"); + f1 = decimal::I8("0.0001"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "-12.3456"); - f0 = udecimal::I8("-10000.1"); - f1 = udecimal::I8("10000"); + f0 = decimal::I8("-10000.1"); + f1 = decimal::I8("10000"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "-100001000"); @@ -608,45 +608,45 @@ TEST_F(DecimalTest, MulDivI8) { f2 /= f1; ASSERT_EQ(f2, f0); - f0 = udecimal::I8("-2"); - f1 = udecimal::I8("3"); + f0 = decimal::I8("-2"); + f1 = decimal::I8("3"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "-0.66666667"); - f0 = udecimal::I8("-1000"); - f1 = udecimal::I8("10"); + f0 = decimal::I8("-1000"); + f1 = decimal::I8("10"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "-100"); - f0 = udecimal::I8("-1000"); - f1 = udecimal::I8("0.1"); + f0 = decimal::I8("-1000"); + f1 = decimal::I8("0.1"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "-10000"); - f0 = udecimal::I8("-1"); - f1 = udecimal::I8("0.1"); + f0 = decimal::I8("-1"); + f1 = decimal::I8("0.1"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "-0.1"); // Positive-Negative cases (resulting in negative) - f0 = udecimal::I8("123.456"); - f1 = udecimal::I8("-1000"); + f0 = decimal::I8("123.456"); + f1 = decimal::I8("-1000"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "-123456"); - f0 = udecimal::I8("123456"); - f1 = udecimal::I8("-0.0001"); + f0 = decimal::I8("123456"); + f1 = decimal::I8("-0.0001"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "-12.3456"); - f0 = udecimal::I8("10000.1"); - f1 = udecimal::I8("-10000"); + f0 = decimal::I8("10000.1"); + f1 = decimal::I8("-10000"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "-100001000"); @@ -660,45 +660,45 @@ TEST_F(DecimalTest, MulDivI8) { f2 /= f1; ASSERT_EQ(f2, f0); - f0 = udecimal::I8("2"); - f1 = udecimal::I8("-3"); + f0 = decimal::I8("2"); + f1 = decimal::I8("-3"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "-0.66666667"); - f0 = udecimal::I8("1000"); - f1 = udecimal::I8("-10"); + f0 = decimal::I8("1000"); + f1 = decimal::I8("-10"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "-100"); - f0 = udecimal::I8("1000"); - f1 = udecimal::I8("-0.1"); + f0 = decimal::I8("1000"); + f1 = decimal::I8("-0.1"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "-10000"); - f0 = udecimal::I8("1"); - f1 = udecimal::I8("-0.1"); + f0 = decimal::I8("1"); + f1 = decimal::I8("-0.1"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "-0.1"); // Negative-Negative cases (resulting in positive) - f0 = udecimal::I8("-123.456"); - f1 = udecimal::I8("-1000"); + f0 = decimal::I8("-123.456"); + f1 = decimal::I8("-1000"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "123456"); - f0 = udecimal::I8("-123456"); - f1 = udecimal::I8("-0.0001"); + f0 = decimal::I8("-123456"); + f1 = decimal::I8("-0.0001"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "12.3456"); - f0 = udecimal::I8("-10000.1"); - f1 = udecimal::I8("-10000"); + f0 = decimal::I8("-10000.1"); + f1 = decimal::I8("-10000"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "100001000"); @@ -712,224 +712,224 @@ TEST_F(DecimalTest, MulDivI8) { f2 /= f1; ASSERT_EQ(f2, f0); - f0 = udecimal::I8("-2"); - f1 = udecimal::I8("-3"); + f0 = decimal::I8("-2"); + f1 = decimal::I8("-3"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "0.66666667"); - f0 = udecimal::I8("-1000"); - f1 = udecimal::I8("-10"); + f0 = decimal::I8("-1000"); + f1 = decimal::I8("-10"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "100"); - f0 = udecimal::I8("-1000"); - f1 = udecimal::I8("-0.1"); + f0 = decimal::I8("-1000"); + f1 = decimal::I8("-0.1"); f2 = f0 / f1; ASSERT_EQ(f2.to_string(), "10000"); - f0 = udecimal::I8("-1"); - f1 = udecimal::I8("-0.1"); + f0 = decimal::I8("-1"); + f1 = decimal::I8("-0.1"); f2 = f0 * f1; ASSERT_EQ(f2.to_string(), "0.1"); } TEST_F(DecimalTest, NegativesU8) { - ASSERT_THROW(udecimal::U8("-1"), std::overflow_error); - ASSERT_THROW(udecimal::U8(-1.0), std::overflow_error); + ASSERT_THROW(decimal::U8("-1"), std::overflow_error); + ASSERT_THROW(decimal::U8(-1.0), std::overflow_error); - udecimal::U8 f0("99"); - udecimal::U8 f1("100"); + decimal::U8 f0("99"); + decimal::U8 f1("100"); ASSERT_THROW(f0 - f1, std::overflow_error); - f0 = udecimal::U8(".001"); - f1 = udecimal::U8(".002"); + f0 = decimal::U8(".001"); + f1 = decimal::U8(".002"); ASSERT_THROW(f0 - f1, std::overflow_error); } TEST_F(DecimalTest, NegativesI8) { - udecimal::I8 f0("-1"); - udecimal::I8 f1(-1.0); + decimal::I8 f0("-1"); + decimal::I8 f1(-1.0); - f0 = udecimal::I8("99"); - f1 = udecimal::I8("100"); + f0 = decimal::I8("99"); + f1 = decimal::I8("100"); - ASSERT_EQ(f0 - f1, udecimal::I8("-1")); + ASSERT_EQ(f0 - f1, decimal::I8("-1")); - f0 = udecimal::I8(".001"); - f1 = udecimal::I8(".002"); + f0 = decimal::I8(".001"); + f1 = decimal::I8(".002"); - ASSERT_EQ(f0 - f1, udecimal::I8("-.001")); + ASSERT_EQ(f0 - f1, decimal::I8("-.001")); } TEST_F(DecimalTest, DecimalPrecisionTooLargeU8) { - auto f0 = udecimal::U8(1.12345678); + auto f0 = decimal::U8(1.12345678); ASSERT_EQ(f0.to_string(), "1.12345678"); - f0 = udecimal::U8(1.123456789123); + f0 = decimal::U8(1.123456789123); ASSERT_EQ(f0.to_string(), "1.12345679"); - f0 = udecimal::U8(1.0 / 3.0); + f0 = decimal::U8(1.0 / 3.0); ASSERT_EQ(f0.to_string(), "0.33333333"); - f0 = udecimal::U8(2.0 / 3.0); + f0 = decimal::U8(2.0 / 3.0); ASSERT_EQ(f0.to_string(), "0.66666667"); } TEST_F(DecimalTest, DecimalPrecisionTooLargeI8) { - auto f0 = udecimal::I8(1.12345678); + auto f0 = decimal::I8(1.12345678); ASSERT_EQ(f0.to_string(), "1.12345678"); - f0 = udecimal::I8(1.123456789123); + f0 = decimal::I8(1.123456789123); ASSERT_EQ(f0.to_string(), "1.12345679"); - f0 = udecimal::I8(1.0 / 3.0); + f0 = decimal::I8(1.0 / 3.0); ASSERT_EQ(f0.to_string(), "0.33333333"); - f0 = udecimal::I8(2.0 / 3.0); + f0 = decimal::I8(2.0 / 3.0); ASSERT_EQ(f0.to_string(), "0.66666667"); - f0 = udecimal::I8(-1.12345678); + f0 = decimal::I8(-1.12345678); ASSERT_EQ(f0.to_string(), "-1.12345678"); - f0 = udecimal::I8(-1.123456789123); + f0 = decimal::I8(-1.123456789123); ASSERT_EQ(f0.to_string(), "-1.12345679"); - f0 = udecimal::I8(-1.0 / 3.0); + f0 = decimal::I8(-1.0 / 3.0); ASSERT_EQ(f0.to_string(), "-0.33333333"); - f0 = udecimal::I8(-2.0 / 3.0); + f0 = decimal::I8(-2.0 / 3.0); ASSERT_EQ(f0.to_string(), "-0.66666667"); } TEST_F(DecimalTest, NaN) { - ASSERT_THROW(udecimal::U8(std::nan("")), std::invalid_argument); - ASSERT_THROW(udecimal::I8(std::nan("")), std::invalid_argument); + ASSERT_THROW(decimal::U8(std::nan("")), std::invalid_argument); + ASSERT_THROW(decimal::I8(std::nan("")), std::invalid_argument); - ASSERT_THROW(udecimal::U8("NaN"), std::invalid_argument); - ASSERT_THROW(udecimal::I8("NaN"), std::invalid_argument); + ASSERT_THROW(decimal::U8("NaN"), std::invalid_argument); + ASSERT_THROW(decimal::I8("NaN"), std::invalid_argument); - udecimal::U8 f0("0.0004096"); + decimal::U8 f0("0.0004096"); ASSERT_EQ(f0.to_string(), "0.0004096"); - udecimal::I8 f1("0.0004096"); + decimal::I8 f1("0.0004096"); ASSERT_EQ(f1.to_string(), "0.0004096"); - udecimal::I8 f2("-0.0004096"); + decimal::I8 f2("-0.0004096"); ASSERT_EQ(f2.to_string(), "-0.0004096"); } TEST_F(DecimalTest, IntFrac) { - auto f0 = udecimal::U8(1234.5678); + auto f0 = decimal::U8(1234.5678); ASSERT_EQ(f0.to_int(), 1234); ASSERT_DOUBLE_EQ(f0.to_frac(), .5678); // Use ASSERT_DOUBLE_EQ for comparing floating point numbers - auto f1 = udecimal::I8(1234.5678); + auto f1 = decimal::I8(1234.5678); ASSERT_EQ(f1.to_int(), 1234); ASSERT_DOUBLE_EQ(f1.to_frac(), .5678); // Use ASSERT_DOUBLE_EQ for comparing floating point numbers - f1 = udecimal::I8(-1234.5678); + f1 = decimal::I8(-1234.5678); ASSERT_EQ(f1.to_int(), -1234); ASSERT_DOUBLE_EQ(f1.to_frac(), -.5678); // Use ASSERT_DOUBLE_EQ for comparing floating point numbers } TEST_F(DecimalTest, StringU8) { - auto f0 = udecimal::U8(1234.5678); + auto f0 = decimal::U8(1234.5678); ASSERT_EQ(f0.to_string(), "1234.5678"); - f0 = udecimal::U8(1234.0); + f0 = decimal::U8(1234.0); ASSERT_EQ(f0.to_string(), "1234"); - f0 = udecimal::U8("1.1"); + f0 = decimal::U8("1.1"); std::string s = f0.to_string(2); ASSERT_EQ(s, "1.10"); - f0 = udecimal::U8("1"); + f0 = decimal::U8("1"); s = f0.to_string(2); ASSERT_EQ(s, "1.00"); - f0 = udecimal::U8("1.123"); + f0 = decimal::U8("1.123"); s = f0.to_string(2); ASSERT_EQ(s, "1.12"); - f0 = udecimal::U8("1.123"); + f0 = decimal::U8("1.123"); s = f0.to_string(0); ASSERT_EQ(s, "1"); s = f0.to_string(10); ASSERT_EQ(s, "1.12300000"); - f0 = udecimal::U8(0.0); + f0 = decimal::U8(0.0); s = f0.to_string(10); ASSERT_EQ(s, "0.00000000"); } TEST_F(DecimalTest, StringI8) { - auto f0 = udecimal::I8(1234.5678); + auto f0 = decimal::I8(1234.5678); ASSERT_EQ(f0.to_string(), "1234.5678"); - f0 = udecimal::I8(1234.0); + f0 = decimal::I8(1234.0); ASSERT_EQ(f0.to_string(), "1234"); - f0 = udecimal::I8("1.1"); + f0 = decimal::I8("1.1"); std::string s = f0.to_string(2); ASSERT_EQ(s, "1.10"); - f0 = udecimal::I8("1"); + f0 = decimal::I8("1"); s = f0.to_string(2); ASSERT_EQ(s, "1.00"); - f0 = udecimal::I8("1.123"); + f0 = decimal::I8("1.123"); s = f0.to_string(2); ASSERT_EQ(s, "1.12"); - f0 = udecimal::I8("1.123"); + f0 = decimal::I8("1.123"); s = f0.to_string(0); ASSERT_EQ(s, "1"); - f0 = udecimal::I8("1.123"); + f0 = decimal::I8("1.123"); s = f0.to_string(10); ASSERT_EQ(s, "1.12300000"); - f0 = udecimal::I8(0.0); + f0 = decimal::I8(0.0); s = f0.to_string(10); ASSERT_EQ(s, "0.00000000"); - f0 = udecimal::I8(-1234.5678); + f0 = decimal::I8(-1234.5678); ASSERT_EQ(f0.to_string(), "-1234.5678"); - f0 = udecimal::I8(-1234.0); + f0 = decimal::I8(-1234.0); ASSERT_EQ(f0.to_string(), "-1234"); - f0 = udecimal::I8("-1.1"); + f0 = decimal::I8("-1.1"); s = f0.to_string(2); ASSERT_EQ(s, "-1.10"); - f0 = udecimal::I8("-1"); + f0 = decimal::I8("-1"); s = f0.to_string(2); ASSERT_EQ(s, "-1.00"); - f0 = udecimal::I8("-1.123"); + f0 = decimal::I8("-1.123"); s = f0.to_string(2); ASSERT_EQ(s, "-1.12"); - f0 = udecimal::I8("-1.123"); + f0 = decimal::I8("-1.123"); s = f0.to_string(0); ASSERT_EQ(s, "-1"); - f0 = udecimal::I8("-1.123"); + f0 = decimal::I8("-1.123"); s = f0.to_string(10); ASSERT_EQ(s, "-1.12300000"); } TEST_F(DecimalTest, RoundU8) { - udecimal::U8 f0 = udecimal::U8("1.12345"); - udecimal::U8 f1 = f0.round(2); + decimal::U8 f0 = decimal::U8("1.12345"); + decimal::U8 f1 = f0.round(2); ASSERT_EQ(f1.to_string(), "1.12"); f1 = f0.round(5); @@ -941,31 +941,31 @@ TEST_F(DecimalTest, RoundU8) { f1 = f0.round(0); ASSERT_EQ(f1.to_string(), "1"); - f0 = udecimal::U8("1.12345"); + f0 = decimal::U8("1.12345"); f1 = f0.round(7); ASSERT_EQ(f1.to_string(), "1.12345"); - f0 = udecimal::U8("0"); + f0 = decimal::U8("0"); f1 = f0.round(4); ASSERT_EQ(f1.to_string(), "0"); - f0 = udecimal::U8("0.0001234"); + f0 = decimal::U8("0.0001234"); f1 = f0.round(2); ASSERT_EQ(f1.to_string(), "0"); - f0 = udecimal::U8("0.6789"); + f0 = decimal::U8("0.6789"); f1 = f0.round(2); ASSERT_EQ(f1.to_string(), "0.68"); - f0 = udecimal::U8("0.0000"); + f0 = decimal::U8("0.0000"); f1 = f0.round(2); ASSERT_EQ(f1.to_string(), "0"); - f0 = udecimal::U8("123456789.987654321"); + f0 = decimal::U8("123456789.987654321"); f1 = f0.round(3); ASSERT_EQ(f1.to_string(), "123456789.988"); - f0 = udecimal::U8("123456789.987654321"); + f0 = decimal::U8("123456789.987654321"); f1 = f0.round(0); ASSERT_EQ(f1.to_string(), "123456789"); @@ -976,8 +976,8 @@ TEST_F(DecimalTest, RoundU8) { TEST_F(DecimalTest, RoundI8) { // Test cases for positive values - udecimal::I8 f0 = udecimal::I8("1.12345"); - udecimal::I8 f1 = f0.round(2); + decimal::I8 f0 = decimal::I8("1.12345"); + decimal::I8 f1 = f0.round(2); ASSERT_EQ(f1.to_string(), "1.12"); f1 = f0.round(5); @@ -989,40 +989,40 @@ TEST_F(DecimalTest, RoundI8) { f1 = f0.round(0); ASSERT_EQ(f1.to_string(), "1"); - f0 = udecimal::I8("1.12345"); + f0 = decimal::I8("1.12345"); f1 = f0.round(7); ASSERT_EQ(f1.to_string(), "1.12345"); - f0 = udecimal::I8("0"); + f0 = decimal::I8("0"); f1 = f0.round(4); ASSERT_EQ(f1.to_string(), "0"); - f0 = udecimal::I8("0.0001234"); + f0 = decimal::I8("0.0001234"); f1 = f0.round(2); ASSERT_EQ(f1.to_string(), "0"); - f0 = udecimal::I8("0.6789"); + f0 = decimal::I8("0.6789"); f1 = f0.round(2); ASSERT_EQ(f1.to_string(), "0.68"); - f0 = udecimal::I8("0.0000"); + f0 = decimal::I8("0.0000"); f1 = f0.round(2); ASSERT_EQ(f1.to_string(), "0"); - f0 = udecimal::I8("123456789.987654321"); + f0 = decimal::I8("123456789.987654321"); f1 = f0.round(3); ASSERT_EQ(f1.to_string(), "123456789.988"); - f0 = udecimal::I8("123456789.987654321"); + f0 = decimal::I8("123456789.987654321"); f1 = f0.round(0); ASSERT_EQ(f1.to_string(), "123456789"); - Decimal<17, udecimal::Signed> f2 = Decimal<17, udecimal::Signed>("0.000000012345678"); - Decimal<17, udecimal::Signed> f3 = f2.round(10); + Decimal<17, decimal::Signed> f2 = Decimal<17, decimal::Signed>("0.000000012345678"); + Decimal<17, decimal::Signed> f3 = f2.round(10); ASSERT_EQ(f3.to_string(), "0.0000000123"); // Additional test cases for negative values - f0 = udecimal::I8("-1.12345"); + f0 = decimal::I8("-1.12345"); f1 = f0.round(2); ASSERT_EQ(f1.to_string(), "-1.12"); @@ -1035,54 +1035,54 @@ TEST_F(DecimalTest, RoundI8) { f1 = f0.round(0); ASSERT_EQ(f1.to_string(), "-1"); - f0 = udecimal::I8("-1.12345"); + f0 = decimal::I8("-1.12345"); f1 = f0.round(7); ASSERT_EQ(f1.to_string(), "-1.12345"); - f0 = udecimal::I8("-0.0001234"); + f0 = decimal::I8("-0.0001234"); f1 = f0.round(2); ASSERT_EQ(f1.to_string(), "0"); - f0 = udecimal::I8("-0.6789"); + f0 = decimal::I8("-0.6789"); f1 = f0.round(2); ASSERT_EQ(f1.to_string(), "-0.68"); - f0 = udecimal::I8("-123456789.987654321"); + f0 = decimal::I8("-123456789.987654321"); f1 = f0.round(3); ASSERT_EQ(f1.to_string(), "-123456789.988"); - f0 = udecimal::I8("-123456789.987654321"); + f0 = decimal::I8("-123456789.987654321"); f1 = f0.round(0); ASSERT_EQ(f1.to_string(), "-123456789"); } TEST_F(DecimalTest, GeneralizedPlaces_Unsigned) { - udecimal::U9 f0 = udecimal::U9("9999999999.12345678901234567890"); + decimal::U9 f0 = decimal::U9("9999999999.12345678901234567890"); ASSERT_EQ(f0.scale, 1000000000); ASSERT_EQ(f0.MAX, 9999999999.999999999); ASSERT_EQ(f0.MIN, 0); ASSERT_EQ(f0.zeros(), "000000000"); ASSERT_EQ(f0.to_string(), "9999999999.123456789"); - udecimal::U10 f1 = udecimal::U10("999999999.1234567891234567890"); + decimal::U10 f1 = decimal::U10("999999999.1234567891234567890"); ASSERT_EQ(f1.scale, 10000000000); ASSERT_EQ(f1.MAX, 999999999.9999999999); ASSERT_EQ(f1.zeros(), "0000000000"); ASSERT_EQ(f1.to_string(), "999999999.1234567891"); - udecimal::U11 f2 = udecimal::U11("99999999.12345678901234567890"); + decimal::U11 f2 = decimal::U11("99999999.12345678901234567890"); ASSERT_EQ(f2.scale, 100000000000); ASSERT_EQ(f2.MAX, 99999999.99999999999); ASSERT_EQ(f2.zeros(), "00000000000"); ASSERT_EQ(f2.to_string(), "99999999.12345678901"); - udecimal::U18 f3 = udecimal::U18("9.12345678901234567890"); + decimal::U18 f3 = decimal::U18("9.12345678901234567890"); ASSERT_EQ(f3.scale, 1000000000000000000); ASSERT_EQ(f3.MAX, 9.999999999999999999); ASSERT_EQ(f3.zeros(), "000000000000000000"); ASSERT_EQ(f3.to_string(), "9.123456789012345678"); - udecimal::U1 f4 = udecimal::U1("999999999999999999.12345678901234567890"); + decimal::U1 f4 = decimal::U1("999999999999999999.12345678901234567890"); ASSERT_EQ(f4.scale, 10); ASSERT_EQ(f4.MAX, 999999999999999999.9); ASSERT_EQ(f4.zeros(), "0"); @@ -1090,35 +1090,35 @@ TEST_F(DecimalTest, GeneralizedPlaces_Unsigned) { } TEST_F(DecimalTest, GeneralizedPlaces_Signed_Positive) { - udecimal::I9 f0 = udecimal::I9("999999999.12345678901234567890"); + decimal::I9 f0 = decimal::I9("999999999.12345678901234567890"); ASSERT_EQ(f0.scale, 1000000000); ASSERT_EQ(f0.MAX, 999999999.999999999); ASSERT_EQ(f0.MIN, -999999999.999999999); ASSERT_EQ(f0.zeros(), "000000000"); ASSERT_EQ(f0.to_string(), "999999999.123456789"); - udecimal::I10 f1 = udecimal::I10("99999999.1234567891234567890"); + decimal::I10 f1 = decimal::I10("99999999.1234567891234567890"); ASSERT_EQ(f1.scale, 10000000000); ASSERT_EQ(f1.MAX, 99999999.9999999999); ASSERT_EQ(f1.MIN, -99999999.9999999999); ASSERT_EQ(f1.zeros(), "0000000000"); ASSERT_EQ(f1.to_string(), "99999999.1234567891"); - udecimal::I11 f2 = udecimal::I11("9999999.12345678901234567890"); + decimal::I11 f2 = decimal::I11("9999999.12345678901234567890"); ASSERT_EQ(f2.scale, 100000000000); ASSERT_EQ(f2.MAX, 9999999.99999999999); ASSERT_EQ(f2.MIN, -9999999.99999999999); ASSERT_EQ(f2.zeros(), "00000000000"); ASSERT_EQ(f2.to_string(), "9999999.12345678901"); - udecimal::I17 f3 = udecimal::I17("9.12345678901234567890"); + decimal::I17 f3 = decimal::I17("9.12345678901234567890"); ASSERT_EQ(f3.scale, 100000000000000000); ASSERT_EQ(f3.MAX, 9.999999999999999999); ASSERT_EQ(f3.MIN, -9.999999999999999999); ASSERT_EQ(f3.zeros(), "00000000000000000"); ASSERT_EQ(f3.to_string(), "9.12345678901234567"); - udecimal::I1 f4 = udecimal::I1("99999999999999999.12345678901234567890"); + decimal::I1 f4 = decimal::I1("99999999999999999.12345678901234567890"); ASSERT_EQ(f4.scale, 10); ASSERT_EQ(f4.MAX, 99999999999999999.9); ASSERT_EQ(f4.MIN, -99999999999999999.9); @@ -1127,35 +1127,35 @@ TEST_F(DecimalTest, GeneralizedPlaces_Signed_Positive) { } TEST_F(DecimalTest, GeneralizedPlaces_Signed_Negative) { - udecimal::I9 f0 = udecimal::I9("-999999999.12345678901234567890"); + decimal::I9 f0 = decimal::I9("-999999999.12345678901234567890"); ASSERT_EQ(f0.scale, 1000000000); ASSERT_EQ(f0.MAX, 999999999.999999999); ASSERT_EQ(f0.MIN, -999999999.999999999); ASSERT_EQ(f0.zeros(), "000000000"); ASSERT_EQ(f0.to_string(), "-999999999.123456789"); - udecimal::I10 f1 = udecimal::I10("-99999999.1234567891234567890"); + decimal::I10 f1 = decimal::I10("-99999999.1234567891234567890"); ASSERT_EQ(f1.scale, 10000000000); ASSERT_EQ(f1.MAX, 99999999.9999999999); ASSERT_EQ(f1.MIN, -99999999.9999999999); ASSERT_EQ(f1.zeros(), "0000000000"); ASSERT_EQ(f1.to_string(), "-99999999.1234567891"); - udecimal::I11 f2 = udecimal::I11("-9999999.12345678901234567890"); + decimal::I11 f2 = decimal::I11("-9999999.12345678901234567890"); ASSERT_EQ(f2.scale, 100000000000); ASSERT_EQ(f2.MAX, 9999999.99999999999); ASSERT_EQ(f2.MIN, -9999999.99999999999); ASSERT_EQ(f2.zeros(), "00000000000"); ASSERT_EQ(f2.to_string(), "-9999999.12345678901"); - udecimal::I17 f3 = udecimal::I17("-9.12345678901234567890"); + decimal::I17 f3 = decimal::I17("-9.12345678901234567890"); ASSERT_EQ(f3.scale, 100000000000000000); ASSERT_EQ(f3.MAX, 9.999999999999999999); ASSERT_EQ(f3.MIN, -9.999999999999999999); ASSERT_EQ(f3.zeros(), "00000000000000000"); ASSERT_EQ(f3.to_string(), "-9.12345678901234567"); - udecimal::I1 f4 = udecimal::I1("-99999999999999999.12345678901234567890"); + decimal::I1 f4 = decimal::I1("-99999999999999999.12345678901234567890"); ASSERT_EQ(f4.scale, 10); ASSERT_EQ(f4.MAX, 99999999999999999.9); ASSERT_EQ(f4.MIN, -99999999999999999.9); @@ -1164,153 +1164,153 @@ TEST_F(DecimalTest, GeneralizedPlaces_Signed_Negative) { } TEST_F(DecimalTest, ConvertPrecision_Unsigned) { - udecimal::U8 f0("1.12345678"); - udecimal::U2 f1 = f0.convert_precision<2>(); + decimal::U8 f0("1.12345678"); + decimal::U2 f1 = f0.convert_precision<2>(); ASSERT_EQ(f1.to_string(), "1.12"); - udecimal::U8 f2("100"); - udecimal::U2 f3 = f2.convert_precision<2>(); + decimal::U8 f2("100"); + decimal::U2 f3 = f2.convert_precision<2>(); ASSERT_EQ(f3.to_string(), "100"); - udecimal::U2 f4("1.12"); - udecimal::U8 f5 = f4.convert_precision<8>(); + decimal::U2 f4("1.12"); + decimal::U8 f5 = f4.convert_precision<8>(); ASSERT_EQ(f5.to_string(), "1.12"); - udecimal::U8 f6("1.12345678"); - udecimal::U8 f7 = f6.convert_precision<8>(); + decimal::U8 f6("1.12345678"); + decimal::U8 f7 = f6.convert_precision<8>(); ASSERT_EQ(f7.to_string(), "1.12345678"); - udecimal::U8 f8("1e8"); - udecimal::U2 f9 = f8.convert_precision<2>(); + decimal::U8 f8("1e8"); + decimal::U2 f9 = f8.convert_precision<2>(); ASSERT_EQ(f9.to_string(), "100000000"); - udecimal::U8 f10("0.000000012345678"); - udecimal::U4 f11 = f10.convert_precision<4>(); + decimal::U8 f10("0.000000012345678"); + decimal::U4 f11 = f10.convert_precision<4>(); ASSERT_EQ(f11.to_string(), "0"); - udecimal::U8 f12("1.126"); - udecimal::U2 f13 = f12.convert_precision<2>(); + decimal::U8 f12("1.126"); + decimal::U2 f13 = f12.convert_precision<2>(); ASSERT_EQ(f13.to_string(), "1.13"); - udecimal::U8 f14("1.124"); - udecimal::U2 f15 = f14.convert_precision<2>(); + decimal::U8 f14("1.124"); + decimal::U2 f15 = f14.convert_precision<2>(); ASSERT_EQ(f15.to_string(), "1.12"); - udecimal::U1 f16("12345678901234567"); - udecimal::U2 f17 = f16.convert_precision<2>(); + decimal::U1 f16("12345678901234567"); + decimal::U2 f17 = f16.convert_precision<2>(); ASSERT_EQ(f16.to_string(), f17.to_string()); - udecimal::U18 f18("0.0000000000000000001"); - udecimal::U1 f19 = f18.convert_precision<1>(); + decimal::U18 f18("0.0000000000000000001"); + decimal::U1 f19 = f18.convert_precision<1>(); ASSERT_EQ(f19.to_string(), "0"); - udecimal::U1 f20("123456789012345678"); + decimal::U1 f20("123456789012345678"); ASSERT_THROW(f20.convert_precision<18>(), std::overflow_error); - udecimal::U1 f22("123456789012345678"); + decimal::U1 f22("123456789012345678"); ASSERT_THROW(f22.convert_precision<3>(), std::overflow_error); - udecimal::U6 f24("12345.6789"); + decimal::U6 f24("12345.6789"); ASSERT_THROW(f24.convert_precision<16>(), std::overflow_error); } TEST_F(DecimalTest, ConvertPrecision_Signed) { - udecimal::I8 f0("1.12345678"); - udecimal::I2 f1 = f0.convert_precision<2>(); + decimal::I8 f0("1.12345678"); + decimal::I2 f1 = f0.convert_precision<2>(); ASSERT_EQ(f1.to_string(), "1.12"); - udecimal::I8 f2("100"); - udecimal::I2 f3 = f2.convert_precision<2>(); + decimal::I8 f2("100"); + decimal::I2 f3 = f2.convert_precision<2>(); ASSERT_EQ(f3.to_string(), "100"); - udecimal::I2 f4("1.12"); - udecimal::I8 f5 = f4.convert_precision<8>(); + decimal::I2 f4("1.12"); + decimal::I8 f5 = f4.convert_precision<8>(); ASSERT_EQ(f5.to_string(), "1.12"); - udecimal::I8 f6("1.12345678"); - udecimal::I8 f7 = f6.convert_precision<8>(); + decimal::I8 f6("1.12345678"); + decimal::I8 f7 = f6.convert_precision<8>(); ASSERT_EQ(f7.to_string(), "1.12345678"); - udecimal::I8 f8("1e8"); - udecimal::I2 f9 = f8.convert_precision<2>(); + decimal::I8 f8("1e8"); + decimal::I2 f9 = f8.convert_precision<2>(); ASSERT_EQ(f9.to_string(), "100000000"); - udecimal::I8 f10("0.000000012345678"); - udecimal::I4 f11 = f10.convert_precision<4>(); + decimal::I8 f10("0.000000012345678"); + decimal::I4 f11 = f10.convert_precision<4>(); ASSERT_EQ(f11.to_string(), "0"); - udecimal::I8 f12("1.126"); - udecimal::I2 f13 = f12.convert_precision<2>(); + decimal::I8 f12("1.126"); + decimal::I2 f13 = f12.convert_precision<2>(); ASSERT_EQ(f13.to_string(), "1.13"); - udecimal::I8 f14("1.124"); - udecimal::I2 f15 = f14.convert_precision<2>(); + decimal::I8 f14("1.124"); + decimal::I2 f15 = f14.convert_precision<2>(); ASSERT_EQ(f15.to_string(), "1.12"); - udecimal::I1 f16("12345678901234567"); - udecimal::I2 f17 = f16.convert_precision<2>(); + decimal::I1 f16("12345678901234567"); + decimal::I2 f17 = f16.convert_precision<2>(); ASSERT_EQ(f16.to_string(), f17.to_string()); - udecimal::I17 f18("0.000000000000000001"); - udecimal::I1 f19 = f18.convert_precision<1>(); + decimal::I17 f18("0.000000000000000001"); + decimal::I1 f19 = f18.convert_precision<1>(); ASSERT_EQ(f19.to_string(), "0"); - udecimal::I1 f20("12345678901234567"); + decimal::I1 f20("12345678901234567"); ASSERT_THROW(f20.convert_precision<17>(), std::overflow_error); - udecimal::I1 f22("12345678901234567"); + decimal::I1 f22("12345678901234567"); ASSERT_THROW(f22.convert_precision<3>(), std::overflow_error); - udecimal::I6 f24("12345.6789"); + decimal::I6 f24("12345.6789"); ASSERT_THROW(f24.convert_precision<16>(), std::overflow_error); - udecimal::I8 nf0("-1.12345678"); - udecimal::I2 nf1 = nf0.convert_precision<2>(); + decimal::I8 nf0("-1.12345678"); + decimal::I2 nf1 = nf0.convert_precision<2>(); ASSERT_EQ(nf1.to_string(), "-1.12"); - udecimal::I8 nf2("-100"); - udecimal::I2 nf3 = nf2.convert_precision<2>(); + decimal::I8 nf2("-100"); + decimal::I2 nf3 = nf2.convert_precision<2>(); ASSERT_EQ(nf3.to_string(), "-100"); - udecimal::I2 nf4("-1.12"); - udecimal::I8 nf5 = nf4.convert_precision<8>(); + decimal::I2 nf4("-1.12"); + decimal::I8 nf5 = nf4.convert_precision<8>(); ASSERT_EQ(nf5.to_string(), "-1.12"); - udecimal::I8 nf6("-1.12345678"); - udecimal::I8 nf7 = nf6.convert_precision<8>(); + decimal::I8 nf6("-1.12345678"); + decimal::I8 nf7 = nf6.convert_precision<8>(); ASSERT_EQ(nf7.to_string(), "-1.12345678"); - udecimal::I8 nf8("-1e8"); - udecimal::I2 nf9 = nf8.convert_precision<2>(); + decimal::I8 nf8("-1e8"); + decimal::I2 nf9 = nf8.convert_precision<2>(); ASSERT_EQ(nf9.to_string(), "-100000000"); - udecimal::I8 nf10("-0.000000012345678"); - udecimal::I4 nf11 = nf10.convert_precision<4>(); + decimal::I8 nf10("-0.000000012345678"); + decimal::I4 nf11 = nf10.convert_precision<4>(); ASSERT_EQ(nf11.to_string(), "0"); - udecimal::I8 nf12("-1.126"); - udecimal::I2 nf13 = nf12.convert_precision<2>(); + decimal::I8 nf12("-1.126"); + decimal::I2 nf13 = nf12.convert_precision<2>(); ASSERT_EQ(nf13.to_string(), "-1.13"); - udecimal::I8 nf14("-1.124"); - udecimal::I2 nf15 = nf14.convert_precision<2>(); + decimal::I8 nf14("-1.124"); + decimal::I2 nf15 = nf14.convert_precision<2>(); ASSERT_EQ(nf15.to_string(), "-1.12"); - udecimal::I1 nf16("-12345678901234567"); - udecimal::I2 nf17 = nf16.convert_precision<2>(); + decimal::I1 nf16("-12345678901234567"); + decimal::I2 nf17 = nf16.convert_precision<2>(); ASSERT_EQ(nf16.to_string(), nf17.to_string()); - udecimal::I17 nf18("-0.000000000000000001"); - udecimal::I1 nf19 = nf18.convert_precision<1>(); + decimal::I17 nf18("-0.000000000000000001"); + decimal::I1 nf19 = nf18.convert_precision<1>(); ASSERT_EQ(nf19.to_string(), "0"); - udecimal::I1 nf20("-12345678901234567"); + decimal::I1 nf20("-12345678901234567"); ASSERT_THROW(nf20.convert_precision<17>(), std::overflow_error); - udecimal::I1 nf22("-12345678901234567"); + decimal::I1 nf22("-12345678901234567"); ASSERT_THROW(nf22.convert_precision<3>(), std::overflow_error); - udecimal::I6 nf24("-12345.6789"); + decimal::I6 nf24("-12345.6789"); ASSERT_THROW(nf24.convert_precision<16>(), std::overflow_error); } @@ -1320,12 +1320,12 @@ class DecimalEncodeDecodeTest : public ::testing::Test { protected: std::vector extra_data{42, 24, 0}; - template + template void RunEncodeDecodeTest() { - udecimal::Decimal original(123.456789); + decimal::Decimal original(123.456789); std::vector binary_data = original.encode_binary(); - udecimal::Decimal result; + decimal::Decimal result; size_t offset = 0; result.decode_binary(binary_data, offset); @@ -1345,13 +1345,13 @@ class DecimalEncodeDecodeTest : public ::testing::Test { ASSERT_EQ(binary_vec, expected); } - template + template void RunDecodeBinaryDataTest() { - udecimal::Decimal original(987.654321); + decimal::Decimal original(987.654321); std::vector binary_data = original.encode_binary(); binary_data.insert(binary_data.end(), extra_data.begin(), extra_data.end()); - udecimal::Decimal result; + decimal::Decimal result; size_t offset = result.decode_binary_data(binary_data); std::vector remaining_data{binary_data.begin() + offset, binary_data.end()}; @@ -1362,27 +1362,27 @@ class DecimalEncodeDecodeTest : public ::testing::Test { }; TEST_F(DecimalEncodeDecodeTest, EncodeDecode) { - RunEncodeDecodeTest<3, udecimal::Unsigned>(); - RunEncodeDecodeTest<6, udecimal::Unsigned>(); - RunEncodeDecodeTest<8, udecimal::Unsigned>(); - RunEncodeDecodeTest<11, udecimal::Unsigned>(); - - RunEncodeDecodeTest<3, udecimal::Signed>(); - RunEncodeDecodeTest<6, udecimal::Signed>(); - RunEncodeDecodeTest<8, udecimal::Signed>(); - RunEncodeDecodeTest<11, udecimal::Signed>(); + RunEncodeDecodeTest<3, decimal::Unsigned>(); + RunEncodeDecodeTest<6, decimal::Unsigned>(); + RunEncodeDecodeTest<8, decimal::Unsigned>(); + RunEncodeDecodeTest<11, decimal::Unsigned>(); + + RunEncodeDecodeTest<3, decimal::Signed>(); + RunEncodeDecodeTest<6, decimal::Signed>(); + RunEncodeDecodeTest<8, decimal::Signed>(); + RunEncodeDecodeTest<11, decimal::Signed>(); } TEST_F(DecimalEncodeDecodeTest, DecodeBinaryData) { - RunDecodeBinaryDataTest<3, udecimal::Unsigned>(); - RunDecodeBinaryDataTest<6, udecimal::Unsigned>(); - RunDecodeBinaryDataTest<8, udecimal::Unsigned>(); - RunDecodeBinaryDataTest<11, udecimal::Unsigned>(); - - RunDecodeBinaryDataTest<3, udecimal::Signed>(); - RunDecodeBinaryDataTest<6, udecimal::Signed>(); - RunDecodeBinaryDataTest<8, udecimal::Signed>(); - RunDecodeBinaryDataTest<11, udecimal::Signed>(); + RunDecodeBinaryDataTest<3, decimal::Unsigned>(); + RunDecodeBinaryDataTest<6, decimal::Unsigned>(); + RunDecodeBinaryDataTest<8, decimal::Unsigned>(); + RunDecodeBinaryDataTest<11, decimal::Unsigned>(); + + RunDecodeBinaryDataTest<3, decimal::Signed>(); + RunDecodeBinaryDataTest<6, decimal::Signed>(); + RunDecodeBinaryDataTest<8, decimal::Signed>(); + RunDecodeBinaryDataTest<11, decimal::Signed>(); } int main(int argc, char** argv) {