src/third_party/WebKit/Source/platform/DecimalTest.cpp

   1 /*
   2  * Copyright (C) 2012 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "platform/Decimal.h"
  33
  34 #include "wtf/MathExtras.h"
  35 #include "wtf/text/CString.h"
  36 #include <float.h>
  37 #include <gtest/gtest.h>
  38
  39 namespace blink {
  40
  41 std::ostream& operator<<(std::ostream& os, const Decimal& decimal)
  42 {
  43     Decimal::EncodedData data = decimal.value();
  44     return os
  45         << "encode(" << String::number(data.coefficient()).ascii().data()
  46         << ", " << String::number(data.exponent()).ascii().data()
  47         << ", " << (data.sign() == Decimal::Negative ? "Negative" : "Positive")
  48         << ")=" << decimal.toString().ascii().data();
  49 }
  50
  51 } // namespace blink
  52
  53 using namespace blink;
  54
  55 // Simulate WebCore/html/StepRange
  56 class DecimalStepRange {
  57 public:
  58     Decimal maximum;
  59     Decimal minimum;
  60     Decimal step;
  61
  62     DecimalStepRange(const Decimal& minimum, const Decimal& maximum, const Decimal& step)
  63         : maximum(maximum)
  64         , minimum(minimum)
  65         , step(step)
  66     {
  67     }
  68
  69     Decimal clampValue(Decimal value) const
  70     {
  71         const Decimal result = minimum + ((value - minimum) / step).round() * step;
  72         ASSERT(result.isFinite());
  73         return result > maximum ? result - step : result;
  74     }
  75 };
  76
  77 class DecimalTest : public ::testing::Test {
  78 protected:
  79     typedef Decimal::Sign Sign;
  80     protected: static const Sign Positive = Decimal::Positive;
  81     protected: static const Sign Negative = Decimal::Negative;
  82
  83     Decimal encode(uint64_t coefficient, int exponent, Sign sign)
  84     {
  85         return Decimal(sign, exponent, coefficient);
  86     }
  87
  88     protected: Decimal fromString(const String& string)
  89     {
  90         return Decimal::fromString(string);
  91     }
  92
  93     protected: Decimal stepDown(const String& minimum, const String& maximum, const String& step, const String& valueString, int numberOfStepTimes)
  94     {
  95         DecimalStepRange stepRange(fromString(minimum), fromString(maximum), fromString(step));
  96         Decimal value = fromString(valueString);
  97         for (int i = 0; i < numberOfStepTimes; ++i) {
  98             value -= stepRange.step;
  99             value = stepRange.clampValue(value);
 100         }
 101         return value;
 102     }
 103
 104     protected: Decimal stepUp(const String& minimum, const String& maximum, const String& step, const String& valueString, int numberOfStepTimes)
 105     {
 106         DecimalStepRange stepRange(fromString(minimum), fromString(maximum), fromString(step));
 107         Decimal value = fromString(valueString);
 108         for (int i = 0; i < numberOfStepTimes; ++i) {
 109             value += stepRange.step;
 110             value = stepRange.clampValue(value);
 111         }
 112         return value;
 113     }
 114 };
 115
 116 // FIXME: We should use expectedSign without "Decimal::", however, g++ causes undefined references for DecimalTest::Positive and Negative.
 117 #define EXPECT_DECIMAL_ENCODED_DATA_EQ(expectedCoefficient, expectedExponent,  expectedSign, decimal) \
 118     EXPECT_EQ((expectedCoefficient), (decimal).value().coefficient()); \
 119     EXPECT_EQ((expectedExponent), (decimal).value().exponent()); \
 120     EXPECT_EQ(Decimal::expectedSign, (decimal).value().sign());
 121
 122 #define EXPECT_DECIMAL_STREQ(expected, decimal) EXPECT_STREQ((expected), (decimal).toString().ascii().data())
 123
 124 TEST_F(DecimalTest, Abs)
 125 {
 126     EXPECT_EQ(encode(0, 0, Positive), encode(0, 0, Positive).abs());
 127     EXPECT_EQ(encode(0, 0, Positive), encode(0, 0, Negative).abs());
 128
 129     EXPECT_EQ(encode(0, 10, Positive), encode(0, 10, Positive).abs());
 130     EXPECT_EQ(encode(0, 10, Positive), encode(0, 10, Negative).abs());
 131
 132     EXPECT_EQ(encode(0, -10, Positive), encode(0, -10, Positive).abs());
 133     EXPECT_EQ(encode(0, -10, Positive), encode(0, -10, Negative).abs());
 134
 135     EXPECT_EQ(encode(1, 0, Positive), encode(1, 0, Positive).abs());
 136     EXPECT_EQ(encode(1, 0, Positive), encode(1, 0, Negative).abs());
 137
 138     EXPECT_EQ(encode(1, 10, Positive), encode(1, 10, Positive).abs());
 139     EXPECT_EQ(encode(1, 10, Positive), encode(1, 10, Negative).abs());
 140
 141     EXPECT_EQ(encode(1, -10, Positive), encode(1, -10, Positive).abs());
 142     EXPECT_EQ(encode(1, -10, Positive), encode(1, -10, Negative).abs());
 143 }
 144
 145 TEST_F(DecimalTest, AbsBigExponent)
 146 {
 147     EXPECT_EQ(encode(1, 1000, Positive), encode(1, 1000, Positive).abs());
 148     EXPECT_EQ(encode(1, 1000, Positive), encode(1, 1000, Negative).abs());
 149 }
 150
 151 TEST_F(DecimalTest, AbsSmallExponent)
 152 {
 153     EXPECT_EQ(encode(1, -1000, Positive), encode(1, -1000, Positive).abs());
 154     EXPECT_EQ(encode(1, -1000, Positive), encode(1, -1000, Negative).abs());
 155 }
 156
 157 TEST_F(DecimalTest, AbsSpecialValues)
 158 {
 159     EXPECT_EQ(Decimal::infinity(Positive), Decimal::infinity(Positive).abs());
 160     EXPECT_EQ(Decimal::infinity(Positive), Decimal::infinity(Negative).abs());
 161     EXPECT_EQ(Decimal::nan(), Decimal::nan().abs());
 162 }
 163
 164 TEST_F(DecimalTest, Add)
 165 {
 166     EXPECT_EQ(encode(0, 0, Positive), Decimal(0) + Decimal(0));
 167     EXPECT_EQ(Decimal(1), Decimal(2) + Decimal(-1));
 168     EXPECT_EQ(Decimal(1), Decimal(-1) + Decimal(2));
 169     EXPECT_EQ(encode(100, 0, Positive), Decimal(99) + Decimal(1));
 170     EXPECT_EQ(encode(100, 0, Negative), Decimal(-50) + Decimal(-50));
 171     EXPECT_EQ(encode(UINT64_C(1000000000000000), 35, Positive), encode(1, 50, Positive) + Decimal(1));
 172     EXPECT_EQ(encode(UINT64_C(1000000000000000), 35, Positive), Decimal(1) + encode(1, 50, Positive));
 173     EXPECT_EQ(encode(UINT64_C(10000000001), 0, Positive), encode(1, 10, Positive) + Decimal(1));
 174     EXPECT_EQ(encode(UINT64_C(10000000001), 0, Positive), Decimal(1) + encode(1, 10, Positive));
 175     EXPECT_EQ(encode(1, 0, Positive), encode(1, -1022, Positive) + encode(1, 0, Positive));
 176     EXPECT_EQ(encode(2, -1022, Positive), encode(1, -1022, Positive) + encode(1, -1022, Positive));
 177 }
 178
 179 TEST_F(DecimalTest, AddBigExponent)
 180 {
 181     EXPECT_EQ(encode(1, 1022, Positive), encode(1, 1022, Positive) + encode(1, 0, Positive));
 182     EXPECT_EQ(encode(2, 1022, Positive), encode(1, 1022, Positive) + encode(1, 1022, Positive));
 183     EXPECT_EQ(Decimal::infinity(Positive), encode(std::numeric_limits<uint64_t>::max(), 1022, Positive) + encode(1, 0, Positive));
 184     EXPECT_EQ(encode(1, 1022, Positive), encode(1, 1022, Positive) + encode(1, -1000, Positive));
 185 }
 186
 187 TEST_F(DecimalTest, AddSmallExponent)
 188 {
 189     EXPECT_EQ(encode(1, 0, Positive), encode(1, -1022, Positive) + encode(1, 0, Positive));
 190     EXPECT_EQ(encode(2, -1022, Positive), encode(1, -1022, Positive) + encode(1, -1022, Positive));
 191 }
 192
 193 TEST_F(DecimalTest, AddSpecialValues)
 194 {
 195     const Decimal Infinity(Decimal::infinity(Positive));
 196     const Decimal MinusInfinity(Decimal::infinity(Negative));
 197     const Decimal NaN(Decimal::nan());
 198     const Decimal Ten(10);
 199
 200     EXPECT_EQ(Infinity, Infinity + Infinity);
 201     EXPECT_EQ(NaN, Infinity + MinusInfinity);
 202     EXPECT_EQ(NaN, MinusInfinity + Infinity);
 203     EXPECT_EQ(MinusInfinity, MinusInfinity + MinusInfinity);
 204
 205     EXPECT_EQ(Infinity, Infinity + Ten);
 206     EXPECT_EQ(Infinity, Ten + Infinity);
 207     EXPECT_EQ(MinusInfinity, MinusInfinity + Ten);
 208     EXPECT_EQ(MinusInfinity, Ten + MinusInfinity);
 209
 210     EXPECT_EQ(NaN, NaN + NaN);
 211     EXPECT_EQ(NaN, NaN + Ten);
 212     EXPECT_EQ(NaN, Ten + NaN);
 213
 214     EXPECT_EQ(NaN, NaN - Infinity);
 215     EXPECT_EQ(NaN, NaN - MinusInfinity);
 216     EXPECT_EQ(NaN, Infinity - NaN);
 217     EXPECT_EQ(NaN, MinusInfinity - NaN);
 218 }
 219
 220 TEST_F(DecimalTest, Ceil)
 221 {
 222     EXPECT_EQ(Decimal(1), Decimal(1).ceil());
 223     EXPECT_EQ(Decimal(1), encode(1, -10, Positive).ceil());
 224     EXPECT_EQ(Decimal(2), encode(11, -1, Positive).ceil());
 225     EXPECT_EQ(Decimal(2), encode(13, -1, Positive).ceil());
 226     EXPECT_EQ(Decimal(2), encode(15, -1, Positive).ceil());
 227     EXPECT_EQ(Decimal(2), encode(19, -1, Positive).ceil());
 228     EXPECT_EQ(Decimal(2), encode(151, -2, Positive).ceil());
 229     EXPECT_EQ(Decimal(2), encode(101, -2, Positive).ceil());
 230     EXPECT_EQ(Decimal(1), encode(199, -3, Positive).ceil());
 231     EXPECT_EQ(Decimal(2), encode(199, -2, Positive).ceil());
 232     EXPECT_EQ(Decimal(3), encode(209, -2, Positive).ceil());
 233
 234     EXPECT_EQ(Decimal(-1), Decimal(-1).ceil());
 235     EXPECT_EQ(Decimal(0), encode(1, -10, Negative).ceil());
 236     EXPECT_EQ(Decimal(-1), encode(11, -1, Negative).ceil());
 237     EXPECT_EQ(Decimal(-1), encode(13, -1, Negative).ceil());
 238     EXPECT_EQ(Decimal(-1), encode(15, -1, Negative).ceil());
 239     EXPECT_EQ(Decimal(-1), encode(19, -1, Negative).ceil());
 240     EXPECT_EQ(Decimal(-1), encode(151, -2, Negative).ceil());
 241     EXPECT_EQ(Decimal(-1), encode(101, -2, Negative).ceil());
 242     EXPECT_EQ(Decimal(0), encode(199, -3, Negative).ceil());
 243     EXPECT_EQ(Decimal(-1), encode(199, -2, Negative).ceil());
 244     EXPECT_EQ(Decimal(-2), encode(209, -2, Negative).ceil());
 245 }
 246
 247 TEST_F(DecimalTest, CeilingBigExponent)
 248 {
 249     EXPECT_EQ(encode(1, 1000, Positive), encode(1, 1000, Positive).ceil());
 250     EXPECT_EQ(encode(1, 1000, Negative), encode(1, 1000, Negative).ceil());
 251 }
 252
 253 TEST_F(DecimalTest, CeilingSmallExponent)
 254 {
 255     EXPECT_EQ(encode(1, 0, Positive), encode(1, -1000, Positive).ceil());
 256     EXPECT_EQ(encode(0, 0, Negative), encode(1, -1000, Negative).ceil());
 257 }
 258
 259 TEST_F(DecimalTest, CeilingSpecialValues)
 260 {
 261     EXPECT_EQ(Decimal::infinity(Positive), Decimal::infinity(Positive).ceil());
 262     EXPECT_EQ(Decimal::infinity(Negative), Decimal::infinity(Negative).ceil());
 263     EXPECT_EQ(Decimal::nan(), Decimal::nan().ceil());
 264 }
 265
 266 TEST_F(DecimalTest, Compare)
 267 {
 268     EXPECT_TRUE(Decimal(0) == Decimal(0));
 269     EXPECT_TRUE(Decimal(0) != Decimal(1));
 270     EXPECT_TRUE(Decimal(0) < Decimal(1));
 271     EXPECT_TRUE(Decimal(0) <= Decimal(0));
 272     EXPECT_TRUE(Decimal(0) > Decimal(-1));
 273     EXPECT_TRUE(Decimal(0) >= Decimal(0));
 274
 275     EXPECT_FALSE(Decimal(1) == Decimal(2));
 276     EXPECT_FALSE(Decimal(1) != Decimal(1));
 277     EXPECT_FALSE(Decimal(1) < Decimal(0));
 278     EXPECT_FALSE(Decimal(1) <= Decimal(0));
 279     EXPECT_FALSE(Decimal(1) > Decimal(2));
 280     EXPECT_FALSE(Decimal(1) >= Decimal(2));
 281 }
 282
 283 TEST_F(DecimalTest, CompareBigExponent)
 284 {
 285     EXPECT_TRUE(encode(1, 1000, Positive) == encode(1, 1000, Positive));
 286     EXPECT_FALSE(encode(1, 1000, Positive) != encode(1, 1000, Positive));
 287     EXPECT_FALSE(encode(1, 1000, Positive) < encode(1, 1000, Positive));
 288     EXPECT_TRUE(encode(1, 1000, Positive) <= encode(1, 1000, Positive));
 289     EXPECT_FALSE(encode(1, 1000, Positive) > encode(1, 1000, Positive));
 290     EXPECT_TRUE(encode(1, 1000, Positive) >= encode(1, 1000, Positive));
 291
 292     EXPECT_TRUE(encode(1, 1000, Negative) == encode(1, 1000, Negative));
 293     EXPECT_FALSE(encode(1, 1000, Negative) != encode(1, 1000, Negative));
 294     EXPECT_FALSE(encode(1, 1000, Negative) < encode(1, 1000, Negative));
 295     EXPECT_TRUE(encode(1, 1000, Negative) <= encode(1, 1000, Negative));
 296     EXPECT_FALSE(encode(1, 1000, Negative) > encode(1, 1000, Negative));
 297     EXPECT_TRUE(encode(1, 1000, Negative) >= encode(1, 1000, Negative));
 298
 299     EXPECT_FALSE(encode(2, 1000, Positive) == encode(1, 1000, Positive));
 300     EXPECT_TRUE(encode(2, 1000, Positive) != encode(1, 1000, Positive));
 301     EXPECT_FALSE(encode(2, 1000, Positive) < encode(1, 1000, Positive));
 302     EXPECT_FALSE(encode(2, 1000, Positive) <= encode(1, 1000, Positive));
 303     EXPECT_TRUE(encode(2, 1000, Positive) > encode(1, 1000, Positive));
 304     EXPECT_TRUE(encode(2, 1000, Positive) >= encode(1, 1000, Positive));
 305
 306     EXPECT_FALSE(encode(2, 1000, Negative) == encode(1, 1000, Negative));
 307     EXPECT_TRUE(encode(2, 1000, Negative) != encode(1, 1000, Negative));
 308     EXPECT_TRUE(encode(2, 1000, Negative) < encode(1, 1000, Negative));
 309     EXPECT_TRUE(encode(2, 1000, Negative) <= encode(1, 1000, Negative));
 310     EXPECT_FALSE(encode(2, 1000, Negative) > encode(1, 1000, Negative));
 311     EXPECT_FALSE(encode(2, 1000, Negative) >= encode(1, 1000, Negative));
 312 }
 313
 314 TEST_F(DecimalTest, CompareSmallExponent)
 315 {
 316     EXPECT_TRUE(encode(1, -1000, Positive) == encode(1, -1000, Positive));
 317     EXPECT_FALSE(encode(1, -1000, Positive) != encode(1, -1000, Positive));
 318     EXPECT_FALSE(encode(1, -1000, Positive) < encode(1, -1000, Positive));
 319     EXPECT_TRUE(encode(1, -1000, Positive) <= encode(1, -1000, Positive));
 320     EXPECT_FALSE(encode(1, -1000, Positive) > encode(1, -1000, Positive));
 321     EXPECT_TRUE(encode(1, -1000, Positive) >= encode(1, -1000, Positive));
 322
 323     EXPECT_TRUE(encode(1, -1000, Negative) == encode(1, -1000, Negative));
 324     EXPECT_FALSE(encode(1, -1000, Negative) != encode(1, -1000, Negative));
 325     EXPECT_FALSE(encode(1, -1000, Negative) < encode(1, -1000, Negative));
 326     EXPECT_TRUE(encode(1, -1000, Negative) <= encode(1, -1000, Negative));
 327     EXPECT_FALSE(encode(1, -1000, Negative) > encode(1, -1000, Negative));
 328     EXPECT_TRUE(encode(1, -1000, Negative) >= encode(1, -1000, Negative));
 329
 330     EXPECT_FALSE(encode(2, -1000, Positive) == encode(1, -1000, Positive));
 331     EXPECT_TRUE(encode(2, -1000, Positive) != encode(1, -1000, Positive));
 332     EXPECT_FALSE(encode(2, -1000, Positive) < encode(1, -1000, Positive));
 333     EXPECT_FALSE(encode(2, -1000, Positive) <= encode(1, -1000, Positive));
 334     EXPECT_TRUE(encode(2, -1000, Positive) > encode(1, -1000, Positive));
 335     EXPECT_TRUE(encode(2, -1000, Positive) >= encode(1, -1000, Positive));
 336
 337     EXPECT_FALSE(encode(2, -1000, Negative) == encode(1, -1000, Negative));
 338     EXPECT_TRUE(encode(2, -1000, Negative) != encode(1, -1000, Negative));
 339     EXPECT_TRUE(encode(2, -1000, Negative) < encode(1, -1000, Negative));
 340     EXPECT_TRUE(encode(2, -1000, Negative) <= encode(1, -1000, Negative));
 341     EXPECT_FALSE(encode(2, -1000, Negative) > encode(1, -1000, Negative));
 342     EXPECT_FALSE(encode(2, -1000, Negative) >= encode(1, -1000, Negative));
 343 }
 344
 345 TEST_F(DecimalTest, CompareSpecialValues)
 346 {
 347     const Decimal Infinity(Decimal::infinity(Positive));
 348     const Decimal MinusInfinity(Decimal::infinity(Negative));
 349     const Decimal NaN(Decimal::nan());
 350     const Decimal Zero(Decimal::zero(Positive));
 351     const Decimal MinusZero(Decimal::zero(Negative));
 352     const Decimal Ten(10);
 353
 354     EXPECT_TRUE(Zero == Zero);
 355     EXPECT_FALSE(Zero != Zero);
 356     EXPECT_FALSE(Zero < Zero);
 357     EXPECT_TRUE(Zero <= Zero);
 358     EXPECT_FALSE(Zero > Zero);
 359     EXPECT_TRUE(Zero >= Zero);
 360
 361     EXPECT_TRUE(Zero == MinusZero);
 362     EXPECT_FALSE(Zero != MinusZero);
 363     EXPECT_FALSE(Zero < MinusZero);
 364     EXPECT_TRUE(Zero <= MinusZero);
 365     EXPECT_FALSE(Zero > MinusZero);
 366     EXPECT_TRUE(Zero >= MinusZero);
 367
 368     EXPECT_TRUE(MinusZero == Zero);
 369     EXPECT_FALSE(MinusZero != Zero);
 370     EXPECT_FALSE(MinusZero < Zero);
 371     EXPECT_TRUE(MinusZero <= Zero);
 372     EXPECT_FALSE(MinusZero > Zero);
 373     EXPECT_TRUE(MinusZero >= Zero);
 374
 375     EXPECT_TRUE(MinusZero == MinusZero);
 376     EXPECT_FALSE(MinusZero != MinusZero);
 377     EXPECT_FALSE(MinusZero < MinusZero);
 378     EXPECT_TRUE(MinusZero <= MinusZero);
 379     EXPECT_FALSE(MinusZero > MinusZero);
 380     EXPECT_TRUE(MinusZero >= MinusZero);
 381
 382     EXPECT_TRUE(Infinity == Infinity);
 383     EXPECT_FALSE(Infinity != Infinity);
 384     EXPECT_FALSE(Infinity < Infinity);
 385     EXPECT_TRUE(Infinity <= Infinity);
 386     EXPECT_FALSE(Infinity > Infinity);
 387     EXPECT_TRUE(Infinity >= Infinity);
 388
 389     EXPECT_FALSE(Infinity == Ten);
 390     EXPECT_TRUE(Infinity != Ten);
 391     EXPECT_FALSE(Infinity < Ten);
 392     EXPECT_FALSE(Infinity <= Ten);
 393     EXPECT_TRUE(Infinity > Ten);
 394     EXPECT_TRUE(Infinity >= Ten);
 395
 396     EXPECT_FALSE(Infinity == MinusInfinity);
 397     EXPECT_TRUE(Infinity != MinusInfinity);
 398     EXPECT_FALSE(Infinity < MinusInfinity);
 399     EXPECT_FALSE(Infinity <= MinusInfinity);
 400     EXPECT_TRUE(Infinity > MinusInfinity);
 401     EXPECT_TRUE(Infinity >= MinusInfinity);
 402
 403     EXPECT_FALSE(Infinity == NaN);
 404     EXPECT_FALSE(Infinity != NaN);
 405     EXPECT_FALSE(Infinity < NaN);
 406     EXPECT_FALSE(Infinity <= NaN);
 407     EXPECT_FALSE(Infinity > NaN);
 408     EXPECT_FALSE(Infinity >= NaN);
 409
 410     EXPECT_FALSE(MinusInfinity == Infinity);
 411     EXPECT_TRUE(MinusInfinity != Infinity);
 412     EXPECT_TRUE(MinusInfinity < Infinity);
 413     EXPECT_TRUE(MinusInfinity <= Infinity);
 414     EXPECT_FALSE(MinusInfinity > Infinity);
 415     EXPECT_FALSE(MinusInfinity >= Infinity);
 416
 417     EXPECT_FALSE(MinusInfinity == Ten);
 418     EXPECT_TRUE(MinusInfinity != Ten);
 419     EXPECT_TRUE(MinusInfinity < Ten);
 420     EXPECT_TRUE(MinusInfinity <= Ten);
 421     EXPECT_FALSE(MinusInfinity > Ten);
 422     EXPECT_FALSE(MinusInfinity >= Ten);
 423
 424     EXPECT_TRUE(MinusInfinity == MinusInfinity);
 425     EXPECT_FALSE(MinusInfinity != MinusInfinity);
 426     EXPECT_FALSE(MinusInfinity < MinusInfinity);
 427     EXPECT_TRUE(MinusInfinity <= MinusInfinity);
 428     EXPECT_FALSE(MinusInfinity > MinusInfinity);
 429     EXPECT_TRUE(MinusInfinity >= MinusInfinity);
 430
 431     EXPECT_FALSE(MinusInfinity == NaN);
 432     EXPECT_FALSE(MinusInfinity != NaN);
 433     EXPECT_FALSE(MinusInfinity < NaN);
 434     EXPECT_FALSE(MinusInfinity <= NaN);
 435     EXPECT_FALSE(MinusInfinity > NaN);
 436     EXPECT_FALSE(MinusInfinity >= NaN);
 437
 438     EXPECT_FALSE(NaN == Infinity);
 439     EXPECT_FALSE(NaN != Infinity);
 440     EXPECT_FALSE(NaN < Infinity);
 441     EXPECT_FALSE(NaN <= Infinity);
 442     EXPECT_FALSE(NaN > Infinity);
 443     EXPECT_FALSE(NaN >= Infinity);
 444
 445     EXPECT_FALSE(NaN == Ten);
 446     EXPECT_FALSE(NaN != Ten);
 447     EXPECT_FALSE(NaN < Ten);
 448     EXPECT_FALSE(NaN <= Ten);
 449     EXPECT_FALSE(NaN > Ten);
 450     EXPECT_FALSE(NaN >= Ten);
 451
 452     EXPECT_FALSE(NaN == MinusInfinity);
 453     EXPECT_FALSE(NaN != MinusInfinity);
 454     EXPECT_FALSE(NaN < MinusInfinity);
 455     EXPECT_FALSE(NaN <= MinusInfinity);
 456     EXPECT_FALSE(NaN > MinusInfinity);
 457     EXPECT_FALSE(NaN >= MinusInfinity);
 458
 459     EXPECT_TRUE(NaN == NaN);
 460     EXPECT_FALSE(NaN != NaN);
 461     EXPECT_FALSE(NaN < NaN);
 462     EXPECT_TRUE(NaN <= NaN);
 463     EXPECT_FALSE(NaN > NaN);
 464     EXPECT_TRUE(NaN >= NaN);
 465 }
 466
 467 TEST_F(DecimalTest, Constructor)
 468 {
 469     EXPECT_DECIMAL_ENCODED_DATA_EQ(0u, 0, Positive, encode(0, 0, Positive));
 470     EXPECT_DECIMAL_ENCODED_DATA_EQ(0u, 0, Negative, encode(0, 0, Negative));
 471     EXPECT_DECIMAL_ENCODED_DATA_EQ(1u, 0, Positive, encode(1, 0, Positive));
 472     EXPECT_DECIMAL_ENCODED_DATA_EQ(1u, 0, Negative, encode(1, 0, Negative));
 473     EXPECT_DECIMAL_ENCODED_DATA_EQ(1u, 1022, Positive, encode(1, 1022, Positive));
 474     EXPECT_DECIMAL_ENCODED_DATA_EQ(1u, 1022, Negative, encode(1, 1022, Negative));
 475     EXPECT_DECIMAL_ENCODED_DATA_EQ(1u, 1023, Positive, encode(1, 1023, Positive));
 476     EXPECT_DECIMAL_ENCODED_DATA_EQ(1u, 1023, Negative, encode(1, 1023, Negative));
 477     EXPECT_TRUE(encode(1, 2000, Positive).isInfinity());
 478     EXPECT_TRUE(encode(1, 2000, Negative).isInfinity());
 479     EXPECT_DECIMAL_ENCODED_DATA_EQ(0u, 0, Positive, encode(1, -2000, Positive));
 480     EXPECT_DECIMAL_ENCODED_DATA_EQ(0u, 0, Negative, encode(1, -2000, Negative));
 481     EXPECT_DECIMAL_ENCODED_DATA_EQ(UINT64_C(99999999999999998), 0, Positive, encode(UINT64_C(99999999999999998), 0, Positive));
 482     EXPECT_DECIMAL_ENCODED_DATA_EQ(UINT64_C(99999999999999998), 0, Negative, encode(UINT64_C(99999999999999998), 0, Negative));
 483     EXPECT_DECIMAL_ENCODED_DATA_EQ(UINT64_C(99999999999999999), 0, Positive, encode(UINT64_C(99999999999999999), 0, Positive));
 484     EXPECT_DECIMAL_ENCODED_DATA_EQ(UINT64_C(99999999999999999), 0, Negative, encode(UINT64_C(99999999999999999), 0, Negative));
 485     EXPECT_DECIMAL_ENCODED_DATA_EQ(UINT64_C(100000000000000000), 0, Positive, encode(UINT64_C(100000000000000000), 0, Positive));
 486     EXPECT_DECIMAL_ENCODED_DATA_EQ(UINT64_C(100000000000000000), 0, Negative, encode(UINT64_C(100000000000000000), 0, Negative));
 487 }
 488
 489 TEST_F(DecimalTest, Division)
 490 {
 491     EXPECT_EQ(encode(0, 0, Positive), Decimal(0) / Decimal(1));
 492     EXPECT_EQ(encode(2, 0, Negative), Decimal(2) / Decimal(-1));
 493     EXPECT_EQ(encode(5, -1, Negative), Decimal(-1) / Decimal(2));
 494     EXPECT_EQ(encode(99, 0, Positive), Decimal(99) / Decimal(1));
 495     EXPECT_EQ(Decimal(1), Decimal(-50) / Decimal(-50));
 496     EXPECT_EQ(encode(UINT64_C(33333333333333333), -17, Positive), Decimal(1) / Decimal(3));
 497     EXPECT_EQ(encode(UINT64_C(12345678901234), -1, Positive), encode(UINT64_C(12345678901234), 0, Positive) / Decimal(10));
 498 }
 499
 500 TEST_F(DecimalTest, DivisionBigExponent)
 501 {
 502     EXPECT_EQ(encode(1, 1022, Positive), encode(1, 1022, Positive) / encode(1, 0, Positive));
 503     EXPECT_EQ(encode(1, 0, Positive), encode(1, 1022, Positive) / encode(1, 1022, Positive));
 504     EXPECT_EQ(Decimal::infinity(Positive), encode(1, 1022, Positive) / encode(1, -1000, Positive));
 505 }
 506
 507 TEST_F(DecimalTest, DivisionSmallExponent)
 508 {
 509     EXPECT_EQ(encode(1, -1022, Positive), encode(1, -1022, Positive) / encode(1, 0, Positive));
 510     EXPECT_EQ(encode(1, 0, Positive), encode(1, -1022, Positive) / encode(1, -1022, Positive));
 511 }
 512
 513 TEST_F(DecimalTest, DivisionSpecialValues)
 514 {
 515     const Decimal Infinity(Decimal::infinity(Positive));
 516     const Decimal MinusInfinity(Decimal::infinity(Negative));
 517     const Decimal NaN(Decimal::nan());
 518     const Decimal Zero(Decimal::zero(Positive));
 519     const Decimal MinusZero(Decimal::zero(Negative));
 520     const Decimal Ten(10);
 521     const Decimal MinusTen(-10);
 522
 523     EXPECT_EQ(NaN, Zero / Zero);
 524     EXPECT_EQ(NaN, Zero / MinusZero);
 525     EXPECT_EQ(NaN, MinusZero / Zero);
 526     EXPECT_EQ(NaN, MinusZero / MinusZero);
 527
 528     EXPECT_EQ(Infinity, Ten / Zero);
 529     EXPECT_EQ(MinusInfinity, Ten / MinusZero);
 530     EXPECT_EQ(MinusInfinity, MinusTen / Zero);
 531     EXPECT_EQ(Infinity, MinusTen / MinusZero);
 532
 533     EXPECT_EQ(Infinity, Infinity / Zero);
 534     EXPECT_EQ(MinusInfinity, Infinity / MinusZero);
 535     EXPECT_EQ(MinusInfinity, MinusInfinity / Zero);
 536     EXPECT_EQ(Infinity, MinusInfinity / MinusZero);
 537
 538     EXPECT_EQ(NaN, Infinity / Infinity);
 539     EXPECT_EQ(NaN, Infinity / MinusInfinity);
 540     EXPECT_EQ(NaN, MinusInfinity / Infinity);
 541     EXPECT_EQ(NaN, MinusInfinity / MinusInfinity);
 542
 543     EXPECT_EQ(Zero, Ten / Infinity);
 544     EXPECT_EQ(MinusZero, Ten / MinusInfinity);
 545     EXPECT_EQ(MinusZero, MinusTen / Infinity);
 546     EXPECT_EQ(Zero, MinusTen / MinusInfinity);
 547
 548     EXPECT_EQ(NaN, NaN / NaN);
 549     EXPECT_EQ(NaN, NaN / Ten);
 550     EXPECT_EQ(NaN, Ten / NaN);
 551
 552     EXPECT_EQ(NaN, NaN / Infinity);
 553     EXPECT_EQ(NaN, NaN / MinusInfinity);
 554     EXPECT_EQ(NaN, Infinity / NaN);
 555     EXPECT_EQ(NaN, MinusInfinity / NaN);
 556 }
 557
 558 TEST_F(DecimalTest, EncodedData)
 559 {
 560     EXPECT_EQ(encode(0, 0, Positive), encode(0, 0, Positive));
 561     EXPECT_EQ(encode(0, 0, Negative), encode(0, 0, Negative));
 562     EXPECT_EQ(Decimal(1), Decimal(1));
 563     EXPECT_EQ(encode(1, 0, Negative), encode(1, 0, Negative));
 564     EXPECT_EQ(Decimal::infinity(Positive), encode(1, 2000, Positive));
 565     EXPECT_EQ(Decimal::zero(Positive), encode(1, -2000, Positive));
 566 }
 567
 568 TEST_F(DecimalTest, Floor)
 569 {
 570     EXPECT_EQ(Decimal(1), Decimal(1).floor());
 571     EXPECT_EQ(Decimal(0), encode(1, -10, Positive).floor());
 572     EXPECT_EQ(Decimal(1), encode(11, -1, Positive).floor());
 573     EXPECT_EQ(Decimal(1), encode(13, -1, Positive).floor());
 574     EXPECT_EQ(Decimal(1), encode(15, -1, Positive).floor());
 575     EXPECT_EQ(Decimal(1), encode(19, -1, Positive).floor());
 576     EXPECT_EQ(Decimal(1), encode(193332, -5, Positive).floor());
 577     EXPECT_EQ(Decimal(12), encode(12002, -3, Positive).floor());
 578
 579     EXPECT_EQ(Decimal(-1), Decimal(-1).floor());
 580     EXPECT_EQ(Decimal(-1), encode(1, -10, Negative).floor());
 581     EXPECT_EQ(Decimal(-2), encode(11, -1, Negative).floor());
 582     EXPECT_EQ(Decimal(-2), encode(13, -1, Negative).floor());
 583     EXPECT_EQ(Decimal(-2), encode(15, -1, Negative).floor());
 584     EXPECT_EQ(Decimal(-2), encode(19, -1, Negative).floor());
 585     EXPECT_EQ(Decimal(-2), encode(193332, -5, Negative).floor());
 586     EXPECT_EQ(Decimal(-13), encode(12002, -3, Negative).floor());
 587 }
 588
 589 TEST_F(DecimalTest, FloorBigExponent)
 590 {
 591     EXPECT_EQ(encode(1, 1000, Positive), encode(1, 1000, Positive).floor());
 592     EXPECT_EQ(encode(1, 1000, Negative), encode(1, 1000, Negative).floor());
 593 }
 594
 595 TEST_F(DecimalTest, FloorSmallExponent)
 596 {
 597     EXPECT_EQ(encode(0, 0, Positive), encode(1, -1000, Positive).floor());
 598     EXPECT_EQ(encode(1, 0, Negative), encode(1, -1000, Negative).floor());
 599 }
 600
 601 TEST_F(DecimalTest, FloorSpecialValues)
 602 {
 603     EXPECT_EQ(Decimal::infinity(Positive), Decimal::infinity(Positive).floor());
 604     EXPECT_EQ(Decimal::infinity(Negative), Decimal::infinity(Negative).floor());
 605     EXPECT_EQ(Decimal::nan(), Decimal::nan().floor());
 606 }
 607
 608 TEST_F(DecimalTest, FromDouble)
 609 {
 610     EXPECT_EQ(encode(0, 0, Positive), Decimal::fromDouble(0.0));
 611     EXPECT_EQ(encode(0, 0, Negative), Decimal::fromDouble(-0.0));
 612     EXPECT_EQ(encode(1, 0, Positive), Decimal::fromDouble(1));
 613     EXPECT_EQ(encode(1, 0, Negative), Decimal::fromDouble(-1));
 614     EXPECT_EQ(encode(123, 0, Positive), Decimal::fromDouble(123));
 615     EXPECT_EQ(encode(123, 0, Negative), Decimal::fromDouble(-123));
 616     EXPECT_EQ(encode(1, -1, Positive), Decimal::fromDouble(0.1));
 617     EXPECT_EQ(encode(1, -1, Negative), Decimal::fromDouble(-0.1));
 618 }
 619
 620 TEST_F(DecimalTest, FromDoubleLimits)
 621 {
 622     EXPECT_EQ(encode(UINT64_C(2220446049250313), -31, Positive), Decimal::fromDouble(std::numeric_limits<double>::epsilon()));
 623     EXPECT_EQ(encode(UINT64_C(2220446049250313), -31, Negative), Decimal::fromDouble(-std::numeric_limits<double>::epsilon()));
 624     EXPECT_EQ(encode(UINT64_C(17976931348623157), 292, Positive), Decimal::fromDouble(std::numeric_limits<double>::max()));
 625     EXPECT_EQ(encode(UINT64_C(17976931348623157), 292, Negative), Decimal::fromDouble(-std::numeric_limits<double>::max()));
 626     EXPECT_EQ(encode(UINT64_C(22250738585072014), -324, Positive), Decimal::fromDouble(std::numeric_limits<double>::min()));
 627     EXPECT_EQ(encode(UINT64_C(22250738585072014), -324, Negative), Decimal::fromDouble(-std::numeric_limits<double>::min()));
 628     EXPECT_TRUE(Decimal::fromDouble(std::numeric_limits<double>::infinity()).isInfinity());
 629     EXPECT_TRUE(Decimal::fromDouble(-std::numeric_limits<double>::infinity()).isInfinity());
 630     EXPECT_TRUE(Decimal::fromDouble(std::numeric_limits<double>::quiet_NaN()).isNaN());
 631     EXPECT_TRUE(Decimal::fromDouble(-std::numeric_limits<double>::quiet_NaN()).isNaN());
 632 }
 633
 634 TEST_F(DecimalTest, FromInt32)
 635 {
 636     EXPECT_EQ(encode(0, 0, Positive), Decimal(0));
 637     EXPECT_EQ(encode(1, 0, Positive), Decimal(1));
 638     EXPECT_EQ(encode(1, 0, Negative), Decimal(-1));
 639     EXPECT_EQ(encode(100, 0, Positive), Decimal(100));
 640     EXPECT_EQ(encode(100, 0, Negative), Decimal(-100));
 641     EXPECT_EQ(encode(0x7FFFFFFF, 0, Positive), Decimal(std::numeric_limits<int32_t>::max()));
 642     EXPECT_EQ(encode(0x80000000u, 0, Negative), Decimal(std::numeric_limits<int32_t>::min()));
 643 }
 644
 645 TEST_F(DecimalTest, FromString)
 646 {
 647     EXPECT_EQ(encode(0, 0, Positive), fromString("0"));
 648     EXPECT_EQ(encode(0, 0, Negative), fromString("-0"));
 649     EXPECT_EQ(Decimal(1), fromString("1"));
 650     EXPECT_EQ(encode(1, 0, Negative), fromString("-1"));
 651     EXPECT_EQ(Decimal(1), fromString("01"));
 652     EXPECT_EQ(encode(3, 0, Positive), fromString("+3"));
 653     EXPECT_EQ(encode(0, 3, Positive), fromString("0E3"));
 654     EXPECT_EQ(encode(5, -1, Positive), fromString(".5"));
 655     EXPECT_EQ(encode(100, 0, Positive), fromString("100"));
 656     EXPECT_EQ(encode(100, 0, Negative), fromString("-100"));
 657     EXPECT_EQ(encode(123, -2, Positive), fromString("1.23"));
 658     EXPECT_EQ(encode(123, -2, Negative), fromString("-1.23"));
 659     EXPECT_EQ(encode(123, 8, Positive), fromString("1.23E10"));
 660     EXPECT_EQ(encode(123, 8, Negative), fromString("-1.23E10"));
 661     EXPECT_EQ(encode(123, 8, Positive), fromString("1.23E+10"));
 662     EXPECT_EQ(encode(123, 8, Negative), fromString("-1.23E+10"));
 663     EXPECT_EQ(encode(123, -12, Positive), fromString("1.23E-10"));
 664     EXPECT_EQ(encode(123, -12, Negative), fromString("-1.23E-10"));
 665     EXPECT_EQ(encode(5, -7, Positive), fromString("0.0000005"));
 666     EXPECT_EQ(encode(0, 0, Positive), fromString("0e9999"));
 667     EXPECT_EQ(encode(123, -3, Positive), fromString("0.123"));
 668     EXPECT_EQ(encode(0, -2, Positive), fromString("00.00"));
 669     EXPECT_EQ(encode(1, 2, Positive), fromString("1E2"));
 670     EXPECT_EQ(Decimal::infinity(Positive), fromString("1E20000"));
 671     EXPECT_EQ(Decimal::zero(Positive), fromString("1E-20000"));
 672     EXPECT_EQ(encode(1000, 1023, Positive), fromString("1E1026"));
 673     EXPECT_EQ(Decimal::zero(Positive), fromString("1E-1026"));
 674     EXPECT_EQ(Decimal::infinity(Positive), fromString("1234567890E1036"));
 675
 676     // 2^1024
 677     const uint64_t leadingDigitsOf2PowerOf1024 = UINT64_C(17976931348623159);
 678     EXPECT_EQ(encode(leadingDigitsOf2PowerOf1024, 292, Positive), fromString("179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216"));
 679 }
 680
 681 // These strings are look like proper number, but we don't accept them.
 682 TEST_F(DecimalTest, FromStringLikeNumber)
 683 {
 684     EXPECT_EQ(Decimal::nan(), fromString(" 123 "));
 685     EXPECT_EQ(Decimal::nan(), fromString("1,234"));
 686 }
 687
 688 // fromString doesn't support infinity and NaN.
 689 TEST_F(DecimalTest, FromStringSpecialValues)
 690 {
 691     EXPECT_EQ(Decimal::nan(), fromString("INF"));
 692     EXPECT_EQ(Decimal::nan(), fromString("Infinity"));
 693     EXPECT_EQ(Decimal::nan(), fromString("infinity"));
 694     EXPECT_EQ(Decimal::nan(), fromString("+Infinity"));
 695     EXPECT_EQ(Decimal::nan(), fromString("+infinity"));
 696     EXPECT_EQ(Decimal::nan(), fromString("-Infinity"));
 697     EXPECT_EQ(Decimal::nan(), fromString("-infinity"));
 698     EXPECT_EQ(Decimal::nan(), fromString("NaN"));
 699     EXPECT_EQ(Decimal::nan(), fromString("nan"));
 700     EXPECT_EQ(Decimal::nan(), fromString("+NaN"));
 701     EXPECT_EQ(Decimal::nan(), fromString("+nan"));
 702     EXPECT_EQ(Decimal::nan(), fromString("-NaN"));
 703     EXPECT_EQ(Decimal::nan(), fromString("-nan"));
 704 }
 705
 706 TEST_F(DecimalTest, fromStringTruncated)
 707 {
 708     EXPECT_EQ(Decimal::nan(), fromString("x"));
 709     EXPECT_EQ(Decimal::nan(), fromString("0."));
 710     EXPECT_EQ(Decimal::nan(), fromString("1x"));
 711
 712     EXPECT_EQ(Decimal::nan(), fromString("1Ex"));
 713     EXPECT_EQ(Decimal::nan(), fromString("1E2x"));
 714     EXPECT_EQ(Decimal::nan(), fromString("1E+x"));
 715 }
 716
 717 TEST_F(DecimalTest, Multiplication)
 718 {
 719     EXPECT_EQ(encode(0, 0, Positive), Decimal(0) * Decimal(0));
 720     EXPECT_EQ(encode(2, 0, Negative), Decimal(2) * Decimal(-1));
 721     EXPECT_EQ(encode(2, 0, Negative), Decimal(-1) * Decimal(2));
 722     EXPECT_EQ(encode(99, 0, Positive), Decimal(99) * Decimal(1));
 723     EXPECT_EQ(encode(2500, 0, Positive), Decimal(-50) * Decimal(-50));
 724     EXPECT_EQ(encode(1, 21, Positive), encode(UINT64_C(10000000000), 0, Positive) * encode(UINT64_C(100000000000), 0, Positive));
 725 }
 726
 727 TEST_F(DecimalTest, MultiplicationBigExponent)
 728 {
 729     EXPECT_EQ(encode(1, 1022, Positive), encode(1, 1022, Positive) * encode(1, 0, Positive));
 730     EXPECT_EQ(Decimal::infinity(Positive), encode(1, 1022, Positive) * encode(1, 1022, Positive));
 731     EXPECT_EQ(encode(1, 22, Positive), encode(1, 1022, Positive) * encode(1, -1000, Positive));
 732 }
 733
 734 TEST_F(DecimalTest, MultiplicationSmallExponent)
 735 {
 736     EXPECT_EQ(encode(1, -1022, Positive), encode(1, -1022, Positive) * encode(1, 0, Positive));
 737     EXPECT_EQ(encode(0, 0, Positive), encode(1, -1022, Positive) * encode(1, -1022, Positive));
 738 }
 739
 740 TEST_F(DecimalTest, MultiplicationSpecialValues)
 741 {
 742     const Decimal Infinity(Decimal::infinity(Positive));
 743     const Decimal MinusInfinity(Decimal::infinity(Negative));
 744     const Decimal NaN(Decimal::nan());
 745     const Decimal Ten(10);
 746     const Decimal MinusTen(-10);
 747     const Decimal Zero(Decimal::zero(Positive));
 748     const Decimal MinusZero(Decimal::zero(Negative));
 749
 750     EXPECT_EQ(Infinity, Infinity * Infinity);
 751     EXPECT_EQ(MinusInfinity, Infinity * MinusInfinity);
 752     EXPECT_EQ(MinusInfinity, MinusInfinity * Infinity);
 753     EXPECT_EQ(Infinity, MinusInfinity * MinusInfinity);
 754
 755     EXPECT_EQ(NaN, Infinity * Zero);
 756     EXPECT_EQ(NaN, Zero * MinusInfinity);
 757     EXPECT_EQ(NaN, MinusInfinity * Zero);
 758     EXPECT_EQ(NaN, MinusInfinity * Zero);
 759
 760     EXPECT_EQ(NaN, Infinity * MinusZero);
 761     EXPECT_EQ(NaN, MinusZero * MinusInfinity);
 762     EXPECT_EQ(NaN, MinusInfinity * MinusZero);
 763     EXPECT_EQ(NaN, MinusInfinity * MinusZero);
 764
 765     EXPECT_EQ(Infinity, Infinity * Ten);
 766     EXPECT_EQ(Infinity, Ten * Infinity);
 767     EXPECT_EQ(MinusInfinity, MinusInfinity * Ten);
 768     EXPECT_EQ(MinusInfinity, Ten * MinusInfinity);
 769
 770     EXPECT_EQ(MinusInfinity, Infinity * MinusTen);
 771     EXPECT_EQ(MinusInfinity, MinusTen * Infinity);
 772     EXPECT_EQ(Infinity, MinusInfinity * MinusTen);
 773     EXPECT_EQ(Infinity, MinusTen * MinusInfinity);
 774
 775     EXPECT_EQ(NaN, NaN * NaN);
 776     EXPECT_EQ(NaN, NaN * Ten);
 777     EXPECT_EQ(NaN, Ten * NaN);
 778
 779     EXPECT_EQ(NaN, NaN * Infinity);
 780     EXPECT_EQ(NaN, NaN * MinusInfinity);
 781     EXPECT_EQ(NaN, Infinity * NaN);
 782     EXPECT_EQ(NaN, MinusInfinity * NaN);
 783 }
 784
 785 TEST_F(DecimalTest, Negate)
 786 {
 787     EXPECT_EQ(encode(0, 0, Negative), -encode(0, 0, Positive));
 788     EXPECT_EQ(encode(0, 0, Positive), -encode(0, 0, Negative));
 789
 790     EXPECT_EQ(encode(0, 10, Negative), -encode(0, 10, Positive));
 791     EXPECT_EQ(encode(0, 10, Positive), -encode(0, 10, Negative));
 792
 793     EXPECT_EQ(encode(0, -10, Negative), -encode(0, -10, Positive));
 794     EXPECT_EQ(encode(0, -10, Positive), -encode(0, -10, Negative));
 795
 796     EXPECT_EQ(encode(1, 0, Negative), -encode(1, 0, Positive));
 797     EXPECT_EQ(encode(1, 0, Positive), -encode(1, 0, Negative));
 798
 799     EXPECT_EQ(encode(1, 10, Negative), -encode(1, 10, Positive));
 800     EXPECT_EQ(encode(1, 10, Positive), -encode(1, 10, Negative));
 801
 802     EXPECT_EQ(encode(1, -10, Negative), -encode(1, -10, Positive));
 803     EXPECT_EQ(encode(1, -10, Positive), -encode(1, -10, Negative));
 804 }
 805
 806 TEST_F(DecimalTest, NegateBigExponent)
 807 {
 808     EXPECT_EQ(encode(1, 1000, Negative), -encode(1, 1000, Positive));
 809     EXPECT_EQ(encode(1, 1000, Positive), -encode(1, 1000, Negative));
 810 }
 811
 812 TEST_F(DecimalTest, NegateSmallExponent)
 813 {
 814     EXPECT_EQ(encode(1, -1000, Negative), -encode(1, -1000, Positive));
 815     EXPECT_EQ(encode(1, -1000, Positive), -encode(1, -1000, Negative));
 816 }
 817
 818 TEST_F(DecimalTest, NegateSpecialValues)
 819 {
 820     EXPECT_EQ(Decimal::infinity(Negative), -Decimal::infinity(Positive));
 821     EXPECT_EQ(Decimal::infinity(Positive), -Decimal::infinity(Negative));
 822     EXPECT_EQ(Decimal::nan(), -Decimal::nan());
 823 }
 824
 825 TEST_F(DecimalTest, Predicates)
 826 {
 827     EXPECT_TRUE(Decimal::zero(Positive).isFinite());
 828     EXPECT_FALSE(Decimal::zero(Positive).isInfinity());
 829     EXPECT_FALSE(Decimal::zero(Positive).isNaN());
 830     EXPECT_TRUE(Decimal::zero(Positive).isPositive());
 831     EXPECT_FALSE(Decimal::zero(Positive).isNegative());
 832     EXPECT_FALSE(Decimal::zero(Positive).isSpecial());
 833     EXPECT_TRUE(Decimal::zero(Positive).isZero());
 834
 835     EXPECT_TRUE(Decimal::zero(Negative).isFinite());
 836     EXPECT_FALSE(Decimal::zero(Negative).isInfinity());
 837     EXPECT_FALSE(Decimal::zero(Negative).isNaN());
 838     EXPECT_FALSE(Decimal::zero(Negative).isPositive());
 839     EXPECT_TRUE(Decimal::zero(Negative).isNegative());
 840     EXPECT_FALSE(Decimal::zero(Negative).isSpecial());
 841     EXPECT_TRUE(Decimal::zero(Negative).isZero());
 842
 843     EXPECT_TRUE(Decimal(123).isFinite());
 844     EXPECT_FALSE(Decimal(123).isInfinity());
 845     EXPECT_FALSE(Decimal(123).isNaN());
 846     EXPECT_TRUE(Decimal(123).isPositive());
 847     EXPECT_FALSE(Decimal(123).isNegative());
 848     EXPECT_FALSE(Decimal(123).isSpecial());
 849     EXPECT_FALSE(Decimal(123).isZero());
 850
 851     EXPECT_TRUE(Decimal(-123).isFinite());
 852     EXPECT_FALSE(Decimal(-123).isInfinity());
 853     EXPECT_FALSE(Decimal(-123).isNaN());
 854     EXPECT_FALSE(Decimal(-123).isPositive());
 855     EXPECT_TRUE(Decimal(-123).isNegative());
 856     EXPECT_FALSE(Decimal(-123).isSpecial());
 857     EXPECT_FALSE(Decimal(-123).isZero());
 858 }
 859
 860 TEST_F(DecimalTest, PredicatesSpecialValues)
 861 {
 862     EXPECT_FALSE(Decimal::infinity(Positive).isFinite());
 863     EXPECT_TRUE(Decimal::infinity(Positive).isInfinity());
 864     EXPECT_FALSE(Decimal::infinity(Positive).isNaN());
 865     EXPECT_TRUE(Decimal::infinity(Positive).isPositive());
 866     EXPECT_FALSE(Decimal::infinity(Positive).isNegative());
 867     EXPECT_TRUE(Decimal::infinity(Positive).isSpecial());
 868     EXPECT_FALSE(Decimal::infinity(Positive).isZero());
 869
 870     EXPECT_FALSE(Decimal::infinity(Negative).isFinite());
 871     EXPECT_TRUE(Decimal::infinity(Negative).isInfinity());
 872     EXPECT_FALSE(Decimal::infinity(Negative).isNaN());
 873     EXPECT_FALSE(Decimal::infinity(Negative).isPositive());
 874     EXPECT_TRUE(Decimal::infinity(Negative).isNegative());
 875     EXPECT_TRUE(Decimal::infinity(Negative).isSpecial());
 876     EXPECT_FALSE(Decimal::infinity(Negative).isZero());
 877
 878     EXPECT_FALSE(Decimal::nan().isFinite());
 879     EXPECT_FALSE(Decimal::nan().isInfinity());
 880     EXPECT_TRUE(Decimal::nan().isNaN());
 881     EXPECT_TRUE(Decimal::nan().isSpecial());
 882     EXPECT_FALSE(Decimal::nan().isZero());
 883 }
 884
 885 // LayoutTests/fast/forms/number/number-stepup-stepdown-from-renderer
 886 TEST_F(DecimalTest, RealWorldExampleNumberStepUpStepDownFromRenderer)
 887 {
 888     EXPECT_DECIMAL_STREQ("10", stepDown("0", "100", "10", "19", 1));
 889     EXPECT_DECIMAL_STREQ("90", stepUp("0", "99", "10", "89", 1));
 890     EXPECT_DECIMAL_STREQ("1", stepUp("0", "1", "0.33333333333333333", "0", 3)); // step=1/3
 891     EXPECT_DECIMAL_STREQ("0.01", stepUp("0", "0.01", "0.0033333333333333333", "0", 3)); // step=1/300
 892     EXPECT_DECIMAL_STREQ("1", stepUp("0", "1", "0.003921568627450980", "0", 255)); // step=1/255
 893     EXPECT_DECIMAL_STREQ("1", stepUp("0", "1", "0.1", "0", 10));
 894 }
 895
 896 TEST_F(DecimalTest, RealWorldExampleNumberStepUpStepDownFromRendererRounding)
 897 {
 898     EXPECT_DECIMAL_STREQ("5.015", stepUp("0", "100", "0.005", "5.005", 2));
 899     EXPECT_DECIMAL_STREQ("5.06", stepUp("0", "100", "0.005", "5.005", 11));
 900     EXPECT_DECIMAL_STREQ("5.065", stepUp("0", "100", "0.005", "5.005", 12));
 901
 902     EXPECT_DECIMAL_STREQ("5.015", stepUp("4", "9", "0.005", "5.005", 2));
 903     EXPECT_DECIMAL_STREQ("5.06", stepUp("4", "9", "0.005", "5.005", 11));
 904     EXPECT_DECIMAL_STREQ("5.065", stepUp("4", "9", "0.005", "5.005", 12));
 905 }
 906
 907 TEST_F(DecimalTest, RealWorldExampleRangeStepUpStepDown)
 908 {
 909     EXPECT_DECIMAL_STREQ("1e+38", stepUp("0", "1E38", "1", "1E38", 9));
 910     EXPECT_DECIMAL_STREQ("1e+38", stepDown("0", "1E38", "1", "1E38", 9));
 911 }
 912
 913 TEST_F(DecimalTest, Remainder)
 914 {
 915     EXPECT_EQ(encode(21, -1, Positive), encode(21, -1, Positive).remainder(3));
 916     EXPECT_EQ(Decimal(1), Decimal(10).remainder(3));
 917     EXPECT_EQ(Decimal(1), Decimal(10).remainder(-3));
 918     EXPECT_EQ(encode(1, 0, Negative), Decimal(-10).remainder(3));
 919     EXPECT_EQ(Decimal(-1), Decimal(-10).remainder(-3));
 920     EXPECT_EQ(encode(2, -1, Positive), encode(102, -1, Positive).remainder(1));
 921     EXPECT_EQ(encode(1, -1, Positive), Decimal(10).remainder(encode(3, -1, Positive)));
 922     EXPECT_EQ(Decimal(1), encode(36, -1, Positive).remainder(encode(13, -1, Positive)));
 923     EXPECT_EQ(encode(1, 86, Positive), (encode(1234, 100, Positive).remainder(Decimal(3))));
 924     EXPECT_EQ(Decimal(500), (Decimal(500).remainder(1000)));
 925     EXPECT_EQ(Decimal(-500), (Decimal(-500).remainder(1000)));
 926 }
 927
 928 TEST_F(DecimalTest, RemainderBigExponent)
 929 {
 930     EXPECT_EQ(encode(0, 1022, Positive), encode(1, 1022, Positive).remainder(encode(1, 0, Positive)));
 931     EXPECT_EQ(encode(0, 1022, Positive), encode(1, 1022, Positive).remainder(encode(1, 1022, Positive)));
 932     EXPECT_EQ(Decimal::infinity(Positive), encode(1, 1022, Positive).remainder(encode(1, -1000, Positive)));
 933 }
 934
 935 TEST_F(DecimalTest, RemainderSmallExponent)
 936 {
 937     EXPECT_EQ(encode(1, -1022, Positive), encode(1, -1022, Positive).remainder(encode(1, 0, Positive)));
 938     EXPECT_EQ(encode(0, -1022, Positive), encode(1, -1022, Positive).remainder(encode(1, -1022, Positive)));
 939 }
 940
 941 TEST_F(DecimalTest, RemainderSpecialValues)
 942 {
 943     EXPECT_EQ(Decimal::infinity(Positive), Decimal::infinity(Positive).remainder(1));
 944     EXPECT_EQ(Decimal::infinity(Negative), Decimal::infinity(Negative).remainder(1));
 945     EXPECT_EQ(Decimal::nan(), Decimal::nan().remainder(1));
 946
 947     EXPECT_EQ(Decimal::infinity(Negative), Decimal::infinity(Positive).remainder(-1));
 948     EXPECT_EQ(Decimal::infinity(Positive), Decimal::infinity(Negative).remainder(-1));
 949     EXPECT_EQ(Decimal::nan(), Decimal::nan().remainder(-1));
 950
 951     EXPECT_EQ(Decimal::infinity(Positive), Decimal::infinity(Positive).remainder(3));
 952     EXPECT_EQ(Decimal::infinity(Negative), Decimal::infinity(Negative).remainder(3));
 953     EXPECT_EQ(Decimal::nan(), Decimal::nan().remainder(3));
 954
 955     EXPECT_EQ(Decimal::infinity(Negative), Decimal::infinity(Positive).remainder(-1));
 956     EXPECT_EQ(Decimal::infinity(Positive), Decimal::infinity(Negative).remainder(-1));
 957     EXPECT_EQ(Decimal::nan(), Decimal::nan().remainder(-1));
 958
 959     EXPECT_EQ(Decimal::nan(), Decimal(1).remainder(Decimal::infinity(Positive)));
 960     EXPECT_EQ(Decimal::nan(), Decimal(1).remainder(Decimal::infinity(Negative)));
 961     EXPECT_EQ(Decimal::nan(), Decimal(1).remainder(Decimal::nan()));
 962 }
 963
 964 TEST_F(DecimalTest, Round)
 965 {
 966     EXPECT_EQ(Decimal(1), (Decimal(9) / Decimal(10)).round());
 967     EXPECT_EQ(Decimal(25), (Decimal(5) / fromString("0.200")).round());
 968     EXPECT_EQ(Decimal(3), (Decimal(5) / Decimal(2)).round());
 969     EXPECT_EQ(Decimal(1), (Decimal(2) / Decimal(3)).round());
 970     EXPECT_EQ(Decimal(3), (Decimal(10) / Decimal(3)).round());
 971     EXPECT_EQ(Decimal(3), (Decimal(1) / fromString("0.3")).round());
 972     EXPECT_EQ(Decimal(10), (Decimal(1) / fromString("0.1")).round());
 973     EXPECT_EQ(Decimal(5), (Decimal(1) / fromString("0.2")).round());
 974     EXPECT_EQ(Decimal(10), (fromString("10.2") / 1).round());
 975     EXPECT_EQ(encode(1234, 100, Positive), encode(1234, 100, Positive).round());
 976
 977     EXPECT_EQ(Decimal(2), encode(190002, -5, Positive).round());
 978     EXPECT_EQ(Decimal(2), encode(150002, -5, Positive).round());
 979     EXPECT_EQ(Decimal(2), encode(150000, -5, Positive).round());
 980     EXPECT_EQ(Decimal(12), encode(12492, -3, Positive).round());
 981     EXPECT_EQ(Decimal(13), encode(12502, -3, Positive).round());
 982
 983     EXPECT_EQ(Decimal(-2), encode(190002, -5, Negative).round());
 984     EXPECT_EQ(Decimal(-2), encode(150002, -5, Negative).round());
 985     EXPECT_EQ(Decimal(-2), encode(150000, -5, Negative).round());
 986     EXPECT_EQ(Decimal(-12), encode(12492, -3, Negative).round());
 987     EXPECT_EQ(Decimal(-13), encode(12502, -3, Negative).round());
 988 }
 989
 990 TEST_F(DecimalTest, RoundSpecialValues)
 991 {
 992     EXPECT_EQ(Decimal::infinity(Positive), Decimal::infinity(Positive).round());
 993     EXPECT_EQ(Decimal::infinity(Negative), Decimal::infinity(Negative).round());
 994     EXPECT_EQ(Decimal::nan(), Decimal::nan().round());
 995 }
 996
 997 TEST_F(DecimalTest, Subtract)
 998 {
 999     EXPECT_EQ(encode(0, 0, Positive), Decimal(0) - Decimal(0));
1000     EXPECT_EQ(encode(3, 0, Positive), Decimal(2) - Decimal(-1));
1001     EXPECT_EQ(encode(3, 0, Negative), Decimal(-1) - Decimal(2));
1002     EXPECT_EQ(encode(98, 0, Positive), Decimal(99) - Decimal(1));
1003     EXPECT_EQ(encode(0, 0, Positive), Decimal(-50) - Decimal(-50));
1004     EXPECT_EQ(encode(UINT64_C(1000000000000000), 35, Positive), encode(1, 50, Positive) - Decimal(1));
1005     EXPECT_EQ(encode(UINT64_C(1000000000000000), 35, Negative), Decimal(1) - encode(1, 50, Positive));
1006 }
1007
1008 TEST_F(DecimalTest, SubtractBigExponent)
1009 {
1010     EXPECT_EQ(encode(1, 1022, Positive), encode(1, 1022, Positive) - encode(1, 0, Positive));
1011     EXPECT_EQ(encode(0, 0, Positive), encode(1, 1022, Positive) - encode(1, 1022, Positive));
1012     EXPECT_EQ(encode(1, 1022, Positive), encode(1, 1022, Positive) + encode(1, -1000, Positive));
1013 }
1014
1015 TEST_F(DecimalTest, SubtractSmallExponent)
1016 {
1017     EXPECT_EQ(encode(UINT64_C(10000000000000000), -16, Negative), encode(1, -1022, Positive) - encode(1, 0, Positive));
1018     EXPECT_EQ(encode(0, 0, Positive), encode(1, -1022, Positive) - encode(1, -1022, Positive));
1019 }
1020
1021 TEST_F(DecimalTest, SubtractSpecialValues)
1022 {
1023     const Decimal Infinity(Decimal::infinity(Positive));
1024     const Decimal MinusInfinity(Decimal::infinity(Negative));
1025     const Decimal NaN(Decimal::nan());
1026     const Decimal Ten(10);
1027
1028     EXPECT_EQ(NaN, Infinity - Infinity);
1029     EXPECT_EQ(Infinity, Infinity - MinusInfinity);
1030     EXPECT_EQ(MinusInfinity, MinusInfinity - Infinity);
1031     EXPECT_EQ(NaN, MinusInfinity - MinusInfinity);
1032
1033     EXPECT_EQ(Infinity, Infinity - Ten);
1034     EXPECT_EQ(MinusInfinity, Ten - Infinity);
1035     EXPECT_EQ(MinusInfinity, MinusInfinity - Ten);
1036     EXPECT_EQ(Infinity, Ten - MinusInfinity);
1037
1038     EXPECT_EQ(NaN, NaN - NaN);
1039     EXPECT_EQ(NaN, NaN - Ten);
1040     EXPECT_EQ(NaN, Ten - NaN);
1041
1042     EXPECT_EQ(NaN, NaN - Infinity);
1043     EXPECT_EQ(NaN, NaN - MinusInfinity);
1044     EXPECT_EQ(NaN, Infinity - NaN);
1045     EXPECT_EQ(NaN, MinusInfinity - NaN);
1046 }
1047
1048 TEST_F(DecimalTest, ToDouble)
1049 {
1050     EXPECT_EQ(0.0, encode(0, 0, Positive).toDouble());
1051     EXPECT_EQ(-0.0, encode(0, 0, Negative).toDouble());
1052
1053     EXPECT_EQ(1.0, encode(1, 0, Positive).toDouble());
1054     EXPECT_EQ(-1.0, encode(1, 0, Negative).toDouble());
1055
1056     EXPECT_EQ(0.1, encode(1, -1, Positive).toDouble());
1057     EXPECT_EQ(-0.1, encode(1, -1, Negative).toDouble());
1058     EXPECT_EQ(0.3, encode(3, -1, Positive).toDouble());
1059     EXPECT_EQ(-0.3, encode(3, -1, Negative).toDouble());
1060     EXPECT_EQ(0.6, encode(6, -1, Positive).toDouble());
1061     EXPECT_EQ(-0.6, encode(6, -1, Negative).toDouble());
1062     EXPECT_EQ(0.7, encode(7, -1, Positive).toDouble());
1063     EXPECT_EQ(-0.7, encode(7, -1, Negative).toDouble());
1064
1065     EXPECT_EQ(0.01, encode(1, -2, Positive).toDouble());
1066     EXPECT_EQ(0.001, encode(1, -3, Positive).toDouble());
1067     EXPECT_EQ(0.0001, encode(1, -4, Positive).toDouble());
1068     EXPECT_EQ(0.00001, encode(1, -5, Positive).toDouble());
1069
1070     EXPECT_EQ(1e+308, encode(1, 308, Positive).toDouble());
1071     EXPECT_EQ(1e-307, encode(1, -307, Positive).toDouble());
1072
1073     EXPECT_TRUE(std::isinf(encode(1, 1000, Positive).toDouble()));
1074     EXPECT_EQ(0.0, encode(1, -1000, Positive).toDouble());
1075 }
1076
1077 TEST_F(DecimalTest, ToDoubleSpecialValues)
1078 {
1079     EXPECT_TRUE(std::isinf(Decimal::infinity(Decimal::Positive).toDouble()));
1080     EXPECT_TRUE(std::isinf(Decimal::infinity(Decimal::Negative).toDouble()));
1081     EXPECT_TRUE(std::isnan(Decimal::nan().toDouble()));
1082 }
1083
1084 TEST_F(DecimalTest, ToString)
1085 {
1086     EXPECT_DECIMAL_STREQ("0", Decimal::zero(Positive));
1087     EXPECT_DECIMAL_STREQ("-0", Decimal::zero(Negative));
1088     EXPECT_DECIMAL_STREQ("1", Decimal(1));
1089     EXPECT_DECIMAL_STREQ("-1", Decimal(-1));
1090     EXPECT_DECIMAL_STREQ("1234567", Decimal(1234567));
1091     EXPECT_DECIMAL_STREQ("-1234567", Decimal(-1234567));
1092     EXPECT_DECIMAL_STREQ("0.5", encode(5, -1, Positive));
1093     EXPECT_DECIMAL_STREQ("-0.5", encode(5, -1, Negative));
1094     EXPECT_DECIMAL_STREQ("12.345", encode(12345, -3, Positive));
1095     EXPECT_DECIMAL_STREQ("-12.345", encode(12345, -3, Negative));
1096     EXPECT_DECIMAL_STREQ("0.12345", encode(12345, -5, Positive));
1097     EXPECT_DECIMAL_STREQ("-0.12345", encode(12345, -5, Negative));
1098     EXPECT_DECIMAL_STREQ("50", encode(50, 0, Positive));
1099     EXPECT_DECIMAL_STREQ("-50", encode(50, 0, Negative));
1100     EXPECT_DECIMAL_STREQ("5e+1", encode(5, 1, Positive));
1101     EXPECT_DECIMAL_STREQ("-5e+1", encode(5, 1, Negative));
1102     EXPECT_DECIMAL_STREQ("5.678e+103", encode(5678, 100, Positive));
1103     EXPECT_DECIMAL_STREQ("-5.678e+103", encode(5678, 100, Negative));
1104     EXPECT_DECIMAL_STREQ("5.678e-97", encode(5678, -100, Positive));
1105     EXPECT_DECIMAL_STREQ("-5.678e-97", encode(5678, -100, Negative));
1106     EXPECT_DECIMAL_STREQ("8639999913600001", encode(UINT64_C(8639999913600001), 0, Positive));
1107     EXPECT_DECIMAL_STREQ("9007199254740991", encode((static_cast<uint64_t>(1) << DBL_MANT_DIG) - 1, 0, Positive));
1108     EXPECT_DECIMAL_STREQ("99999999999999999", encode(UINT64_C(99999999999999999), 0, Positive));
1109     EXPECT_DECIMAL_STREQ("9.9999999999999999e+17", encode(UINT64_C(99999999999999999), 1, Positive));
1110     EXPECT_DECIMAL_STREQ("9.9999999999999999e+18", encode(UINT64_C(99999999999999999), 2, Positive));
1111     EXPECT_DECIMAL_STREQ("1e+16", encode(UINT64_C(99999999999999999), -1, Positive));
1112     EXPECT_DECIMAL_STREQ("1000000000000000", encode(UINT64_C(99999999999999999), -2, Positive));
1113     EXPECT_DECIMAL_STREQ("1", encode(UINT64_C(99999999999999999), -17, Positive));
1114     EXPECT_DECIMAL_STREQ("0.001", encode(UINT64_C(99999999999999999), -20, Positive));
1115     EXPECT_DECIMAL_STREQ("1e-83", encode(UINT64_C(99999999999999999), -100, Positive));
1116 }
1117
1118 TEST_F(DecimalTest, ToStringSpecialValues)
1119 {
1120     EXPECT_DECIMAL_STREQ("Infinity", Decimal::infinity(Positive));
1121     EXPECT_DECIMAL_STREQ("-Infinity", Decimal::infinity(Negative));
1122     EXPECT_DECIMAL_STREQ("NaN", Decimal::nan());
1123 }