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 WebCore { 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 WebCore 52 53 using namespace WebCore; 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, Ceiling) 221 { 222 EXPECT_EQ(Decimal(1), Decimal(1).ceiling()); 223 EXPECT_EQ(Decimal(1), encode(1, -10, Positive).ceiling()); 224 EXPECT_EQ(Decimal(2), encode(11, -1, Positive).ceiling()); 225 EXPECT_EQ(Decimal(2), encode(13, -1, Positive).ceiling()); 226 EXPECT_EQ(Decimal(2), encode(15, -1, Positive).ceiling()); 227 EXPECT_EQ(Decimal(2), encode(19, -1, Positive).ceiling()); 228 EXPECT_EQ(Decimal(2), encode(151, -2, Positive).ceiling()); 229 EXPECT_EQ(Decimal(2), encode(101, -2, Positive).ceiling()); 230 EXPECT_EQ(Decimal(1), encode(199, -3, Positive).ceiling()); 231 EXPECT_EQ(Decimal(2), encode(199, -2, Positive).ceiling()); 232 EXPECT_EQ(Decimal(3), encode(209, -2, Positive).ceiling()); 233 234 EXPECT_EQ(Decimal(-1), Decimal(-1).ceiling()); 235 EXPECT_EQ(Decimal(0), encode(1, -10, Negative).ceiling()); 236 EXPECT_EQ(Decimal(-1), encode(11, -1, Negative).ceiling()); 237 EXPECT_EQ(Decimal(-1), encode(13, -1, Negative).ceiling()); 238 EXPECT_EQ(Decimal(-1), encode(15, -1, Negative).ceiling()); 239 EXPECT_EQ(Decimal(-1), encode(19, -1, Negative).ceiling()); 240 EXPECT_EQ(Decimal(-1), encode(151, -2, Negative).ceiling()); 241 EXPECT_EQ(Decimal(-1), encode(101, -2, Negative).ceiling()); 242 EXPECT_EQ(Decimal(0), encode(199, -3, Negative).ceiling()); 243 EXPECT_EQ(Decimal(-1), encode(199, -2, Negative).ceiling()); 244 EXPECT_EQ(Decimal(-2), encode(209, -2, Negative).ceiling()); 245 } 246 247 TEST_F(DecimalTest, CeilingBigExponent) 248 { 249 EXPECT_EQ(encode(1, 1000, Positive), encode(1, 1000, Positive).ceiling()); 250 EXPECT_EQ(encode(1, 1000, Negative), encode(1, 1000, Negative).ceiling()); 251 } 252 253 TEST_F(DecimalTest, CeilingSmallExponent) 254 { 255 EXPECT_EQ(encode(1, 0, Positive), encode(1, -1000, Positive).ceiling()); 256 EXPECT_EQ(encode(0, 0, Negative), encode(1, -1000, Negative).ceiling()); 257 } 258 259 TEST_F(DecimalTest, CeilingSpecialValues) 260 { 261 EXPECT_EQ(Decimal::infinity(Positive), Decimal::infinity(Positive).ceiling()); 262 EXPECT_EQ(Decimal::infinity(Negative), Decimal::infinity(Negative).ceiling()); 263 EXPECT_EQ(Decimal::nan(), Decimal::nan().ceiling()); 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 } 1124
