diff options
Diffstat (limited to 'chromium/third_party/blink/renderer/platform/decimal_test.cc')
| -rw-r--r-- | chromium/third_party/blink/renderer/platform/decimal_test.cc | 1161 |
1 files changed, 1161 insertions, 0 deletions
diff --git a/chromium/third_party/blink/renderer/platform/decimal_test.cc b/chromium/third_party/blink/renderer/platform/decimal_test.cc new file mode 100644 index 00000000000..8bd321acfe1 --- /dev/null +++ b/chromium/third_party/blink/renderer/platform/decimal_test.cc @@ -0,0 +1,1161 @@ +/* + * Copyright (C) 2012 Google Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Google Inc. nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "third_party/blink/renderer/platform/decimal.h" + +#include <float.h> +#include "testing/gtest/include/gtest/gtest.h" +#include "third_party/blink/renderer/platform/wtf/math_extras.h" +#include "third_party/blink/renderer/platform/wtf/text/cstring.h" + +namespace blink { + +// Simulate core/html/forms/StepRange +class DecimalStepRange { + public: + Decimal maximum; + Decimal minimum; + Decimal step; + + DecimalStepRange(const Decimal& minimum, + const Decimal& maximum, + const Decimal& step) + : maximum(maximum), minimum(minimum), step(step) {} + + Decimal ClampValue(Decimal value) const { + const Decimal result = minimum + ((value - minimum) / step).Round() * step; + DCHECK(result.IsFinite()); + return result > maximum ? result - step : result; + } +}; + +class DecimalTest : public testing::Test { + protected: + using Sign = Decimal::Sign; + static const Sign kPositive = Decimal::kPositive; + static const Sign kNegative = Decimal::kNegative; + + Decimal Encode(uint64_t coefficient, int exponent, Sign sign) { + return Decimal(sign, exponent, coefficient); + } + + Decimal FromString(const String& string) { + return Decimal::FromString(string); + } + + Decimal StepDown(const String& minimum, + const String& maximum, + const String& step, + const String& value_string, + int number_of_step_times) { + DecimalStepRange step_range(FromString(minimum), FromString(maximum), + FromString(step)); + Decimal value = FromString(value_string); + for (int i = 0; i < number_of_step_times; ++i) { + value -= step_range.step; + value = step_range.ClampValue(value); + } + return value; + } + + Decimal StepUp(const String& minimum, + const String& maximum, + const String& step, + const String& value_string, + int number_of_step_times) { + DecimalStepRange step_range(FromString(minimum), FromString(maximum), + FromString(step)); + Decimal value = FromString(value_string); + for (int i = 0; i < number_of_step_times; ++i) { + value += step_range.step; + value = step_range.ClampValue(value); + } + return value; + } +}; + +// FIXME: We should use expectedSign without "Decimal::", however, g++ causes +// undefined references for DecimalTest::Positive and Negative. +#define EXPECT_DECIMAL_ENCODED_DATA_EQ(expectedCoefficient, expectedExponent, \ + expectedSign, decimal) \ + EXPECT_EQ((expectedCoefficient), (decimal).Value().Coefficient()); \ + EXPECT_EQ((expectedExponent), (decimal).Value().Exponent()); \ + EXPECT_EQ(Decimal::expectedSign, (decimal).Value().GetSign()); + +#define EXPECT_DECIMAL_STREQ(expected, decimal) \ + EXPECT_STREQ((expected), (decimal).ToString().Ascii().data()) + +TEST_F(DecimalTest, Abs) { + EXPECT_EQ(Encode(0, 0, kPositive), Encode(0, 0, kPositive).Abs()); + EXPECT_EQ(Encode(0, 0, kPositive), Encode(0, 0, kNegative).Abs()); + + EXPECT_EQ(Encode(0, 10, kPositive), Encode(0, 10, kPositive).Abs()); + EXPECT_EQ(Encode(0, 10, kPositive), Encode(0, 10, kNegative).Abs()); + + EXPECT_EQ(Encode(0, -10, kPositive), Encode(0, -10, kPositive).Abs()); + EXPECT_EQ(Encode(0, -10, kPositive), Encode(0, -10, kNegative).Abs()); + + EXPECT_EQ(Encode(1, 0, kPositive), Encode(1, 0, kPositive).Abs()); + EXPECT_EQ(Encode(1, 0, kPositive), Encode(1, 0, kNegative).Abs()); + + EXPECT_EQ(Encode(1, 10, kPositive), Encode(1, 10, kPositive).Abs()); + EXPECT_EQ(Encode(1, 10, kPositive), Encode(1, 10, kNegative).Abs()); + + EXPECT_EQ(Encode(1, -10, kPositive), Encode(1, -10, kPositive).Abs()); + EXPECT_EQ(Encode(1, -10, kPositive), Encode(1, -10, kNegative).Abs()); +} + +TEST_F(DecimalTest, AbsBigExponent) { + EXPECT_EQ(Encode(1, 1000, kPositive), Encode(1, 1000, kPositive).Abs()); + EXPECT_EQ(Encode(1, 1000, kPositive), Encode(1, 1000, kNegative).Abs()); +} + +TEST_F(DecimalTest, AbsSmallExponent) { + EXPECT_EQ(Encode(1, -1000, kPositive), Encode(1, -1000, kPositive).Abs()); + EXPECT_EQ(Encode(1, -1000, kPositive), Encode(1, -1000, kNegative).Abs()); +} + +TEST_F(DecimalTest, AbsSpecialValues) { + EXPECT_EQ(Decimal::Infinity(kPositive), Decimal::Infinity(kPositive).Abs()); + EXPECT_EQ(Decimal::Infinity(kPositive), Decimal::Infinity(kNegative).Abs()); + EXPECT_EQ(Decimal::Nan(), Decimal::Nan().Abs()); +} + +TEST_F(DecimalTest, Add) { + EXPECT_EQ(Encode(0, 0, kPositive), Decimal(0) + Decimal(0)); + EXPECT_EQ(Decimal(1), Decimal(2) + Decimal(-1)); + EXPECT_EQ(Decimal(1), Decimal(-1) + Decimal(2)); + EXPECT_EQ(Encode(100, 0, kPositive), Decimal(99) + Decimal(1)); + EXPECT_EQ(Encode(100, 0, kNegative), Decimal(-50) + Decimal(-50)); + EXPECT_EQ(Encode(UINT64_C(1000000000000000), 35, kPositive), + Encode(1, 50, kPositive) + Decimal(1)); + EXPECT_EQ(Encode(UINT64_C(1000000000000000), 35, kPositive), + Decimal(1) + Encode(1, 50, kPositive)); + EXPECT_EQ(Encode(UINT64_C(10000000001), 0, kPositive), + Encode(1, 10, kPositive) + Decimal(1)); + EXPECT_EQ(Encode(UINT64_C(10000000001), 0, kPositive), + Decimal(1) + Encode(1, 10, kPositive)); + EXPECT_EQ(Encode(1, 0, kPositive), + Encode(1, -1022, kPositive) + Encode(1, 0, kPositive)); + EXPECT_EQ(Encode(2, -1022, kPositive), + Encode(1, -1022, kPositive) + Encode(1, -1022, kPositive)); +} + +TEST_F(DecimalTest, AddBigExponent) { + EXPECT_EQ(Encode(1, 1022, kPositive), + Encode(1, 1022, kPositive) + Encode(1, 0, kPositive)); + EXPECT_EQ(Encode(2, 1022, kPositive), + Encode(1, 1022, kPositive) + Encode(1, 1022, kPositive)); + EXPECT_EQ(Decimal::Infinity(kPositive), + Encode(std::numeric_limits<uint64_t>::max(), 1022, kPositive) + + Encode(1, 0, kPositive)); + EXPECT_EQ(Encode(1, 1022, kPositive), + Encode(1, 1022, kPositive) + Encode(1, -1000, kPositive)); +} + +TEST_F(DecimalTest, AddSmallExponent) { + EXPECT_EQ(Encode(1, 0, kPositive), + Encode(1, -1022, kPositive) + Encode(1, 0, kPositive)); + EXPECT_EQ(Encode(2, -1022, kPositive), + Encode(1, -1022, kPositive) + Encode(1, -1022, kPositive)); +} + +TEST_F(DecimalTest, AddSpecialValues) { + const Decimal infinity(Decimal::Infinity(kPositive)); + const Decimal minus_infinity(Decimal::Infinity(kNegative)); + const Decimal na_n(Decimal::Nan()); + const Decimal ten(10); + + EXPECT_EQ(infinity, infinity + infinity); + EXPECT_EQ(na_n, infinity + minus_infinity); + EXPECT_EQ(na_n, minus_infinity + infinity); + EXPECT_EQ(minus_infinity, minus_infinity + minus_infinity); + + EXPECT_EQ(infinity, infinity + ten); + EXPECT_EQ(infinity, ten + infinity); + EXPECT_EQ(minus_infinity, minus_infinity + ten); + EXPECT_EQ(minus_infinity, ten + minus_infinity); + + EXPECT_EQ(na_n, na_n + na_n); + EXPECT_EQ(na_n, na_n + ten); + EXPECT_EQ(na_n, ten + na_n); + + EXPECT_EQ(na_n, na_n - infinity); + EXPECT_EQ(na_n, na_n - minus_infinity); + EXPECT_EQ(na_n, infinity - na_n); + EXPECT_EQ(na_n, minus_infinity - na_n); +} + +TEST_F(DecimalTest, Ceil) { + EXPECT_EQ(Decimal(1), Decimal(1).Ceil()); + EXPECT_EQ(Decimal(1), Encode(1, -10, kPositive).Ceil()); + EXPECT_EQ(Decimal(2), Encode(11, -1, kPositive).Ceil()); + EXPECT_EQ(Decimal(2), Encode(13, -1, kPositive).Ceil()); + EXPECT_EQ(Decimal(2), Encode(15, -1, kPositive).Ceil()); + EXPECT_EQ(Decimal(2), Encode(19, -1, kPositive).Ceil()); + EXPECT_EQ(Decimal(2), Encode(151, -2, kPositive).Ceil()); + EXPECT_EQ(Decimal(2), Encode(101, -2, kPositive).Ceil()); + EXPECT_EQ(Decimal(1), Encode(199, -3, kPositive).Ceil()); + EXPECT_EQ(Decimal(2), Encode(199, -2, kPositive).Ceil()); + EXPECT_EQ(Decimal(3), Encode(209, -2, kPositive).Ceil()); + + EXPECT_EQ(Decimal(-1), Decimal(-1).Ceil()); + EXPECT_EQ(Decimal(0), Encode(1, -10, kNegative).Ceil()); + EXPECT_EQ(Decimal(-1), Encode(11, -1, kNegative).Ceil()); + EXPECT_EQ(Decimal(-1), Encode(13, -1, kNegative).Ceil()); + EXPECT_EQ(Decimal(-1), Encode(15, -1, kNegative).Ceil()); + EXPECT_EQ(Decimal(-1), Encode(19, -1, kNegative).Ceil()); + EXPECT_EQ(Decimal(-1), Encode(151, -2, kNegative).Ceil()); + EXPECT_EQ(Decimal(-1), Encode(101, -2, kNegative).Ceil()); + EXPECT_EQ(Decimal(0), Encode(199, -3, kNegative).Ceil()); + EXPECT_EQ(Decimal(-1), Encode(199, -2, kNegative).Ceil()); + EXPECT_EQ(Decimal(-2), Encode(209, -2, kNegative).Ceil()); + EXPECT_EQ(Decimal(1), + Encode(UINT64_C(123456789012345678), -18, kPositive).Ceil()); +} + +TEST_F(DecimalTest, CeilingBigExponent) { + EXPECT_EQ(Encode(1, 1000, kPositive), Encode(1, 1000, kPositive).Ceil()); + EXPECT_EQ(Encode(1, 1000, kNegative), Encode(1, 1000, kNegative).Ceil()); +} + +TEST_F(DecimalTest, CeilingSmallExponent) { + EXPECT_EQ(Encode(1, 0, kPositive), Encode(1, -1000, kPositive).Ceil()); + EXPECT_EQ(Encode(0, 0, kNegative), Encode(1, -1000, kNegative).Ceil()); +} + +TEST_F(DecimalTest, CeilingSpecialValues) { + EXPECT_EQ(Decimal::Infinity(kPositive), Decimal::Infinity(kPositive).Ceil()); + EXPECT_EQ(Decimal::Infinity(kNegative), Decimal::Infinity(kNegative).Ceil()); + EXPECT_EQ(Decimal::Nan(), Decimal::Nan().Ceil()); +} + +TEST_F(DecimalTest, Compare) { + EXPECT_TRUE(Decimal(0) == Decimal(0)); + EXPECT_TRUE(Decimal(0) != Decimal(1)); + EXPECT_TRUE(Decimal(0) < Decimal(1)); + EXPECT_TRUE(Decimal(0) <= Decimal(0)); + EXPECT_TRUE(Decimal(0) > Decimal(-1)); + EXPECT_TRUE(Decimal(0) >= Decimal(0)); + + EXPECT_FALSE(Decimal(1) == Decimal(2)); + EXPECT_FALSE(Decimal(1) != Decimal(1)); + EXPECT_FALSE(Decimal(1) < Decimal(0)); + EXPECT_FALSE(Decimal(1) <= Decimal(0)); + EXPECT_FALSE(Decimal(1) > Decimal(2)); + EXPECT_FALSE(Decimal(1) >= Decimal(2)); +} + +TEST_F(DecimalTest, CompareBigExponent) { + EXPECT_TRUE(Encode(1, 1000, kPositive) == Encode(1, 1000, kPositive)); + EXPECT_FALSE(Encode(1, 1000, kPositive) != Encode(1, 1000, kPositive)); + EXPECT_FALSE(Encode(1, 1000, kPositive) < Encode(1, 1000, kPositive)); + EXPECT_TRUE(Encode(1, 1000, kPositive) <= Encode(1, 1000, kPositive)); + EXPECT_FALSE(Encode(1, 1000, kPositive) > Encode(1, 1000, kPositive)); + EXPECT_TRUE(Encode(1, 1000, kPositive) >= Encode(1, 1000, kPositive)); + + EXPECT_TRUE(Encode(1, 1000, kNegative) == Encode(1, 1000, kNegative)); + EXPECT_FALSE(Encode(1, 1000, kNegative) != Encode(1, 1000, kNegative)); + EXPECT_FALSE(Encode(1, 1000, kNegative) < Encode(1, 1000, kNegative)); + EXPECT_TRUE(Encode(1, 1000, kNegative) <= Encode(1, 1000, kNegative)); + EXPECT_FALSE(Encode(1, 1000, kNegative) > Encode(1, 1000, kNegative)); + EXPECT_TRUE(Encode(1, 1000, kNegative) >= Encode(1, 1000, kNegative)); + + EXPECT_FALSE(Encode(2, 1000, kPositive) == Encode(1, 1000, kPositive)); + EXPECT_TRUE(Encode(2, 1000, kPositive) != Encode(1, 1000, kPositive)); + EXPECT_FALSE(Encode(2, 1000, kPositive) < Encode(1, 1000, kPositive)); + EXPECT_FALSE(Encode(2, 1000, kPositive) <= Encode(1, 1000, kPositive)); + EXPECT_TRUE(Encode(2, 1000, kPositive) > Encode(1, 1000, kPositive)); + EXPECT_TRUE(Encode(2, 1000, kPositive) >= Encode(1, 1000, kPositive)); + + EXPECT_FALSE(Encode(2, 1000, kNegative) == Encode(1, 1000, kNegative)); + EXPECT_TRUE(Encode(2, 1000, kNegative) != Encode(1, 1000, kNegative)); + EXPECT_TRUE(Encode(2, 1000, kNegative) < Encode(1, 1000, kNegative)); + EXPECT_TRUE(Encode(2, 1000, kNegative) <= Encode(1, 1000, kNegative)); + EXPECT_FALSE(Encode(2, 1000, kNegative) > Encode(1, 1000, kNegative)); + EXPECT_FALSE(Encode(2, 1000, kNegative) >= Encode(1, 1000, kNegative)); +} + +TEST_F(DecimalTest, CompareSmallExponent) { + EXPECT_TRUE(Encode(1, -1000, kPositive) == Encode(1, -1000, kPositive)); + EXPECT_FALSE(Encode(1, -1000, kPositive) != Encode(1, -1000, kPositive)); + EXPECT_FALSE(Encode(1, -1000, kPositive) < Encode(1, -1000, kPositive)); + EXPECT_TRUE(Encode(1, -1000, kPositive) <= Encode(1, -1000, kPositive)); + EXPECT_FALSE(Encode(1, -1000, kPositive) > Encode(1, -1000, kPositive)); + EXPECT_TRUE(Encode(1, -1000, kPositive) >= Encode(1, -1000, kPositive)); + + EXPECT_TRUE(Encode(1, -1000, kNegative) == Encode(1, -1000, kNegative)); + EXPECT_FALSE(Encode(1, -1000, kNegative) != Encode(1, -1000, kNegative)); + EXPECT_FALSE(Encode(1, -1000, kNegative) < Encode(1, -1000, kNegative)); + EXPECT_TRUE(Encode(1, -1000, kNegative) <= Encode(1, -1000, kNegative)); + EXPECT_FALSE(Encode(1, -1000, kNegative) > Encode(1, -1000, kNegative)); + EXPECT_TRUE(Encode(1, -1000, kNegative) >= Encode(1, -1000, kNegative)); + + EXPECT_FALSE(Encode(2, -1000, kPositive) == Encode(1, -1000, kPositive)); + EXPECT_TRUE(Encode(2, -1000, kPositive) != Encode(1, -1000, kPositive)); + EXPECT_FALSE(Encode(2, -1000, kPositive) < Encode(1, -1000, kPositive)); + EXPECT_FALSE(Encode(2, -1000, kPositive) <= Encode(1, -1000, kPositive)); + EXPECT_TRUE(Encode(2, -1000, kPositive) > Encode(1, -1000, kPositive)); + EXPECT_TRUE(Encode(2, -1000, kPositive) >= Encode(1, -1000, kPositive)); + + EXPECT_FALSE(Encode(2, -1000, kNegative) == Encode(1, -1000, kNegative)); + EXPECT_TRUE(Encode(2, -1000, kNegative) != Encode(1, -1000, kNegative)); + EXPECT_TRUE(Encode(2, -1000, kNegative) < Encode(1, -1000, kNegative)); + EXPECT_TRUE(Encode(2, -1000, kNegative) <= Encode(1, -1000, kNegative)); + EXPECT_FALSE(Encode(2, -1000, kNegative) > Encode(1, -1000, kNegative)); + EXPECT_FALSE(Encode(2, -1000, kNegative) >= Encode(1, -1000, kNegative)); +} + +TEST_F(DecimalTest, CompareSpecialValues) { + const Decimal infinity(Decimal::Infinity(kPositive)); + const Decimal minus_infinity(Decimal::Infinity(kNegative)); + const Decimal na_n(Decimal::Nan()); + const Decimal zero(Decimal::Zero(kPositive)); + const Decimal minus_zero(Decimal::Zero(kNegative)); + const Decimal ten(10); + + EXPECT_TRUE(zero == zero); + EXPECT_FALSE(zero != zero); + EXPECT_FALSE(zero < zero); + EXPECT_TRUE(zero <= zero); + EXPECT_FALSE(zero > zero); + EXPECT_TRUE(zero >= zero); + + EXPECT_TRUE(zero == minus_zero); + EXPECT_FALSE(zero != minus_zero); + EXPECT_FALSE(zero < minus_zero); + EXPECT_TRUE(zero <= minus_zero); + EXPECT_FALSE(zero > minus_zero); + EXPECT_TRUE(zero >= minus_zero); + + EXPECT_TRUE(minus_zero == zero); + EXPECT_FALSE(minus_zero != zero); + EXPECT_FALSE(minus_zero < zero); + EXPECT_TRUE(minus_zero <= zero); + EXPECT_FALSE(minus_zero > zero); + EXPECT_TRUE(minus_zero >= zero); + + EXPECT_TRUE(minus_zero == minus_zero); + EXPECT_FALSE(minus_zero != minus_zero); + EXPECT_FALSE(minus_zero < minus_zero); + EXPECT_TRUE(minus_zero <= minus_zero); + EXPECT_FALSE(minus_zero > minus_zero); + EXPECT_TRUE(minus_zero >= minus_zero); + + EXPECT_TRUE(infinity == infinity); + EXPECT_FALSE(infinity != infinity); + EXPECT_FALSE(infinity < infinity); + EXPECT_TRUE(infinity <= infinity); + EXPECT_FALSE(infinity > infinity); + EXPECT_TRUE(infinity >= infinity); + + EXPECT_FALSE(infinity == ten); + EXPECT_TRUE(infinity != ten); + EXPECT_FALSE(infinity < ten); + EXPECT_FALSE(infinity <= ten); + EXPECT_TRUE(infinity > ten); + EXPECT_TRUE(infinity >= ten); + + EXPECT_FALSE(infinity == minus_infinity); + EXPECT_TRUE(infinity != minus_infinity); + EXPECT_FALSE(infinity < minus_infinity); + EXPECT_FALSE(infinity <= minus_infinity); + EXPECT_TRUE(infinity > minus_infinity); + EXPECT_TRUE(infinity >= minus_infinity); + + EXPECT_FALSE(infinity == na_n); + EXPECT_FALSE(infinity != na_n); + EXPECT_FALSE(infinity < na_n); + EXPECT_FALSE(infinity <= na_n); + EXPECT_FALSE(infinity > na_n); + EXPECT_FALSE(infinity >= na_n); + + EXPECT_FALSE(minus_infinity == infinity); + EXPECT_TRUE(minus_infinity != infinity); + EXPECT_TRUE(minus_infinity < infinity); + EXPECT_TRUE(minus_infinity <= infinity); + EXPECT_FALSE(minus_infinity > infinity); + EXPECT_FALSE(minus_infinity >= infinity); + + EXPECT_FALSE(minus_infinity == ten); + EXPECT_TRUE(minus_infinity != ten); + EXPECT_TRUE(minus_infinity < ten); + EXPECT_TRUE(minus_infinity <= ten); + EXPECT_FALSE(minus_infinity > ten); + EXPECT_FALSE(minus_infinity >= ten); + + EXPECT_TRUE(minus_infinity == minus_infinity); + EXPECT_FALSE(minus_infinity != minus_infinity); + EXPECT_FALSE(minus_infinity < minus_infinity); + EXPECT_TRUE(minus_infinity <= minus_infinity); + EXPECT_FALSE(minus_infinity > minus_infinity); + EXPECT_TRUE(minus_infinity >= minus_infinity); + + EXPECT_FALSE(minus_infinity == na_n); + EXPECT_FALSE(minus_infinity != na_n); + EXPECT_FALSE(minus_infinity < na_n); + EXPECT_FALSE(minus_infinity <= na_n); + EXPECT_FALSE(minus_infinity > na_n); + EXPECT_FALSE(minus_infinity >= na_n); + + EXPECT_FALSE(na_n == infinity); + EXPECT_FALSE(na_n != infinity); + EXPECT_FALSE(na_n < infinity); + EXPECT_FALSE(na_n <= infinity); + EXPECT_FALSE(na_n > infinity); + EXPECT_FALSE(na_n >= infinity); + + EXPECT_FALSE(na_n == ten); + EXPECT_FALSE(na_n != ten); + EXPECT_FALSE(na_n < ten); + EXPECT_FALSE(na_n <= ten); + EXPECT_FALSE(na_n > ten); + EXPECT_FALSE(na_n >= ten); + + EXPECT_FALSE(na_n == minus_infinity); + EXPECT_FALSE(na_n != minus_infinity); + EXPECT_FALSE(na_n < minus_infinity); + EXPECT_FALSE(na_n <= minus_infinity); + EXPECT_FALSE(na_n > minus_infinity); + EXPECT_FALSE(na_n >= minus_infinity); + + EXPECT_TRUE(na_n == na_n); + EXPECT_FALSE(na_n != na_n); + EXPECT_FALSE(na_n < na_n); + EXPECT_TRUE(na_n <= na_n); + EXPECT_FALSE(na_n > na_n); + EXPECT_TRUE(na_n >= na_n); +} + +TEST_F(DecimalTest, Constructor) { + EXPECT_DECIMAL_ENCODED_DATA_EQ(0u, 0, kPositive, Encode(0, 0, kPositive)); + EXPECT_DECIMAL_ENCODED_DATA_EQ(0u, 0, kNegative, Encode(0, 0, kNegative)); + EXPECT_DECIMAL_ENCODED_DATA_EQ(1u, 0, kPositive, Encode(1, 0, kPositive)); + EXPECT_DECIMAL_ENCODED_DATA_EQ(1u, 0, kNegative, Encode(1, 0, kNegative)); + EXPECT_DECIMAL_ENCODED_DATA_EQ(1u, 1022, kPositive, + Encode(1, 1022, kPositive)); + EXPECT_DECIMAL_ENCODED_DATA_EQ(1u, 1022, kNegative, + Encode(1, 1022, kNegative)); + EXPECT_DECIMAL_ENCODED_DATA_EQ(1u, 1023, kPositive, + Encode(1, 1023, kPositive)); + EXPECT_DECIMAL_ENCODED_DATA_EQ(1u, 1023, kNegative, + Encode(1, 1023, kNegative)); + EXPECT_TRUE(Encode(1, 2000, kPositive).IsInfinity()); + EXPECT_TRUE(Encode(1, 2000, kNegative).IsInfinity()); + EXPECT_DECIMAL_ENCODED_DATA_EQ(0u, 0, kPositive, Encode(1, -2000, kPositive)); + EXPECT_DECIMAL_ENCODED_DATA_EQ(0u, 0, kNegative, Encode(1, -2000, kNegative)); + EXPECT_DECIMAL_ENCODED_DATA_EQ( + UINT64_C(99999999999999998), 0, kPositive, + Encode(UINT64_C(99999999999999998), 0, kPositive)); + EXPECT_DECIMAL_ENCODED_DATA_EQ( + UINT64_C(99999999999999998), 0, kNegative, + Encode(UINT64_C(99999999999999998), 0, kNegative)); + EXPECT_DECIMAL_ENCODED_DATA_EQ( + UINT64_C(99999999999999999), 0, kPositive, + Encode(UINT64_C(99999999999999999), 0, kPositive)); + EXPECT_DECIMAL_ENCODED_DATA_EQ( + UINT64_C(99999999999999999), 0, kNegative, + Encode(UINT64_C(99999999999999999), 0, kNegative)); + EXPECT_DECIMAL_ENCODED_DATA_EQ( + UINT64_C(100000000000000000), 0, kPositive, + Encode(UINT64_C(100000000000000000), 0, kPositive)); + EXPECT_DECIMAL_ENCODED_DATA_EQ( + UINT64_C(100000000000000000), 0, kNegative, + Encode(UINT64_C(100000000000000000), 0, kNegative)); +} + +TEST_F(DecimalTest, Division) { + EXPECT_EQ(Encode(0, 0, kPositive), Decimal(0) / Decimal(1)); + EXPECT_EQ(Encode(2, 0, kNegative), Decimal(2) / Decimal(-1)); + EXPECT_EQ(Encode(5, -1, kNegative), Decimal(-1) / Decimal(2)); + EXPECT_EQ(Encode(99, 0, kPositive), Decimal(99) / Decimal(1)); + EXPECT_EQ(Decimal(1), Decimal(-50) / Decimal(-50)); + EXPECT_EQ(Encode(UINT64_C(333333333333333333), -18, kPositive), + Decimal(1) / Decimal(3)); + EXPECT_EQ(Encode(UINT64_C(12345678901234), -1, kPositive), + Encode(UINT64_C(12345678901234), 0, kPositive) / Decimal(10)); + EXPECT_EQ(Encode(UINT64_C(500005000050000500), -18, kPositive), + Decimal(50000) / Decimal(99999)); +} + +TEST_F(DecimalTest, DivisionBigExponent) { + EXPECT_EQ(Encode(1, 1022, kPositive), + Encode(1, 1022, kPositive) / Encode(1, 0, kPositive)); + EXPECT_EQ(Encode(1, 0, kPositive), + Encode(1, 1022, kPositive) / Encode(1, 1022, kPositive)); + EXPECT_EQ(Decimal::Infinity(kPositive), + Encode(1, 1022, kPositive) / Encode(1, -1000, kPositive)); +} + +TEST_F(DecimalTest, DivisionSmallExponent) { + EXPECT_EQ(Encode(1, -1022, kPositive), + Encode(1, -1022, kPositive) / Encode(1, 0, kPositive)); + EXPECT_EQ(Encode(1, 0, kPositive), + Encode(1, -1022, kPositive) / Encode(1, -1022, kPositive)); +} + +TEST_F(DecimalTest, DivisionSpecialValues) { + const Decimal infinity(Decimal::Infinity(kPositive)); + const Decimal minus_infinity(Decimal::Infinity(kNegative)); + const Decimal na_n(Decimal::Nan()); + const Decimal zero(Decimal::Zero(kPositive)); + const Decimal minus_zero(Decimal::Zero(kNegative)); + const Decimal ten(10); + const Decimal minus_ten(-10); + + EXPECT_EQ(na_n, zero / zero); + EXPECT_EQ(na_n, zero / minus_zero); + EXPECT_EQ(na_n, minus_zero / zero); + EXPECT_EQ(na_n, minus_zero / minus_zero); + + EXPECT_EQ(infinity, ten / zero); + EXPECT_EQ(minus_infinity, ten / minus_zero); + EXPECT_EQ(minus_infinity, minus_ten / zero); + EXPECT_EQ(infinity, minus_ten / minus_zero); + + EXPECT_EQ(infinity, infinity / zero); + EXPECT_EQ(minus_infinity, infinity / minus_zero); + EXPECT_EQ(minus_infinity, minus_infinity / zero); + EXPECT_EQ(infinity, minus_infinity / minus_zero); + + EXPECT_EQ(na_n, infinity / infinity); + EXPECT_EQ(na_n, infinity / minus_infinity); + EXPECT_EQ(na_n, minus_infinity / infinity); + EXPECT_EQ(na_n, minus_infinity / minus_infinity); + + EXPECT_EQ(zero, ten / infinity); + EXPECT_EQ(minus_zero, ten / minus_infinity); + EXPECT_EQ(minus_zero, minus_ten / infinity); + EXPECT_EQ(zero, minus_ten / minus_infinity); + + EXPECT_EQ(na_n, na_n / na_n); + EXPECT_EQ(na_n, na_n / ten); + EXPECT_EQ(na_n, ten / na_n); + + EXPECT_EQ(na_n, na_n / infinity); + EXPECT_EQ(na_n, na_n / minus_infinity); + EXPECT_EQ(na_n, infinity / na_n); + EXPECT_EQ(na_n, minus_infinity / na_n); +} + +TEST_F(DecimalTest, EncodedData) { + EXPECT_EQ(Encode(0, 0, kPositive), Encode(0, 0, kPositive)); + EXPECT_EQ(Encode(0, 0, kNegative), Encode(0, 0, kNegative)); + EXPECT_EQ(Decimal(1), Decimal(1)); + EXPECT_EQ(Encode(1, 0, kNegative), Encode(1, 0, kNegative)); + EXPECT_EQ(Decimal::Infinity(kPositive), Encode(1, 2000, kPositive)); + EXPECT_EQ(Decimal::Zero(kPositive), Encode(1, -2000, kPositive)); +} + +TEST_F(DecimalTest, Floor) { + EXPECT_EQ(Decimal(1), Decimal(1).Floor()); + EXPECT_EQ(Decimal(0), Encode(1, -10, kPositive).Floor()); + EXPECT_EQ(Decimal(1), Encode(11, -1, kPositive).Floor()); + EXPECT_EQ(Decimal(1), Encode(13, -1, kPositive).Floor()); + EXPECT_EQ(Decimal(1), Encode(15, -1, kPositive).Floor()); + EXPECT_EQ(Decimal(1), Encode(19, -1, kPositive).Floor()); + EXPECT_EQ(Decimal(1), Encode(193332, -5, kPositive).Floor()); + EXPECT_EQ(Decimal(12), Encode(12002, -3, kPositive).Floor()); + + EXPECT_EQ(Decimal(-1), Decimal(-1).Floor()); + EXPECT_EQ(Decimal(-1), Encode(1, -10, kNegative).Floor()); + EXPECT_EQ(Decimal(-2), Encode(11, -1, kNegative).Floor()); + EXPECT_EQ(Decimal(-2), Encode(13, -1, kNegative).Floor()); + EXPECT_EQ(Decimal(-2), Encode(15, -1, kNegative).Floor()); + EXPECT_EQ(Decimal(-2), Encode(19, -1, kNegative).Floor()); + EXPECT_EQ(Decimal(-2), Encode(193332, -5, kNegative).Floor()); + EXPECT_EQ(Decimal(-13), Encode(12002, -3, kNegative).Floor()); + + // crbug.com/572769 + EXPECT_EQ(Decimal(-1), Encode(992971299197409433, -18, kNegative).Floor()); +} + +TEST_F(DecimalTest, FloorBigExponent) { + EXPECT_EQ(Encode(1, 1000, kPositive), Encode(1, 1000, kPositive).Floor()); + EXPECT_EQ(Encode(1, 1000, kNegative), Encode(1, 1000, kNegative).Floor()); +} + +TEST_F(DecimalTest, FloorSmallExponent) { + EXPECT_EQ(Encode(0, 0, kPositive), Encode(1, -1000, kPositive).Floor()); + EXPECT_EQ(Encode(1, 0, kNegative), Encode(1, -1000, kNegative).Floor()); +} + +TEST_F(DecimalTest, FloorSpecialValues) { + EXPECT_EQ(Decimal::Infinity(kPositive), Decimal::Infinity(kPositive).Floor()); + EXPECT_EQ(Decimal::Infinity(kNegative), Decimal::Infinity(kNegative).Floor()); + EXPECT_EQ(Decimal::Nan(), Decimal::Nan().Floor()); +} + +TEST_F(DecimalTest, FromDouble) { + EXPECT_EQ(Encode(0, 0, kPositive), Decimal::FromDouble(0.0)); + EXPECT_EQ(Encode(0, 0, kNegative), Decimal::FromDouble(-0.0)); + EXPECT_EQ(Encode(1, 0, kPositive), Decimal::FromDouble(1)); + EXPECT_EQ(Encode(1, 0, kNegative), Decimal::FromDouble(-1)); + EXPECT_EQ(Encode(123, 0, kPositive), Decimal::FromDouble(123)); + EXPECT_EQ(Encode(123, 0, kNegative), Decimal::FromDouble(-123)); + EXPECT_EQ(Encode(1, -1, kPositive), Decimal::FromDouble(0.1)); + EXPECT_EQ(Encode(1, -1, kNegative), Decimal::FromDouble(-0.1)); +} + +TEST_F(DecimalTest, FromDoubleLimits) { + EXPECT_EQ(Encode(UINT64_C(2220446049250313), -31, kPositive), + Decimal::FromDouble(std::numeric_limits<double>::epsilon())); + EXPECT_EQ(Encode(UINT64_C(2220446049250313), -31, kNegative), + Decimal::FromDouble(-std::numeric_limits<double>::epsilon())); + EXPECT_EQ(Encode(UINT64_C(17976931348623157), 292, kPositive), + Decimal::FromDouble(std::numeric_limits<double>::max())); + EXPECT_EQ(Encode(UINT64_C(17976931348623157), 292, kNegative), + Decimal::FromDouble(-std::numeric_limits<double>::max())); + EXPECT_EQ(Encode(UINT64_C(22250738585072014), -324, kPositive), + Decimal::FromDouble(std::numeric_limits<double>::min())); + EXPECT_EQ(Encode(UINT64_C(22250738585072014), -324, kNegative), + Decimal::FromDouble(-std::numeric_limits<double>::min())); + EXPECT_TRUE(Decimal::FromDouble(std::numeric_limits<double>::infinity()) + .IsInfinity()); + EXPECT_TRUE(Decimal::FromDouble(-std::numeric_limits<double>::infinity()) + .IsInfinity()); + EXPECT_TRUE( + Decimal::FromDouble(std::numeric_limits<double>::quiet_NaN()).IsNaN()); + EXPECT_TRUE( + Decimal::FromDouble(-std::numeric_limits<double>::quiet_NaN()).IsNaN()); +} + +TEST_F(DecimalTest, FromInt32) { + EXPECT_EQ(Encode(0, 0, kPositive), Decimal(0)); + EXPECT_EQ(Encode(1, 0, kPositive), Decimal(1)); + EXPECT_EQ(Encode(1, 0, kNegative), Decimal(-1)); + EXPECT_EQ(Encode(100, 0, kPositive), Decimal(100)); + EXPECT_EQ(Encode(100, 0, kNegative), Decimal(-100)); + EXPECT_EQ(Encode(0x7FFFFFFF, 0, kPositive), + Decimal(std::numeric_limits<int32_t>::max())); + EXPECT_EQ(Encode(0x80000000u, 0, kNegative), + Decimal(std::numeric_limits<int32_t>::min())); +} + +TEST_F(DecimalTest, FromString) { + EXPECT_EQ(Encode(0, 0, kPositive), FromString("0")); + EXPECT_EQ(Encode(0, 0, kNegative), FromString("-0")); + EXPECT_EQ(Decimal(1), FromString("1")); + EXPECT_EQ(Encode(1, 0, kNegative), FromString("-1")); + EXPECT_EQ(Decimal(1), FromString("01")); + EXPECT_EQ(Encode(3, 0, kPositive), FromString("+3")); + EXPECT_EQ(Encode(0, 3, kPositive), FromString("0E3")); + EXPECT_EQ(Encode(5, -1, kPositive), FromString(".5")); + EXPECT_EQ(Encode(100, 0, kPositive), FromString("100")); + EXPECT_EQ(Encode(100, 0, kNegative), FromString("-100")); + EXPECT_EQ(Encode(123, -2, kPositive), FromString("1.23")); + EXPECT_EQ(Encode(123, -2, kNegative), FromString("-1.23")); + EXPECT_EQ(Encode(123, 8, kPositive), FromString("1.23E10")); + EXPECT_EQ(Encode(123, 8, kNegative), FromString("-1.23E10")); + EXPECT_EQ(Encode(123, 8, kPositive), FromString("1.23E+10")); + EXPECT_EQ(Encode(123, 8, kNegative), FromString("-1.23E+10")); + EXPECT_EQ(Encode(123, -12, kPositive), FromString("1.23E-10")); + EXPECT_EQ(Encode(123, -12, kNegative), FromString("-1.23E-10")); + EXPECT_EQ(Encode(5, -7, kPositive), FromString("0.0000005")); + EXPECT_EQ(Encode(0, 0, kPositive), FromString("0e9999")); + EXPECT_EQ(Encode(123, -3, kPositive), FromString("0.123")); + EXPECT_EQ(Encode(0, -2, kPositive), FromString("00.00")); + EXPECT_EQ(Encode(1, 2, kPositive), FromString("1E2")); + EXPECT_EQ(Decimal::Infinity(kPositive), FromString("1E20000")); + EXPECT_EQ(Decimal::Zero(kPositive), FromString("1E-20000")); + EXPECT_EQ(Encode(1000, 1023, kPositive), FromString("1E1026")); + EXPECT_EQ(Decimal::Zero(kPositive), FromString("1E-1026")); + EXPECT_EQ(Decimal::Infinity(kPositive), FromString("1234567890E1036")); + + // 2^1024 + const uint64_t kLeadingDigitsOf2PowerOf1024 = UINT64_C(17976931348623159); + EXPECT_EQ(Encode(kLeadingDigitsOf2PowerOf1024, 292, kPositive), + FromString("1797693134862315907729305190789024733617976978942306572" + "7343008115773267580550096313270847732240753602112011387" + "9871393357658789768814416622492847430639474124377767893" + "4248654852763022196012460941194530829520850057688381506" + "8234246288147391311054082723716335051068458629823994724" + "5938479716304835356329624224137216")); +} + +// These strings are look like proper number, but we don't accept them. +TEST_F(DecimalTest, FromStringLikeNumber) { + EXPECT_EQ(Decimal::Nan(), FromString(" 123 ")); + EXPECT_EQ(Decimal::Nan(), FromString("1,234")); +} + +// fromString doesn't support infinity and NaN. +TEST_F(DecimalTest, FromStringSpecialValues) { + EXPECT_EQ(Decimal::Nan(), FromString("INF")); + EXPECT_EQ(Decimal::Nan(), FromString("Infinity")); + EXPECT_EQ(Decimal::Nan(), FromString("infinity")); + EXPECT_EQ(Decimal::Nan(), FromString("+Infinity")); + EXPECT_EQ(Decimal::Nan(), FromString("+infinity")); + EXPECT_EQ(Decimal::Nan(), FromString("-Infinity")); + EXPECT_EQ(Decimal::Nan(), FromString("-infinity")); + EXPECT_EQ(Decimal::Nan(), FromString("NaN")); + EXPECT_EQ(Decimal::Nan(), FromString("nan")); + EXPECT_EQ(Decimal::Nan(), FromString("+NaN")); + EXPECT_EQ(Decimal::Nan(), FromString("+nan")); + EXPECT_EQ(Decimal::Nan(), FromString("-NaN")); + EXPECT_EQ(Decimal::Nan(), FromString("-nan")); +} + +TEST_F(DecimalTest, fromStringTruncated) { + EXPECT_EQ(Decimal::Nan(), FromString("x")); + EXPECT_EQ(Decimal::Nan(), FromString("0.")); + EXPECT_EQ(Decimal::Nan(), FromString("1x")); + + EXPECT_EQ(Decimal::Nan(), FromString("1Ex")); + EXPECT_EQ(Decimal::Nan(), FromString("1E2x")); + EXPECT_EQ(Decimal::Nan(), FromString("1E+x")); +} + +TEST_F(DecimalTest, Multiplication) { + EXPECT_EQ(Encode(0, 0, kPositive), Decimal(0) * Decimal(0)); + EXPECT_EQ(Encode(2, 0, kNegative), Decimal(2) * Decimal(-1)); + EXPECT_EQ(Encode(2, 0, kNegative), Decimal(-1) * Decimal(2)); + EXPECT_EQ(Encode(99, 0, kPositive), Decimal(99) * Decimal(1)); + EXPECT_EQ(Encode(2500, 0, kPositive), Decimal(-50) * Decimal(-50)); + EXPECT_EQ(Encode(1, 21, kPositive), + Encode(UINT64_C(10000000000), 0, kPositive) * + Encode(UINT64_C(100000000000), 0, kPositive)); +} + +TEST_F(DecimalTest, MultiplicationBigExponent) { + EXPECT_EQ(Encode(1, 1022, kPositive), + Encode(1, 1022, kPositive) * Encode(1, 0, kPositive)); + EXPECT_EQ(Decimal::Infinity(kPositive), + Encode(1, 1022, kPositive) * Encode(1, 1022, kPositive)); + EXPECT_EQ(Encode(1, 22, kPositive), + Encode(1, 1022, kPositive) * Encode(1, -1000, kPositive)); +} + +TEST_F(DecimalTest, MultiplicationSmallExponent) { + EXPECT_EQ(Encode(1, -1022, kPositive), + Encode(1, -1022, kPositive) * Encode(1, 0, kPositive)); + EXPECT_EQ(Encode(0, 0, kPositive), + Encode(1, -1022, kPositive) * Encode(1, -1022, kPositive)); +} + +TEST_F(DecimalTest, MultiplicationSpecialValues) { + const Decimal infinity(Decimal::Infinity(kPositive)); + const Decimal minus_infinity(Decimal::Infinity(kNegative)); + const Decimal na_n(Decimal::Nan()); + const Decimal ten(10); + const Decimal minus_ten(-10); + const Decimal zero(Decimal::Zero(kPositive)); + const Decimal minus_zero(Decimal::Zero(kNegative)); + + EXPECT_EQ(infinity, infinity * infinity); + EXPECT_EQ(minus_infinity, infinity * minus_infinity); + EXPECT_EQ(minus_infinity, minus_infinity * infinity); + EXPECT_EQ(infinity, minus_infinity * minus_infinity); + + EXPECT_EQ(na_n, infinity * zero); + EXPECT_EQ(na_n, zero * minus_infinity); + EXPECT_EQ(na_n, minus_infinity * zero); + EXPECT_EQ(na_n, minus_infinity * zero); + + EXPECT_EQ(na_n, infinity * minus_zero); + EXPECT_EQ(na_n, minus_zero * minus_infinity); + EXPECT_EQ(na_n, minus_infinity * minus_zero); + EXPECT_EQ(na_n, minus_infinity * minus_zero); + + EXPECT_EQ(infinity, infinity * ten); + EXPECT_EQ(infinity, ten * infinity); + EXPECT_EQ(minus_infinity, minus_infinity * ten); + EXPECT_EQ(minus_infinity, ten * minus_infinity); + + EXPECT_EQ(minus_infinity, infinity * minus_ten); + EXPECT_EQ(minus_infinity, minus_ten * infinity); + EXPECT_EQ(infinity, minus_infinity * minus_ten); + EXPECT_EQ(infinity, minus_ten * minus_infinity); + + EXPECT_EQ(na_n, na_n * na_n); + EXPECT_EQ(na_n, na_n * ten); + EXPECT_EQ(na_n, ten * na_n); + + EXPECT_EQ(na_n, na_n * infinity); + EXPECT_EQ(na_n, na_n * minus_infinity); + EXPECT_EQ(na_n, infinity * na_n); + EXPECT_EQ(na_n, minus_infinity * na_n); +} + +TEST_F(DecimalTest, Negate) { + EXPECT_EQ(Encode(0, 0, kNegative), -Encode(0, 0, kPositive)); + EXPECT_EQ(Encode(0, 0, kPositive), -Encode(0, 0, kNegative)); + + EXPECT_EQ(Encode(0, 10, kNegative), -Encode(0, 10, kPositive)); + EXPECT_EQ(Encode(0, 10, kPositive), -Encode(0, 10, kNegative)); + + EXPECT_EQ(Encode(0, -10, kNegative), -Encode(0, -10, kPositive)); + EXPECT_EQ(Encode(0, -10, kPositive), -Encode(0, -10, kNegative)); + + EXPECT_EQ(Encode(1, 0, kNegative), -Encode(1, 0, kPositive)); + EXPECT_EQ(Encode(1, 0, kPositive), -Encode(1, 0, kNegative)); + + EXPECT_EQ(Encode(1, 10, kNegative), -Encode(1, 10, kPositive)); + EXPECT_EQ(Encode(1, 10, kPositive), -Encode(1, 10, kNegative)); + + EXPECT_EQ(Encode(1, -10, kNegative), -Encode(1, -10, kPositive)); + EXPECT_EQ(Encode(1, -10, kPositive), -Encode(1, -10, kNegative)); +} + +TEST_F(DecimalTest, NegateBigExponent) { + EXPECT_EQ(Encode(1, 1000, kNegative), -Encode(1, 1000, kPositive)); + EXPECT_EQ(Encode(1, 1000, kPositive), -Encode(1, 1000, kNegative)); +} + +TEST_F(DecimalTest, NegateSmallExponent) { + EXPECT_EQ(Encode(1, -1000, kNegative), -Encode(1, -1000, kPositive)); + EXPECT_EQ(Encode(1, -1000, kPositive), -Encode(1, -1000, kNegative)); +} + +TEST_F(DecimalTest, NegateSpecialValues) { + EXPECT_EQ(Decimal::Infinity(kNegative), -Decimal::Infinity(kPositive)); + EXPECT_EQ(Decimal::Infinity(kPositive), -Decimal::Infinity(kNegative)); + EXPECT_EQ(Decimal::Nan(), -Decimal::Nan()); +} + +TEST_F(DecimalTest, Predicates) { + EXPECT_TRUE(Decimal::Zero(kPositive).IsFinite()); + EXPECT_FALSE(Decimal::Zero(kPositive).IsInfinity()); + EXPECT_FALSE(Decimal::Zero(kPositive).IsNaN()); + EXPECT_TRUE(Decimal::Zero(kPositive).IsPositive()); + EXPECT_FALSE(Decimal::Zero(kPositive).IsNegative()); + EXPECT_FALSE(Decimal::Zero(kPositive).IsSpecial()); + EXPECT_TRUE(Decimal::Zero(kPositive).IsZero()); + + EXPECT_TRUE(Decimal::Zero(kNegative).IsFinite()); + EXPECT_FALSE(Decimal::Zero(kNegative).IsInfinity()); + EXPECT_FALSE(Decimal::Zero(kNegative).IsNaN()); + EXPECT_FALSE(Decimal::Zero(kNegative).IsPositive()); + EXPECT_TRUE(Decimal::Zero(kNegative).IsNegative()); + EXPECT_FALSE(Decimal::Zero(kNegative).IsSpecial()); + EXPECT_TRUE(Decimal::Zero(kNegative).IsZero()); + + EXPECT_TRUE(Decimal(123).IsFinite()); + EXPECT_FALSE(Decimal(123).IsInfinity()); + EXPECT_FALSE(Decimal(123).IsNaN()); + EXPECT_TRUE(Decimal(123).IsPositive()); + EXPECT_FALSE(Decimal(123).IsNegative()); + EXPECT_FALSE(Decimal(123).IsSpecial()); + EXPECT_FALSE(Decimal(123).IsZero()); + + EXPECT_TRUE(Decimal(-123).IsFinite()); + EXPECT_FALSE(Decimal(-123).IsInfinity()); + EXPECT_FALSE(Decimal(-123).IsNaN()); + EXPECT_FALSE(Decimal(-123).IsPositive()); + EXPECT_TRUE(Decimal(-123).IsNegative()); + EXPECT_FALSE(Decimal(-123).IsSpecial()); + EXPECT_FALSE(Decimal(-123).IsZero()); +} + +TEST_F(DecimalTest, PredicatesSpecialValues) { + EXPECT_FALSE(Decimal::Infinity(kPositive).IsFinite()); + EXPECT_TRUE(Decimal::Infinity(kPositive).IsInfinity()); + EXPECT_FALSE(Decimal::Infinity(kPositive).IsNaN()); + EXPECT_TRUE(Decimal::Infinity(kPositive).IsPositive()); + EXPECT_FALSE(Decimal::Infinity(kPositive).IsNegative()); + EXPECT_TRUE(Decimal::Infinity(kPositive).IsSpecial()); + EXPECT_FALSE(Decimal::Infinity(kPositive).IsZero()); + + EXPECT_FALSE(Decimal::Infinity(kNegative).IsFinite()); + EXPECT_TRUE(Decimal::Infinity(kNegative).IsInfinity()); + EXPECT_FALSE(Decimal::Infinity(kNegative).IsNaN()); + EXPECT_FALSE(Decimal::Infinity(kNegative).IsPositive()); + EXPECT_TRUE(Decimal::Infinity(kNegative).IsNegative()); + EXPECT_TRUE(Decimal::Infinity(kNegative).IsSpecial()); + EXPECT_FALSE(Decimal::Infinity(kNegative).IsZero()); + + EXPECT_FALSE(Decimal::Nan().IsFinite()); + EXPECT_FALSE(Decimal::Nan().IsInfinity()); + EXPECT_TRUE(Decimal::Nan().IsNaN()); + EXPECT_TRUE(Decimal::Nan().IsSpecial()); + EXPECT_FALSE(Decimal::Nan().IsZero()); +} + +// LayoutTests/fast/forms/number/number-stepup-stepdown-from-renderer +TEST_F(DecimalTest, RealWorldExampleNumberStepUpStepDownFromRenderer) { + EXPECT_DECIMAL_STREQ("10", StepDown("0", "100", "10", "19", 1)); + EXPECT_DECIMAL_STREQ("90", StepUp("0", "99", "10", "89", 1)); + EXPECT_DECIMAL_STREQ( + "1", StepUp("0", "1", "0.33333333333333333", "0", 3)); // step=1/3 + EXPECT_DECIMAL_STREQ("0.01", StepUp("0", "0.01", "0.0033333333333333333", "0", + 3)); // step=1/300 + EXPECT_DECIMAL_STREQ( + "1", StepUp("0", "1", "0.003921568627450980", "0", 255)); // step=1/255 + EXPECT_DECIMAL_STREQ("1", StepUp("0", "1", "0.1", "0", 10)); +} + +TEST_F(DecimalTest, RealWorldExampleNumberStepUpStepDownFromRendererRounding) { + EXPECT_DECIMAL_STREQ("5.015", StepUp("0", "100", "0.005", "5.005", 2)); + EXPECT_DECIMAL_STREQ("5.06", StepUp("0", "100", "0.005", "5.005", 11)); + EXPECT_DECIMAL_STREQ("5.065", StepUp("0", "100", "0.005", "5.005", 12)); + + EXPECT_DECIMAL_STREQ("5.015", StepUp("4", "9", "0.005", "5.005", 2)); + EXPECT_DECIMAL_STREQ("5.06", StepUp("4", "9", "0.005", "5.005", 11)); + EXPECT_DECIMAL_STREQ("5.065", StepUp("4", "9", "0.005", "5.005", 12)); +} + +TEST_F(DecimalTest, RealWorldExampleRangeStepUpStepDown) { + EXPECT_DECIMAL_STREQ("1e+38", StepUp("0", "1E38", "1", "1E38", 9)); + EXPECT_DECIMAL_STREQ("1e+38", StepDown("0", "1E38", "1", "1E38", 9)); +} + +TEST_F(DecimalTest, Remainder) { + EXPECT_EQ(Encode(21, -1, kPositive), Encode(21, -1, kPositive).Remainder(3)); + EXPECT_EQ(Decimal(1), Decimal(10).Remainder(3)); + EXPECT_EQ(Decimal(1), Decimal(10).Remainder(-3)); + EXPECT_EQ(Encode(1, 0, kNegative), Decimal(-10).Remainder(3)); + EXPECT_EQ(Decimal(-1), Decimal(-10).Remainder(-3)); + EXPECT_EQ(Encode(2, -1, kPositive), Encode(102, -1, kPositive).Remainder(1)); + EXPECT_EQ(Encode(1, -1, kPositive), + Decimal(10).Remainder(Encode(3, -1, kPositive))); + EXPECT_EQ(Decimal(1), + Encode(36, -1, kPositive).Remainder(Encode(13, -1, kPositive))); + EXPECT_EQ(Encode(1, 86, kPositive), + (Encode(1234, 100, kPositive).Remainder(Decimal(3)))); + EXPECT_EQ(Decimal(500), (Decimal(500).Remainder(1000))); + EXPECT_EQ(Decimal(-500), (Decimal(-500).Remainder(1000))); +} + +TEST_F(DecimalTest, RemainderBigExponent) { + EXPECT_EQ(Encode(0, 1022, kPositive), + Encode(1, 1022, kPositive).Remainder(Encode(1, 0, kPositive))); + EXPECT_EQ(Encode(0, 1022, kPositive), + Encode(1, 1022, kPositive).Remainder(Encode(1, 1022, kPositive))); + EXPECT_EQ(Decimal::Infinity(kPositive), + Encode(1, 1022, kPositive).Remainder(Encode(1, -1000, kPositive))); +} + +TEST_F(DecimalTest, RemainderSmallExponent) { + EXPECT_EQ(Encode(1, -1022, kPositive), + Encode(1, -1022, kPositive).Remainder(Encode(1, 0, kPositive))); + EXPECT_EQ(Encode(0, -1022, kPositive), + Encode(1, -1022, kPositive).Remainder(Encode(1, -1022, kPositive))); +} + +TEST_F(DecimalTest, RemainderSpecialValues) { + EXPECT_EQ(Decimal::Infinity(kPositive), + Decimal::Infinity(kPositive).Remainder(1)); + EXPECT_EQ(Decimal::Infinity(kNegative), + Decimal::Infinity(kNegative).Remainder(1)); + EXPECT_EQ(Decimal::Nan(), Decimal::Nan().Remainder(1)); + + EXPECT_EQ(Decimal::Infinity(kNegative), + Decimal::Infinity(kPositive).Remainder(-1)); + EXPECT_EQ(Decimal::Infinity(kPositive), + Decimal::Infinity(kNegative).Remainder(-1)); + EXPECT_EQ(Decimal::Nan(), Decimal::Nan().Remainder(-1)); + + EXPECT_EQ(Decimal::Infinity(kPositive), + Decimal::Infinity(kPositive).Remainder(3)); + EXPECT_EQ(Decimal::Infinity(kNegative), + Decimal::Infinity(kNegative).Remainder(3)); + EXPECT_EQ(Decimal::Nan(), Decimal::Nan().Remainder(3)); + + EXPECT_EQ(Decimal::Infinity(kNegative), + Decimal::Infinity(kPositive).Remainder(-1)); + EXPECT_EQ(Decimal::Infinity(kPositive), + Decimal::Infinity(kNegative).Remainder(-1)); + EXPECT_EQ(Decimal::Nan(), Decimal::Nan().Remainder(-1)); + + EXPECT_EQ(Decimal::Nan(), Decimal(1).Remainder(Decimal::Infinity(kPositive))); + EXPECT_EQ(Decimal::Nan(), Decimal(1).Remainder(Decimal::Infinity(kNegative))); + EXPECT_EQ(Decimal::Nan(), Decimal(1).Remainder(Decimal::Nan())); +} + +TEST_F(DecimalTest, Round) { + EXPECT_EQ(Decimal(1), (Decimal(9) / Decimal(10)).Round()); + EXPECT_EQ(Decimal(25), (Decimal(5) / FromString("0.200")).Round()); + EXPECT_EQ(Decimal(3), (Decimal(5) / Decimal(2)).Round()); + EXPECT_EQ(Decimal(1), (Decimal(2) / Decimal(3)).Round()); + EXPECT_EQ(Decimal(3), (Decimal(10) / Decimal(3)).Round()); + EXPECT_EQ(Decimal(3), (Decimal(1) / FromString("0.3")).Round()); + EXPECT_EQ(Decimal(10), (Decimal(1) / FromString("0.1")).Round()); + EXPECT_EQ(Decimal(5), (Decimal(1) / FromString("0.2")).Round()); + EXPECT_EQ(Decimal(10), (FromString("10.2") / 1).Round()); + EXPECT_EQ(Encode(1234, 100, kPositive), Encode(1234, 100, kPositive).Round()); + + EXPECT_EQ(Decimal(2), Encode(190002, -5, kPositive).Round()); + EXPECT_EQ(Decimal(2), Encode(150002, -5, kPositive).Round()); + EXPECT_EQ(Decimal(2), Encode(150000, -5, kPositive).Round()); + EXPECT_EQ(Decimal(12), Encode(12492, -3, kPositive).Round()); + EXPECT_EQ(Decimal(13), Encode(12502, -3, kPositive).Round()); + + EXPECT_EQ(Decimal(-2), Encode(190002, -5, kNegative).Round()); + EXPECT_EQ(Decimal(-2), Encode(150002, -5, kNegative).Round()); + EXPECT_EQ(Decimal(-2), Encode(150000, -5, kNegative).Round()); + EXPECT_EQ(Decimal(-12), Encode(12492, -3, kNegative).Round()); + EXPECT_EQ(Decimal(-13), Encode(12502, -3, kNegative).Round()); +} + +TEST_F(DecimalTest, RoundSpecialValues) { + EXPECT_EQ(Decimal::Infinity(kPositive), Decimal::Infinity(kPositive).Round()); + EXPECT_EQ(Decimal::Infinity(kNegative), Decimal::Infinity(kNegative).Round()); + EXPECT_EQ(Decimal::Nan(), Decimal::Nan().Round()); +} + +TEST_F(DecimalTest, Subtract) { + EXPECT_EQ(Encode(0, 0, kPositive), Decimal(0) - Decimal(0)); + EXPECT_EQ(Encode(3, 0, kPositive), Decimal(2) - Decimal(-1)); + EXPECT_EQ(Encode(3, 0, kNegative), Decimal(-1) - Decimal(2)); + EXPECT_EQ(Encode(98, 0, kPositive), Decimal(99) - Decimal(1)); + EXPECT_EQ(Encode(0, 0, kPositive), Decimal(-50) - Decimal(-50)); + EXPECT_EQ(Encode(UINT64_C(1000000000000000), 35, kPositive), + Encode(1, 50, kPositive) - Decimal(1)); + EXPECT_EQ(Encode(UINT64_C(1000000000000000), 35, kNegative), + Decimal(1) - Encode(1, 50, kPositive)); +} + +TEST_F(DecimalTest, SubtractBigExponent) { + EXPECT_EQ(Encode(1, 1022, kPositive), + Encode(1, 1022, kPositive) - Encode(1, 0, kPositive)); + EXPECT_EQ(Encode(0, 0, kPositive), + Encode(1, 1022, kPositive) - Encode(1, 1022, kPositive)); + EXPECT_EQ(Encode(1, 1022, kPositive), + Encode(1, 1022, kPositive) + Encode(1, -1000, kPositive)); +} + +TEST_F(DecimalTest, SubtractSmallExponent) { + EXPECT_EQ(Encode(UINT64_C(10000000000000000), -16, kNegative), + Encode(1, -1022, kPositive) - Encode(1, 0, kPositive)); + EXPECT_EQ(Encode(0, 0, kPositive), + Encode(1, -1022, kPositive) - Encode(1, -1022, kPositive)); +} + +TEST_F(DecimalTest, SubtractSpecialValues) { + const Decimal infinity(Decimal::Infinity(kPositive)); + const Decimal minus_infinity(Decimal::Infinity(kNegative)); + const Decimal na_n(Decimal::Nan()); + const Decimal ten(10); + + EXPECT_EQ(na_n, infinity - infinity); + EXPECT_EQ(infinity, infinity - minus_infinity); + EXPECT_EQ(minus_infinity, minus_infinity - infinity); + EXPECT_EQ(na_n, minus_infinity - minus_infinity); + + EXPECT_EQ(infinity, infinity - ten); + EXPECT_EQ(minus_infinity, ten - infinity); + EXPECT_EQ(minus_infinity, minus_infinity - ten); + EXPECT_EQ(infinity, ten - minus_infinity); + + EXPECT_EQ(na_n, na_n - na_n); + EXPECT_EQ(na_n, na_n - ten); + EXPECT_EQ(na_n, ten - na_n); + + EXPECT_EQ(na_n, na_n - infinity); + EXPECT_EQ(na_n, na_n - minus_infinity); + EXPECT_EQ(na_n, infinity - na_n); + EXPECT_EQ(na_n, minus_infinity - na_n); +} + +TEST_F(DecimalTest, ToDouble) { + EXPECT_EQ(0.0, Encode(0, 0, kPositive).ToDouble()); + EXPECT_EQ(-0.0, Encode(0, 0, kNegative).ToDouble()); + + EXPECT_EQ(1.0, Encode(1, 0, kPositive).ToDouble()); + EXPECT_EQ(-1.0, Encode(1, 0, kNegative).ToDouble()); + + EXPECT_EQ(0.1, Encode(1, -1, kPositive).ToDouble()); + EXPECT_EQ(-0.1, Encode(1, -1, kNegative).ToDouble()); + EXPECT_EQ(0.3, Encode(3, -1, kPositive).ToDouble()); + EXPECT_EQ(-0.3, Encode(3, -1, kNegative).ToDouble()); + EXPECT_EQ(0.6, Encode(6, -1, kPositive).ToDouble()); + EXPECT_EQ(-0.6, Encode(6, -1, kNegative).ToDouble()); + EXPECT_EQ(0.7, Encode(7, -1, kPositive).ToDouble()); + EXPECT_EQ(-0.7, Encode(7, -1, kNegative).ToDouble()); + + EXPECT_EQ(0.01, Encode(1, -2, kPositive).ToDouble()); + EXPECT_EQ(0.001, Encode(1, -3, kPositive).ToDouble()); + EXPECT_EQ(0.0001, Encode(1, -4, kPositive).ToDouble()); + EXPECT_EQ(0.00001, Encode(1, -5, kPositive).ToDouble()); + + EXPECT_EQ(1e+308, Encode(1, 308, kPositive).ToDouble()); + EXPECT_EQ(1e-307, Encode(1, -307, kPositive).ToDouble()); + + EXPECT_TRUE(std::isinf(Encode(1, 1000, kPositive).ToDouble())); + EXPECT_EQ(0.0, Encode(1, -1000, kPositive).ToDouble()); +} + +TEST_F(DecimalTest, ToDoubleSpecialValues) { + EXPECT_TRUE(std::isinf(Decimal::Infinity(Decimal::kPositive).ToDouble())); + EXPECT_TRUE(std::isinf(Decimal::Infinity(Decimal::kNegative).ToDouble())); + EXPECT_TRUE(std::isnan(Decimal::Nan().ToDouble())); +} + +TEST_F(DecimalTest, ToString) { + EXPECT_DECIMAL_STREQ("0", Decimal::Zero(kPositive)); + EXPECT_DECIMAL_STREQ("-0", Decimal::Zero(kNegative)); + EXPECT_DECIMAL_STREQ("1", Decimal(1)); + EXPECT_DECIMAL_STREQ("-1", Decimal(-1)); + EXPECT_DECIMAL_STREQ("1234567", Decimal(1234567)); + EXPECT_DECIMAL_STREQ("-1234567", Decimal(-1234567)); + EXPECT_DECIMAL_STREQ("0.5", Encode(5, -1, kPositive)); + EXPECT_DECIMAL_STREQ("-0.5", Encode(5, -1, kNegative)); + EXPECT_DECIMAL_STREQ("12.345", Encode(12345, -3, kPositive)); + EXPECT_DECIMAL_STREQ("-12.345", Encode(12345, -3, kNegative)); + EXPECT_DECIMAL_STREQ("0.12345", Encode(12345, -5, kPositive)); + EXPECT_DECIMAL_STREQ("-0.12345", Encode(12345, -5, kNegative)); + EXPECT_DECIMAL_STREQ("50", Encode(50, 0, kPositive)); + EXPECT_DECIMAL_STREQ("-50", Encode(50, 0, kNegative)); + EXPECT_DECIMAL_STREQ("5e+1", Encode(5, 1, kPositive)); + EXPECT_DECIMAL_STREQ("-5e+1", Encode(5, 1, kNegative)); + EXPECT_DECIMAL_STREQ("5.678e+103", Encode(5678, 100, kPositive)); + EXPECT_DECIMAL_STREQ("-5.678e+103", Encode(5678, 100, kNegative)); + EXPECT_DECIMAL_STREQ("5.678e-97", Encode(5678, -100, kPositive)); + EXPECT_DECIMAL_STREQ("-5.678e-97", Encode(5678, -100, kNegative)); + EXPECT_DECIMAL_STREQ("8639999913600001", + Encode(UINT64_C(8639999913600001), 0, kPositive)); + EXPECT_DECIMAL_STREQ( + "9007199254740991", + Encode((static_cast<uint64_t>(1) << DBL_MANT_DIG) - 1, 0, kPositive)); + EXPECT_DECIMAL_STREQ("99999999999999999", + Encode(UINT64_C(99999999999999999), 0, kPositive)); + EXPECT_DECIMAL_STREQ("9.9999999999999999e+17", + Encode(UINT64_C(99999999999999999), 1, kPositive)); + EXPECT_DECIMAL_STREQ("9.9999999999999999e+18", + Encode(UINT64_C(99999999999999999), 2, kPositive)); + EXPECT_DECIMAL_STREQ("1e+16", + Encode(UINT64_C(99999999999999999), -1, kPositive)); + EXPECT_DECIMAL_STREQ("1000000000000000", + Encode(UINT64_C(99999999999999999), -2, kPositive)); + EXPECT_DECIMAL_STREQ("1", + Encode(UINT64_C(99999999999999999), -17, kPositive)); + EXPECT_DECIMAL_STREQ("0.001", + Encode(UINT64_C(99999999999999999), -20, kPositive)); + EXPECT_DECIMAL_STREQ("1e-83", + Encode(UINT64_C(99999999999999999), -100, kPositive)); +} + +TEST_F(DecimalTest, ToStringSpecialValues) { + EXPECT_DECIMAL_STREQ("Infinity", Decimal::Infinity(kPositive)); + EXPECT_DECIMAL_STREQ("-Infinity", Decimal::Infinity(kNegative)); + EXPECT_DECIMAL_STREQ("NaN", Decimal::Nan()); +} + +} // namespace blink |