Attachment #144276 for bug #87360

View Details Raw Unified Return to Bug 87360

| Differences between



2012-05-24  Yoshifumi Inoue  <yosin@chromium.org>

        [Platform] Introduce Decimal class for Number/Range input type.
        https://bugs.webkit.org/show_bug.cgi?id=87360

        Reviewed by NOBODY (OOPS!).

        This patch added new class Decimal for decimal arithmatic in two
        files: platform/Decimal.cpp and Decimal.h with unit test.

        Test: WebKit/chromium/tests/DecimalTest.cpp

        * CMakeLists.txt:
        * GNUmakefile.list.am:
        * Target.pri:
        * WebCore.gypi:
        * WebCore.vcproj/WebCore.vcproj:
        * WebCore.xcodeproj/project.pbxproj:
        * platform/Decimal.cpp: Added.
        (WebCore):
        (DecimalPrivate):
        (SpecialValueHandler):
        (UInt128):
        (WebCore::DecimalPrivate::UInt128::high):
        (WebCore::DecimalPrivate::UInt128::low):
        (WebCore::DecimalPrivate::UInt128::isZero):
        (WebCore::DecimalPrivate::countDigits):
        (WebCore::DecimalPrivate::multiplyHigh):
        (WebCore::DecimalPrivate::power):
        (WebCore::DecimalPrivate::scaleDown):
        (WebCore::DecimalPrivate::scaleUp):
        (WebCore::DecimalPrivate::SpecialValueHandler::SpecialValueHandler):
        (WebCore::DecimalPrivate::SpecialValueHandler::handle):
        (WebCore::DecimalPrivate::SpecialValueHandler::value):
        (WebCore::DecimalPrivate::UInt128::UInt128):
        (WebCore::DecimalPrivate::UInt128::operator /=):
        (WebCore::DecimalPrivate::UInt128::multiply):
        (WebCore::Decimal::EncodedData::EncodedData):
        (WebCore::Decimal::EncodedData::coefficient):
        (WebCore::Decimal::EncodedData::formatClass)
        (WebCore::Decimal::EncodedData::exponent):
        (WebCore::Decimal::EncodedData::isFinite):
        (WebCore::Decimal::EncodedData::isSpecial):
        (WebCore::Decimal::EncodedData::isZero):
        (WebCore::Decimal::EncodedData::sign):
        (WebCore::Decimal::EncodedData::setSign):
        (WebCore::Decimal::Decimal):
        (WebCore::Decimal::operator =):
        (WebCore::Decimal::operator +=):
        (WebCore::Decimal::operator -=):
        (WebCore::Decimal::operator *=):
        (WebCore::Decimal::operator /=):
        (WebCore::Decimal::operator -):
        (WebCore::Decimal::operator +):
        (WebCore::Decimal::operator *):
        (WebCore::Decimal::operator /):
        (WebCore::Decimal::operator==):
        (WebCore::Decimal::operator!=):
        (WebCore::Decimal::operator <):
        (WebCore::Decimal::operator <=):
        (WebCore::Decimal::operator >):
        (WebCore::Decimal::operator >=):
        (WebCore::Decimal::exponent):
        (WebCore::Decimal::sign):
        (WebCore::Decimal::abs):
        (WebCore::Decimal::ceiling):
        (WebCore::Decimal::compareTo):
        (WebCore::Decimal::fastEquals):
        (WebCore::Decimal::floor):
        (WebCore::Decimal::fromString):
        (WebCore::Decimal::infinity):
        (WebCore::Decimal::nan):
        (WebCore::Decimal::remainder):
        (WebCore::Decimal::round):
        (WebCore::Decimal::toString):
        (WebCore::Decimal::zero):
        * platform/Decimal.h: Added.
        (WebCore::Decimal::isFinite):
        (WebCore::Decimal::isNegative):
        (WebCore::Decimal::isPositive):
        (WebCore::Decimal::isSpecial):
        (WebCore::Decimal::isZero):
        (WebCore::Decimal::value):
        (WebCore::Decimal::invertSign):

2012-05-27  Yoshifumi Inoue  <yosin@chromium.org>

        [WTF] Introduce UINT64_C to MathExtras.h



2012-05-24  Yoshifumi Inoue  <yosin@chromium.org>

        [Platform] Introduce Decimal class for Number/Range input type.
        https://bugs.webkit.org/show_bug.cgi?id=87360

        Reviewed by NOBODY (OOPS!).

        This patch added unit test for Decimal class.

        * WebKit.gypi:
        * tests/DecimalTest.cpp: Added.
        (WebCore::operator<<): Output Decimal for unit test debugging
        (DecimalTest):
        (DecimalStepRange):
        (DecimalTest::DecimalStepRange::DecimalStepRange):
        (DecimalTest::DecimalStepRange::clampValue):
        (DecimalTest::DecimalTest::encode):
        (DecimalTest::DecimalTest::fromString):
        (DecimalTest::DecimalTest::stepDown):
        (DecimalTest::DecimalTest::stepUp):
        (DecimalTest::TEST_F):

2012-05-25  Ryosuke Niwa  <rniwa@webkit.org>

        Roll chromium DEPS from r139156 to r139184.

Lines 1107-1112 SET(WebCore_SOURCES a/Source/WebCore/CMakeLists.txt_sec1
- a/Source/WebCore/CMakeLists.txt +1 lines
1107	platform/ContentType.cpp	1107	platform/ContentType.cpp
1108	platform/CrossThreadCopier.cpp	1108	platform/CrossThreadCopier.cpp
1109	platform/DateComponents.cpp	1109	platform/DateComponents.cpp
		1110	platform/Decimal.cpp
1110	platform/DragData.cpp	1111	platform/DragData.cpp
1111	platform/DragImage.cpp	1112	platform/DragImage.cpp
1112	platform/EventTracer.cpp	1113	platform/EventTracer.cpp

Lines 3115-3120 webcore_sources += \ a/Source/WebCore/GNUmakefile.list.am_sec1
- a/Source/WebCore/GNUmakefile.list.am +2 lines
3115	Source/WebCore/platform/Cursor.h \	3115	Source/WebCore/platform/Cursor.h \
3116	Source/WebCore/platform/DateComponents.cpp \	3116	Source/WebCore/platform/DateComponents.cpp \
3117	Source/WebCore/platform/DateComponents.h \	3117	Source/WebCore/platform/DateComponents.h \
		3118	Source/WebCore/platform/Decimal.cpp \
		3119	Source/WebCore/platform/Decimal.h \
3118	Source/WebCore/platform/DragData.cpp \	3120	Source/WebCore/platform/DragData.cpp \
3119	Source/WebCore/platform/DragData.h \	3121	Source/WebCore/platform/DragData.h \
3120	Source/WebCore/platform/DragImage.cpp \	3122	Source/WebCore/platform/DragImage.cpp \



    platform/ContentType.cpp \
    platform/CrossThreadCopier.cpp \
    platform/DateComponents.cpp \
    platform/Decimal.cpp \
    platform/DragData.cpp \
    platform/DragImage.cpp \
    platform/EventTracer.cpp \

    platform/ContextMenu.h \
    platform/CrossThreadCopier.h \
    platform/DateComponents.h \
    platform/Decimal.h \
    platform/DragData.h \
    platform/DragImage.h \
    platform/EventTracer.h \



            'platform/CookiesStrategy.h',
            'platform/Cursor.h',
            'platform/DateComponents.h',
            'platform/Decimal.h'
            'platform/DragData.h',
            'platform/DragImage.h',
            'platform/EventTracer.h',

            'platform/CrossThreadCopier.h',
            'platform/Cursor.cpp',
            'platform/DateComponents.cpp',
            'platform/Decimal.cpp',
            'platform/DragData.cpp',
            'platform/DragImage.cpp',
            'platform/EventLoop.h',

Lines 27835-27840 a/Source/WebCore/WebCore.vcproj/WebCore.vcproj_sec1
- a/Source/WebCore/WebCore.vcproj/WebCore.vcproj +8 lines
27835	>	27835	>
27836	</File>	27836	</File>
27837	<File	27837	<File
		27838	RelativePath="..\platform\Decimal.cpp"
		27839	>
		27840	</File>
		27841	<File
		27842	RelativePath="..\platform\Decimal.h"
		27843	>
		27844	</File>
		27845	<File
27838	RelativePath="..\platform\DragData.cpp"	27846	RelativePath="..\platform\DragData.cpp"
27839	>	27847	>
27840	</File>	27848	</File>



/*
 * Copyright (C) 2012 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "Decimal.h"

#include <algorithm>
#include <float.h>

#include <wtf/Assertions.h>
#include <wtf/MathExtras.h>
#include <wtf/Noncopyable.h>
#include <wtf/text/StringBuilder.h>

namespace WebCore {

namespace DecimalPrivate {

static int const ExponentMax = 1023;
static int const ExponentMin = -1023;
static int const Precision = 18;

static const uint64_t MaxCoefficient = UINT64_C(0x16345785D89FFFF); // 999999999999999999 == 18 9's

// This class handles Decimal special values.
class SpecialValueHandler {
    WTF_MAKE_NONCOPYABLE(SpecialValueHandler);
public:
    enum HandleResult {
        BothFinite,
        Bothinfinity,
        EitherNaN,
        LHSIsinfinity,
        RHSIsinfinity,
    };

    SpecialValueHandler(const Decimal& lhs, const Decimal& rhs);
    HandleResult handle();
    Decimal value() const;

private:
    enum Result {
        ResultIsLHS,
        ResultIsRHS,
        ResultIsUnknown,
    };

    const Decimal& m_lhs;
    const Decimal& m_rhs;
    Result m_result;
};

// This class is used for 128 bit unsigned integer arithmetic.
class UInt128 {
public:
    UInt128(uint64_t low, uint64_t high);

    UInt128& operator/=(uint32_t);

    uint64_t high() const { return m_high; }
    uint64_t low() const { return m_low; }

    static UInt128 multiply(uint64_t low, uint64_t high);

private:
    bool isZero() const { return !m_low && !m_high; }

    uint64_t m_high;
    uint64_t m_low;
};

static int countDigits(uint64_t x)
{
    int numberOfDigits = 0;
    uint64_t powerOf10 = 1;
    while (x >= powerOf10) {
        ++numberOfDigits;
        if (powerOf10 >= uint64_t(-1) / 10)
            break;
        powerOf10 *= 10;
    }
    return numberOfDigits;
}

static uint64_t multiplyHigh(uint64_t u, uint64_t v)
{
    const int n = 64;
    const int n2 = n / 2;
    const uint64_t mask = (uint64_t(1) << n2) - 1;
    uint64_t u0 = u & mask;
    uint64_t u1 = u >> n2;
    uint64_t v0 = v & mask;
    uint64_t v1 = v >> n2;
    uint64_t w0 = u0 * v0;
    uint64_t tt = u1 * v0 + (w0 >> n2);
    uint64_t w1 = tt & mask;
    uint64_t w2 = tt >> n2;
    w1 = u0 * v1 + w1;
    return u1 * v1 + w2 + (w1 >> n2);
}

template<typename T>
static T power(T const x, unsigned n)
{
    T y = 1;
    T z = x;
    for (;;) {
        if (n & 1)
            y = y * z;

        n >>= 1;
        if (!n)
            return y;

        z = z * z;
    }
}

static uint64_t scaleDown(uint64_t x, int n)
{
    ASSERT(n >= 0);
    while (n > 0 && x) {
        x /= 10;
        --n;
    }
    return x;
}

static uint64_t scaleUp(uint64_t x, int n)
{
    ASSERT(n >= 0);
    ASSERT(n < Precision);
    uint64_t result = x * power(uint64_t(10), n);
    ASSERT(result >= x);
    return result;
}

SpecialValueHandler::SpecialValueHandler(const Decimal& lhs, const Decimal& rhs)
    : m_lhs(lhs), m_rhs(rhs), m_result(ResultIsUnknown)
{
}

SpecialValueHandler::HandleResult SpecialValueHandler::handle()
{
    if (m_lhs.isFinite() && m_rhs.isFinite())
        return BothFinite;

    const Decimal::FormatClass lhsClass = m_lhs.value().formatClass();
    const Decimal::FormatClass rhsClass = m_rhs.value().formatClass();
    if (lhsClass == Decimal::ClassNaN) {
        m_result = ResultIsLHS;
        return EitherNaN;
     }

    if (rhsClass == Decimal::ClassNaN) {
        m_result = ResultIsRHS;
        return EitherNaN;
     }

    if (lhsClass == Decimal::ClassInfinity)
        return rhsClass == Decimal::ClassInfinity ? Bothinfinity : LHSIsinfinity;

    if (rhsClass == Decimal::ClassInfinity)
        return RHSIsinfinity;

    ASSERT_NOT_REACHED();
    return BothFinite;
}

Decimal SpecialValueHandler::value() const
{
    switch (m_result) {
    case ResultIsLHS:
        return m_lhs;
    case ResultIsRHS:
        return m_rhs;
    case ResultIsUnknown:
    default:
        ASSERT_NOT_REACHED();
        return m_lhs;
    }
}

UInt128::UInt128(uint64_t low, uint64_t high)
    : m_high(high), m_low(low)
{
}

UInt128& UInt128::operator/=(const uint32_t divisor)
{
    if (!m_high) {
        m_low /= divisor;
        return *this;
    }

    uint32_t dividend[4];
    dividend[0] = uint32_t(m_low & uint32_t(-1));
    dividend[1] = uint32_t(m_low >> 32);
    dividend[2] = uint32_t(m_high & uint32_t(-1));
    dividend[3] = uint32_t(m_high >> 32);

    uint32_t quotient[4];
    uint32_t remainder = 0;
    for (int i = 3; i >= 0; --i) {
        const uint64_t work = (uint64_t(remainder) << 32) | dividend[i];
        remainder = uint32_t(work % divisor);
        quotient[i] = uint32_t(work / divisor);
    }
    m_low = quotient[0] | (uint64_t(quotient[1]) << 32);
    m_high = quotient[2] | (uint64_t(quotient[3]) << 32);
    return *this;
}

UInt128 UInt128::multiply(uint64_t u, uint64_t v)
{
    return UInt128(u * v, multiplyHigh(u, v));
}

} // namespace DecimalPrivate

using namespace DecimalPrivate;

Decimal::EncodedData::EncodedData(Sign sign, FormatClass formatClass)
    : m_coefficient(0)
    , m_exponent(0)
    , m_formatClass(formatClass)
    , m_sign(sign)
{
}

Decimal::EncodedData::EncodedData(Sign sign, int exponent, uint64_t coefficient)
    : m_formatClass(coefficient ? ClassNormal : ClassZero)
    , m_sign(sign)
{
    if (exponent >= ExponentMin && exponent <= ExponentMax) {
        while (coefficient >= MaxCoefficient) {
            coefficient /= 10;
            ++exponent;
        }
    }

    if (exponent > ExponentMax) {
        m_coefficient = 0;
        m_exponent = 0;
        m_formatClass = ClassInfinity;
        return;
    }

    if (exponent < ExponentMin) {
        m_coefficient = 0;
        m_exponent = 0;
        m_formatClass = ClassZero;
        return;
    }

    m_coefficient = coefficient;
    m_exponent = int16_t(exponent);
}

bool Decimal::EncodedData::operator==(const EncodedData& another) const
{
    return m_sign == another.m_sign
        && m_formatClass == another.m_formatClass
        && m_exponent == another.m_exponent
        && m_coefficient == another.m_coefficient;
}

Decimal::Decimal(int32_t i32)
    : m_data(i32 < 0 ? Negative : Positive, 0, i32 < 0 ? uint32_t(-i32) : i32)
{
}

Decimal::Decimal(Sign sign, int exponent, uint64_t coefficient)
    : m_data(sign, exponent, coefficient)
{
}

Decimal::Decimal(const EncodedData& data)
    : m_data(data)
{
}

Decimal::Decimal(const Decimal& other)
    : m_data(other.m_data)
{
}

Decimal& Decimal::operator=(const Decimal& other)
{
    m_data = other.m_data;
    return *this;
}

Decimal& Decimal::operator+=(const Decimal& other)
{
    m_data = (*this + other).m_data;
    return *this;
}

Decimal& Decimal::operator-=(const Decimal& other)
{
    m_data = (*this - other).m_data;
    return *this;
}

Decimal& Decimal::operator*=(const Decimal& other)
{
    m_data = (*this * other).m_data;
    return *this;
}

Decimal& Decimal::operator/=(const Decimal& other)
{
    m_data = (*this / other).m_data;
    return *this;
}

Decimal Decimal::operator-() const
{
    Decimal result(*this);
    result.m_data.setSign(invertSign(m_data.sign()));
    return result;
}

Decimal Decimal::operator+(const Decimal& rhs) const
{
    const Decimal& lhs = *this;
    const Sign lhsSign = lhs.sign();
    const Sign rhsSign = rhs.sign();

    SpecialValueHandler handler(lhs, rhs);
    switch (handler.handle()) {
    case SpecialValueHandler::BothFinite:
        break;

    case SpecialValueHandler::Bothinfinity:
        return lhsSign == rhsSign ? lhs : nan();

    case SpecialValueHandler::EitherNaN:
        return handler.value();

    case SpecialValueHandler::LHSIsinfinity:
        return lhs;

    case SpecialValueHandler::RHSIsinfinity:
        return rhs;
    }

    ASSERT(lhs.isFinite());
    ASSERT(rhs.isFinite());

    const int lhsExponent = lhs.exponent();
    const int rhsExponent = rhs.exponent();
    int resultExponent = std::min(lhsExponent, rhsExponent);
    uint64_t lhsCoefficient = lhs.m_data.coefficient();
    uint64_t rhsCoefficient = rhs.m_data.coefficient();

    // Make coefficient aligned.
    if (lhsExponent > rhsExponent) {
        const int numberOfLHSDigits = countDigits(lhsCoefficient);
        if (numberOfLHSDigits) {
            const int lhsShiftAmount = lhsExponent - rhsExponent;
            const int overflow = numberOfLHSDigits + lhsShiftAmount - Precision;
            if (overflow <= 0)
                lhsCoefficient = scaleUp(lhsCoefficient, lhsShiftAmount);
            else {
                lhsCoefficient = scaleUp(lhsCoefficient, lhsShiftAmount - overflow);
                rhsCoefficient = scaleDown(rhsCoefficient, overflow);
                resultExponent += overflow;
            }
        }

    } if (lhsExponent < rhsExponent) {
        const int numberOfRHSDigits = countDigits(rhsCoefficient);
        if (numberOfRHSDigits) {
            const int rhsShiftAmount = rhsExponent - lhsExponent;
            const int overflow = numberOfRHSDigits + rhsShiftAmount - Precision;
            if (overflow <= 0)
                rhsCoefficient = scaleUp(rhsCoefficient, rhsShiftAmount);
            else {
                rhsCoefficient = scaleUp(rhsCoefficient, rhsShiftAmount - overflow);
                lhsCoefficient = scaleDown(lhsCoefficient, overflow);
                resultExponent += overflow;
            }
        }
    }

    uint64_t const result = lhsSign == rhsSign ? lhsCoefficient + rhsCoefficient : lhsCoefficient - rhsCoefficient;
    return lhsSign == Negative && rhsSign == Positive && !result
            ? Decimal(Positive, resultExponent, 0)
            : int64_t(result) >= 0
                ? Decimal(lhsSign, resultExponent, result)
                : Decimal(invertSign(lhsSign), resultExponent, -int64_t(result));
}

Decimal Decimal::operator-(const Decimal& rhs) const
{
    const Decimal& lhs = *this;
    const Sign lhsSign = lhs.sign();
    const Sign rhsSign = rhs.sign();

    SpecialValueHandler handler(lhs, rhs);
    switch (handler.handle()) {
    case SpecialValueHandler::BothFinite:
        break;

    case SpecialValueHandler::Bothinfinity:
        return lhsSign == rhsSign ? nan() : lhs;

    case SpecialValueHandler::EitherNaN:
        return handler.value();

    case SpecialValueHandler::LHSIsinfinity:
        return lhs;

    case SpecialValueHandler::RHSIsinfinity:
        return infinity(invertSign(rhsSign));
    }

    ASSERT(lhs.isFinite());
    ASSERT(rhs.isFinite());

    uint64_t lhsCoefficient = lhs.m_data.coefficient();
    uint64_t rhsCoefficient = rhs.m_data.coefficient();

    const int lhsExponent = lhs.exponent();
    const int rhsExponent = rhs.exponent();
    int resultExponent = std::min(lhsExponent, rhsExponent);

    // Make coefficient aligned.
    if (lhsExponent > rhsExponent) {
        const int numberOfLHSDigits = countDigits(lhsCoefficient);
        if (numberOfLHSDigits) {
            const int lhsShiftAmount = lhsExponent - rhsExponent;
            const int overflow = numberOfLHSDigits + lhsShiftAmount - Precision;
            if (overflow <= 0)
                lhsCoefficient = scaleUp(lhsCoefficient, lhsShiftAmount);
            else {
                lhsCoefficient = scaleUp(lhsCoefficient, lhsShiftAmount - overflow);
                rhsCoefficient = scaleDown(rhsCoefficient, overflow);
                resultExponent += overflow;
            }
        }

    } if (lhsExponent < rhsExponent) {
        const int numberOfRHSDigits = countDigits(rhsCoefficient);
        if (numberOfRHSDigits) {
            const int rhsShiftAmount = rhsExponent - lhsExponent;
            const int overflow = numberOfRHSDigits + rhsShiftAmount - Precision;
            if (overflow <= 0)
                rhsCoefficient = scaleUp(rhsCoefficient, rhsShiftAmount);
            else {
                rhsCoefficient = scaleUp(rhsCoefficient, rhsShiftAmount - overflow);
                lhsCoefficient = scaleDown(lhsCoefficient, overflow);
                resultExponent += overflow;
            }
        }
    }

    uint64_t result = lhsSign == rhsSign ? lhsCoefficient - rhsCoefficient : lhsCoefficient + rhsCoefficient;
    return lhsSign == Negative && rhsSign == Negative && !result
            ? Decimal(Positive, resultExponent, 0)
            : int64_t(result) >= 0
                ? Decimal(lhsSign, resultExponent, result)
                : Decimal(invertSign(lhsSign), resultExponent, -int64_t(result));
}

Decimal Decimal::operator*(const Decimal& rhs) const
{
    const Decimal& lhs = *this;
    const Sign lhsSign = lhs.sign();
    const Sign rhsSign = rhs.sign();
    Sign resultSign = lhsSign == rhsSign ? Positive : Negative;

    SpecialValueHandler handler(lhs, rhs);
    switch (handler.handle()) {
    case SpecialValueHandler::BothFinite: {
        const uint64_t lhsCoefficient = lhs.m_data.coefficient();
        const uint64_t rhsCoefficient = rhs.m_data.coefficient();
        int resultExponent = lhs.exponent() + rhs.exponent();
        UInt128 work(UInt128::multiply(lhsCoefficient, rhsCoefficient));
        while (work.high()) {
          work /= 10;
          ++resultExponent;
        }
        return Decimal(resultSign, resultExponent, work.low());
    }

    case SpecialValueHandler::Bothinfinity:
        return infinity(resultSign);

    case SpecialValueHandler::EitherNaN:
        return handler.value();

    case SpecialValueHandler::LHSIsinfinity:
        return rhs.isZero() ? nan() : infinity(resultSign);

    case SpecialValueHandler::RHSIsinfinity:
        return lhs.isZero() ? nan() : infinity(resultSign);
    }

    ASSERT_NOT_REACHED();
    return nan();
}

Decimal Decimal::operator/(const Decimal& rhs) const
{
    const Decimal& lhs = *this;
    const Sign lhsSign = lhs.sign();
    const Sign rhsSign = rhs.sign();
    Sign resultSign = lhsSign == rhsSign ? Positive : Negative;

    SpecialValueHandler handler(lhs, rhs);
    switch (handler.handle()) {
    case SpecialValueHandler::BothFinite:
        break;

    case SpecialValueHandler::Bothinfinity:
        return nan();

    case SpecialValueHandler::EitherNaN:
        return handler.value();

    case SpecialValueHandler::LHSIsinfinity:
        return infinity(resultSign);

    case SpecialValueHandler::RHSIsinfinity:
        return zero(resultSign);
    }

    ASSERT(lhs.isFinite());
    ASSERT(rhs.isFinite());

    if (rhs.isZero())
        return lhs.isZero() ? nan() : infinity(resultSign);

    int resultExponent = lhs.exponent() - rhs.exponent();

    if (lhs.isZero()) {
        // 0/non-zero => 0
        return Decimal(resultSign, resultExponent, 0);
    }

    uint64_t remainder = lhs.m_data.coefficient();
    const uint64_t divisor = rhs.m_data.coefficient();
    uint64_t result = 0;
    while (result < MaxCoefficient / 100) {
        while (remainder < divisor) {
            remainder *= 10;
            result *= 10;
            --resultExponent;
        }
        result += remainder / divisor;
        remainder %= divisor;
        if (!remainder)
            break;
    }

    if (remainder > divisor / 2)
        ++result;

    return Decimal(resultSign, resultExponent, result);
}

bool Decimal::operator==(const Decimal& rhs) const
{
    return m_data == rhs.m_data || compareTo(rhs).isZero();
}

bool Decimal::operator!=(const Decimal& rhs) const
{
    return !operator==(rhs);
}

bool Decimal::operator<(const Decimal& rhs) const
{
    return !operator>=(rhs);
}

bool Decimal::operator<=(const Decimal& rhs) const
{
    if (m_data == rhs.m_data)
        return true;
    const Decimal result = compareTo(rhs);
    return result.isZero() || result.isNegative();
}

bool Decimal::operator>(const Decimal& rhs) const
{
    return !operator<=(rhs);
}

bool Decimal::operator>=(const Decimal& rhs) const
{
    if (m_data == rhs.m_data)
        return true;
    const Decimal result = compareTo(rhs);
    return result.isZero() || !result.isNegative();
}

int Decimal::exponent() const
{
    return isFinite() ? m_data.exponent() : 0;
}

Decimal::Sign Decimal::sign() const
{
    return m_data.sign();
}

Decimal Decimal::abs() const
{
    Decimal result(*this);
    result.m_data.setSign(Positive);
    return result;
}

// Round toward positive infinity.
// Note: Mac ports defines ceil(x) as wtf_ceil(x), so we can't use name "ceil" here.
Decimal Decimal::ceiling() const
{
    if (isSpecial())
        return *this;

    if (exponent() >= 0)
        return *this;

    uint64_t result = m_data.coefficient();
    const int numberOfDigits = countDigits(result);
    const int numberOfDropDigits = -exponent();
    if (numberOfDigits < numberOfDropDigits)
        return zero(Positive);

    result = scaleDown(result, numberOfDropDigits - 1);
    if (sign() == Positive && result % 10 > 0)
        result += 10;
    result /= 10;
    return Decimal(sign(), 0, result);
}

Decimal Decimal::compareTo(const Decimal& rhs) const
{
    const Decimal result(*this - rhs);
    return result.isZero()
            ? zero(Positive)
            : result.isFinite()
                    ? result
                    : result.isNegative() ? Decimal(-1) : Decimal(1);
}

// Round toward negative infinity.
Decimal Decimal::floor() const
{
    if (isSpecial())
        return *this;

    if (exponent() >= 0)
        return *this;

    uint64_t result = m_data.coefficient();
    const int numberOfDigits = countDigits(result);
    const int numberOfDropDigits = -exponent();
    if (numberOfDigits < numberOfDropDigits)
        return zero(Positive);

    result = scaleDown(result, numberOfDropDigits - 1);
    if (isNegative() && result % 10 > 0)
        result += 10;
    result /= 10;
    return Decimal(sign(), 0, result);
}

Decimal Decimal::fromString(const String& str)
{
    int exponent = 0;
    Sign exponentSign = Positive;
    int numberOfDigits = 0;
    int numberOfDigitsAfterDot = 0;
    int numberOfExtraDigits = 0;
    Sign sign = Positive;

    enum {
        StateDigit,
        StateDot,
        StateDotDigit,
        StateE,
        StateEDigit,
        StateESign,
        StateSign,
        StateStart,
        StateZero,
    } state = StateStart;

    #define HandleCharAndBreak(ch1, next, ...) \
        if (ch == ch1 || ch == ch1 - 'A' + 'a') { \
            __VA_ARGS__; \
            state = next; \
            break; \
        }

    uint64_t accumulator = 0;
    for (unsigned index = 0; index < str.length(); ++index) {
        const int ch = str[index];
        switch (state) {
        case StateDigit:
            if (ch >= '0' && ch <= '9') {
                if (numberOfDigits < Precision) {
                    ++numberOfDigits;
                    accumulator *= 10;
                    accumulator += ch - '0';
                } else
                    ++numberOfExtraDigits;
                break;
            }

            if (ch == '.') {
                state = StateDot;
                break;
            }

            HandleCharAndBreak('E', StateE);
            return nan();

        case StateDot:
            if (ch >= '0' && ch <= '9') {
                if (numberOfDigits < Precision) {
                    ++numberOfDigits;
                    ++numberOfDigitsAfterDot;
                    accumulator *= 10;
                    accumulator += ch - '0';
                }
                state = StateDotDigit;
                break;
            }

        case StateDotDigit:
            if (ch >= '0' && ch <= '9') {
                if (numberOfDigits < Precision) {
                    ++numberOfDigits;
                    ++numberOfDigitsAfterDot;
                    accumulator *= 10;
                    accumulator += ch - '0';
                }
                break;
            }

            HandleCharAndBreak('E', StateE);
            return nan();

        case StateE:
            if (ch == '+') {
                exponentSign = Positive;
                state = StateESign;
                break;
            }

            if (ch == '-') {
                exponentSign = Negative;
                state = StateESign;
                break;
            }

            if (ch >= '0' && ch <= '9') {
                exponent = ch - '0';
                state = StateEDigit;
                break;
            }

            return nan();

        case StateEDigit:
            if (ch >= '0' && ch <= '9') {
                exponent *= 10;
                exponent += ch - '0';
                if (exponent > ExponentMax + Precision)
                    return exponentSign == Negative ? zero(Positive) : infinity(sign);
                state = StateEDigit;
                break;
            }

            return nan();

        case StateESign:
            if (ch >= '0' && ch <= '9') {
                exponent = ch - '0';
                state = StateEDigit;
                break;
            }

            return nan();

        case StateSign:
            if (ch == '0') {
                state = StateZero;
                break;
            }

            if (ch >= '1' && ch <= '9') {
                accumulator = ch - '0';
                numberOfDigits = 1;
                state = StateDigit;
                break;
            }

            return nan();

        case StateStart:
            if (ch == '0') {
                state = StateZero;
                break;
            }

            if (ch >= '1' && ch <= '9') {
                accumulator = ch - '0';
                numberOfDigits = 1;
                state = StateDigit;
                break;
            }

            if (ch == '-') {
                sign = Negative;
                state = StateSign;
                break;
            }

            if (ch == '+') {
                sign = Positive;
                state = StateSign;
                break;
            }

            if (ch == '.') {
                state = StateDot;
                break;
            }

            return nan();

        case StateZero:
            if (ch == '0')
                break;

            if (ch >= '1' && ch <= '9') {
                accumulator = ch - '0';
                numberOfDigits = 1;
                state = StateDigit;
                break;
            }

            if (ch == '.') {
                state = StateDot;
                break;
            }

            HandleCharAndBreak('E', StateE);
            return nan();

        default:
            ASSERT_NOT_REACHED();
            return nan();
        }
    }

    if (state == StateZero)
        return zero(sign);

    if (state == StateDigit || state == StateEDigit || state == StateDotDigit) {
        int resultExponent = exponent * (exponentSign == Negative ? -1 : 1) - numberOfDigitsAfterDot + numberOfExtraDigits;
        if (resultExponent < ExponentMin)
            return zero(Positive);

        const int overflow = resultExponent - ExponentMax + 1;
        if (overflow > 0) {
            if (overflow + numberOfDigits - numberOfDigitsAfterDot > Precision)
                return infinity(sign);
            accumulator = scaleUp(accumulator, overflow);
            resultExponent -= overflow;
        }

        return Decimal(sign, resultExponent, accumulator);
    }

    return nan();
}

Decimal Decimal::infinity(const Sign sign)
{
    return Decimal(EncodedData(sign, ClassInfinity));
}

Decimal Decimal::nan()
{
    return Decimal(EncodedData(Positive, ClassNaN));
}

Decimal Decimal::remainder(const Decimal& rhs) const
{
    const Decimal quotient = (*this / rhs).round();
    return quotient.isSpecial() ? quotient : *this - quotient * rhs;
}

Decimal Decimal::round() const
{
    if (isSpecial())
        return *this;

    if (exponent() >= 0)
        return *this;

    uint64_t result = m_data.coefficient();
    const int numberOfDigits = countDigits(result);
    const int numberOfDropDigits = -exponent();
    if (numberOfDigits < numberOfDropDigits)
        return zero(Positive);

    result = scaleDown(result, numberOfDropDigits - 1);
    if (result % 10 >= 5)
        result += 10;
    result /= 10;
    return Decimal(sign(), 0, result);
}

String Decimal::toString() const
{
    switch (m_data.formatClass()) {
    case ClassInfinity:
        return sign() ? "-Infinity" : "Infinity";

    case ClassNaN:
        return sign() ? "-NaN" : "NaN";

    case ClassNormal:
    case ClassZero:
        break;

    default:
        ASSERT_NOT_REACHED();
        return "";
    }

    StringBuilder builder;
    if (sign())
        builder.append('-');

    int originalExponent = exponent();

    const int maxDigits = DBL_DIG;
    uint64_t coefficient = m_data.coefficient();
    int lastDigit = 0;
    while (countDigits(coefficient) > maxDigits) {
        lastDigit = coefficient % 10;
        coefficient /= 10;
        ++originalExponent;
    }

    if (lastDigit >= 5)
        ++coefficient;

    while (originalExponent < 0 && coefficient && !(coefficient % 10)) {
        coefficient /= 10;
        ++originalExponent;
    }

    const String digits = String::number(coefficient);
    int coefficientLength = int(digits.length());
    const int adjustedExponent = originalExponent + coefficientLength - 1;
    if (originalExponent <= 0 && adjustedExponent >= -6) {
        if (!originalExponent) {
            builder.append(digits);
            return builder.toString();
        }

        if (adjustedExponent >= 0) {
            for (int i = 0; i < coefficientLength; ++i) {
                builder.append(digits[i]);
                if (i == adjustedExponent)
                    builder.append('.');
            }
            return builder.toString();
        }

        builder.append("0.");
        for (int i = adjustedExponent + 1; i < 0; ++i)
            builder.append('0');

        builder.append(digits);

    } else {
        builder.append(digits[0]);
        while (coefficientLength >= 2 && digits[coefficientLength - 1] == '0')
            --coefficientLength;
        if (coefficientLength >= 2) {
            builder.append('.');
            for (int i = 1; i < coefficientLength; ++i)
                builder.append(digits[i]);
        }

        if (adjustedExponent) {
            builder.append(adjustedExponent < 0 ? "e" : "e+");
            builder.append(String::number(adjustedExponent));
        }
    }
    return builder.toString();
}

Decimal Decimal::zero(Sign sign)
{
    return Decimal(EncodedData(sign, ClassZero));
}

} // namespace WebCore



/*
 * Copyright (C) 2012 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef Decimal_h
#define Decimal_h

#include <stdint.h>
#include <wtf/text/WTFString.h>

namespace WebCore {

// This class represents decimal base floating point number.
//
// FIXME: Once all C++ compiler support decimal type, we should replace this
// class to compiler supported one. See below URI for current status of decimal
// type for C++: // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1977.html
class Decimal {
public:
    enum Sign {
        Positive,
        Negative,
    };

    // You should not use FormatClass. This is for implementation.
    enum FormatClass {
        ClassInfinity,
        ClassNormal,
        ClassNaN,
        ClassZero,
    };

    // You should not use EncodedData other than unit testing.
    class EncodedData {
    public:
        EncodedData(Sign, FormatClass);
        EncodedData(Sign, int exponent, uint64_t coefficient);

        bool operator==(const EncodedData&) const;
        bool operator!=(const EncodedData& another) const { return !operator==(another); }

        uint64_t coefficient() const { return m_coefficient; }
        int countDigits() const;
        int exponent() const { return m_exponent; }
        FormatClass formatClass() const { return m_formatClass; }
        bool isFinite() const { return !isSpecial(); }
        bool isSpecial() const { return m_formatClass == ClassInfinity || m_formatClass == ClassNaN; }
        bool isZero() const { return m_formatClass == ClassZero; }
        Sign sign() const { return m_sign; }
        void setSign(Sign sign) { m_sign = sign; }

    private:
        uint64_t m_coefficient;
        int16_t m_exponent;
        FormatClass m_formatClass;
        Sign m_sign;
    };

    Decimal(int32_t = 0);
    Decimal(Sign, int exponent, uint64_t coefficient);
    Decimal(const Decimal&);

    Decimal& operator=(const Decimal&);
    Decimal& operator+=(const Decimal&);
    Decimal& operator-=(const Decimal&);
    Decimal& operator*=(const Decimal&);
    Decimal& operator/=(const Decimal&);

    Decimal operator-() const;

    bool operator==(const Decimal&) const;
    bool operator!=(const Decimal&) const;
    bool operator<(const Decimal&) const;
    bool operator<=(const Decimal&) const;
    bool operator>(const Decimal&) const;
    bool operator>=(const Decimal&) const;

    Decimal operator+(const Decimal&) const;
    Decimal operator-(const Decimal&) const;
    Decimal operator*(const Decimal&) const;
    Decimal operator/(const Decimal&) const;

    int exponent() const;
    bool isFinite() const { return m_data.isFinite(); }
    bool isNegative() const { return sign() == Negative; }
    bool isPositive() const { return sign() == Positive; }
    bool isSpecial() const { return m_data.isSpecial(); }
    bool isZero() const { return m_data.isZero(); }

    Decimal abs() const;
    Decimal ceiling() const;
    Decimal floor() const;
    Decimal remainder(const Decimal&) const;
    Decimal round() const;
    String toString() const;

    static Decimal fromString(const String&);
    static Decimal infinity(Sign);
    static Decimal nan();
    static Decimal zero(Sign);

    // You should not use below methods. We expose them for unit testing.
    explicit Decimal(const EncodedData&);
    const EncodedData& value() const { return m_data; }

private:
    Decimal(double);
    Decimal compareTo(const Decimal&) const;

    static inline Sign invertSign(Sign sign)
    {
        return sign == Negative ? Positive : Negative;
    }

    Sign sign() const;

    EncodedData m_data;
};

} // namespace WebCore

#endif // Decimal_h

Lines 95-100 a/Source/WebKit/chromium/WebKit.gypi_sec1
- a/Source/WebKit/chromium/WebKit.gypi +1 lines
95	'tests/ClipboardChromiumTest.cpp',	95	'tests/ClipboardChromiumTest.cpp',
96	'tests/CompositorFakeGraphicsContext3D.h',	96	'tests/CompositorFakeGraphicsContext3D.h',
97	'tests/CompositorFakeWebGraphicsContext3D.h',	97	'tests/CompositorFakeWebGraphicsContext3D.h',
		98	'tests/DecimalTest.cpp',
98	'tests/DragImageTest.cpp',	99	'tests/DragImageTest.cpp',
99	'tests/DrawingBufferChromiumTest.cpp',	100	'tests/DrawingBufferChromiumTest.cpp',
100	'tests/EventListenerTest.cpp',	101	'tests/EventListenerTest.cpp',



/*
 * Copyright (C) 2012 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "Decimal.h"

#include <gtest/gtest.h>
#include <wtf/MathExtras.h>
#include <wtf/text/CString.h>

namespace WebCore {

std::ostream& operator<<(std::ostream& os, const Decimal& decimal)
{
    Decimal::EncodedData data = decimal.value();
    return os 
        << "encode(" << String::number(data.coefficient()).ascii().data()
        << ", " << String::number(data.exponent()).ascii().data()
        << ", " << (data.sign() == Decimal::Negative ? "Negative" : "Positive")
        << ")=" << decimal.toString().ascii().data();
}

} // namespace WebCore

using namespace WebCore;

// Simulate WebCore/html/StepRange
class DecimalStepRange {
public:
    Decimal maximum;
    Decimal minimum;
    Decimal step;

    DecimalStepRange(const Decimal& minimum, const Decimal& maximum, const Decimal& step)
        : maximum(maximum)
        , minimum(minimum)
        , step(step)
    {
    }

    Decimal clampValue(Decimal value) const
    {
        const Decimal result = minimum + ((value - minimum) / step).round() * step;
        ASSERT(result.isFinite());
        return result > maximum ? result - step : result;
    }
};

class DecimalTest : public ::testing::Test {
protected:
    typedef Decimal::Sign Sign;
    protected: static const Sign Positive = Decimal::Positive;
    protected: static const Sign Negative = Decimal::Negative;

    Decimal encode(uint64_t coefficient, int exponent, Sign sign)
    {
        return Decimal(sign, exponent, coefficient);
    }

    protected: Decimal fromString(const String& string)
    {
        return Decimal::fromString(string);
    }

    protected: String stepDown(const String& minimum, const String& maximum, const String& step, const String& valueString, int numberOfStepTimes)
    {
        DecimalStepRange stepRange(fromString(minimum), fromString(maximum), fromString(step));
        Decimal value = fromString(valueString);
        for (int i = 0; i < numberOfStepTimes; ++i) {
          value -= stepRange.step;
          value = stepRange.clampValue(value);
        }
        return value.toString();
    }

    protected: String stepUp(const String& minimum, const String& maximum, const String& step, const String& valueString, int numberOfStepTimes)
    {
        DecimalStepRange stepRange(fromString(minimum), fromString(maximum), fromString(step));
        Decimal value = fromString(valueString);
        for (int i = 0; i < numberOfStepTimes; ++i) {
          value += stepRange.step;
          value = stepRange.clampValue(value);
        }
        return value.toString();
    }
};

TEST_F(DecimalTest, Abs)
{
    EXPECT_EQ(encode(0, 0, Positive), encode(0, 0, Positive).abs());
    EXPECT_EQ(encode(0, 0, Positive), encode(0, 0, Negative).abs());

    EXPECT_EQ(encode(0, 10, Positive), encode(0, 10, Positive).abs());
    EXPECT_EQ(encode(0, 10, Positive), encode(0, 10, Negative).abs());

    EXPECT_EQ(encode(0, -10, Positive), encode(0, -10, Positive).abs());
    EXPECT_EQ(encode(0, -10, Positive), encode(0, -10, Negative).abs());

    EXPECT_EQ(encode(1, 0, Positive), encode(1, 0, Positive).abs());
    EXPECT_EQ(encode(1, 0, Positive), encode(1, 0, Negative).abs());

    EXPECT_EQ(encode(1, 10, Positive), encode(1, 10, Positive).abs());
    EXPECT_EQ(encode(1, 10, Positive), encode(1, 10, Negative).abs());

    EXPECT_EQ(encode(1, -10, Positive), encode(1, -10, Positive).abs());
    EXPECT_EQ(encode(1, -10, Positive), encode(1, -10, Negative).abs());
}

TEST_F(DecimalTest, Ceiling)
{
    EXPECT_EQ(Decimal(1), Decimal(1).ceiling());
    EXPECT_EQ(Decimal(2), encode(11, -1, Positive).ceiling());
    EXPECT_EQ(Decimal(2), encode(13, -1, Positive).ceiling());
    EXPECT_EQ(Decimal(2), encode(15, -1, Positive).ceiling());
    EXPECT_EQ(Decimal(2), encode(19, -1, Positive).ceiling());

    EXPECT_EQ(Decimal(-1), Decimal(-1).ceiling());
    EXPECT_EQ(Decimal(-1), encode(11, -1, Negative).ceiling());
    EXPECT_EQ(Decimal(-1), encode(13, -1, Negative).ceiling());
    EXPECT_EQ(Decimal(-1), encode(15, -1, Negative).ceiling());
    EXPECT_EQ(Decimal(-1), encode(19, -1, Negative).ceiling());
}

TEST_F(DecimalTest, EncodedData)
{
    EXPECT_EQ(encode(0, 0, Positive), encode(0, 0, Positive));
    EXPECT_EQ(encode(0, 0, Negative), encode(0, 0, Negative));
    EXPECT_EQ(Decimal(1), Decimal(1));
    EXPECT_EQ(encode(1, 0, Negative), encode(1, 0, Negative));
    EXPECT_EQ(Decimal::infinity(Positive), encode(1, 2000, Positive));
    EXPECT_EQ(Decimal::zero(Positive), encode(1, -2000, Positive));
}

TEST_F(DecimalTest, Floor)
{
    EXPECT_EQ(Decimal(1), Decimal(1).floor());
    EXPECT_EQ(Decimal(1), encode(11, -1, Positive).floor());
    EXPECT_EQ(Decimal(1), encode(13, -1, Positive).floor());
    EXPECT_EQ(Decimal(1), encode(15, -1, Positive).floor());
    EXPECT_EQ(Decimal(1), encode(19, -1, Positive).floor());

    EXPECT_EQ(Decimal(-1), Decimal(-1).floor());
    EXPECT_EQ(Decimal(-2), encode(11, -1, Negative).floor());
    EXPECT_EQ(Decimal(-2), encode(13, -1, Negative).floor());
    EXPECT_EQ(Decimal(-2), encode(15, -1, Negative).floor());
    EXPECT_EQ(Decimal(-2), encode(19, -1, Negative).floor());
}

TEST_F(DecimalTest, FromInt32)
{
    EXPECT_EQ(encode(0, 0, Positive), Decimal(0));
    EXPECT_EQ(Decimal(1), Decimal(1));
    EXPECT_EQ(encode(1, 0, Negative), Decimal(-1));
    EXPECT_EQ(encode(100, 0, Positive), Decimal(100));
    EXPECT_EQ(encode(100, 0, Negative), Decimal(-100));
    EXPECT_EQ(encode(0x7FFFFFFF, 0, Positive), Decimal(INT_MAX));
    EXPECT_EQ(encode(0x80000000u, 0, Negative), Decimal(INT_MIN));
}

TEST_F(DecimalTest, FromString)
{
    EXPECT_EQ(encode(0, 0, Positive), fromString("0"));
    EXPECT_EQ(encode(0, 0, Negative), fromString("-0"));
    EXPECT_EQ(Decimal(1), fromString("1"));
    EXPECT_EQ(encode(1, 0, Negative), fromString("-1"));
    EXPECT_EQ(Decimal(1), fromString("01"));
    EXPECT_EQ(encode(3, 0, Positive), fromString("+3"));
    EXPECT_EQ(encode(0, 3, Positive), fromString("0E3"));
    EXPECT_EQ(encode(5, -1, Positive), fromString(".5"));
    EXPECT_EQ(encode(100, 0, Positive), fromString("100"));
    EXPECT_EQ(encode(100, 0, Negative), fromString("-100"));
    EXPECT_EQ(encode(123, -2, Positive), fromString("1.23"));
    EXPECT_EQ(encode(123, -2, Negative), fromString("-1.23"));
    EXPECT_EQ(encode(123, 8, Positive), fromString("1.23E10"));
    EXPECT_EQ(encode(123, 8, Negative), fromString("-1.23E10"));
    EXPECT_EQ(encode(123, 8, Positive), fromString("1.23E+10"));
    EXPECT_EQ(encode(123, 8, Negative), fromString("-1.23E+10"));
    EXPECT_EQ(encode(123, -12, Positive), fromString("1.23E-10"));
    EXPECT_EQ(encode(123, -12, Negative), fromString("-1.23E-10"));
    EXPECT_EQ(encode(5, -7, Positive), fromString("0.0000005"));
    EXPECT_EQ(encode(123, -3, Positive), fromString("0.123"));
    EXPECT_EQ(encode(0, -2, Positive), fromString("00.00"));
    EXPECT_EQ(encode(1, 2, Positive), fromString("1E2"));
    EXPECT_EQ(Decimal::infinity(Positive), fromString("1E20000"));
    EXPECT_EQ(Decimal::zero(Positive), fromString("1E-20000"));
    EXPECT_EQ(encode(1000, 1023, Positive), fromString("1E1026"));
    EXPECT_EQ(Decimal::zero(Positive), fromString("1E-1026"));
    EXPECT_EQ(Decimal::infinity(Positive), fromString("1234567890E1036"));

    // 2^1024
    const uint64_t leadingDigitsOf2PowerOf1024 = UINT64_C(17976931348623159);
    EXPECT_EQ(encode(leadingDigitsOf2PowerOf1024, 292, Positive), fromString("179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216"));
}

// These strings are look like proper number, but we don't accept them.
TEST_F(DecimalTest, FromStringLikeNumber)
{
    EXPECT_EQ(Decimal::nan(), fromString(" 123 "));
    EXPECT_EQ(Decimal::nan(), fromString("1,234"));
    EXPECT_EQ(Decimal::nan(), fromString("INF"));
}

TEST_F(DecimalTest, fromStringTruncated)
{
    EXPECT_EQ(Decimal::nan(), fromString("x"));
    EXPECT_EQ(Decimal::nan(), fromString("0."));
    EXPECT_EQ(Decimal::nan(), fromString("1x"));

    EXPECT_EQ(Decimal::nan(), fromString("1Ex"));
    EXPECT_EQ(Decimal::nan(), fromString("1E2x"));
    EXPECT_EQ(Decimal::nan(), fromString("1E+x"));
}

TEST_F(DecimalTest, Predicates)
{
    EXPECT_TRUE(Decimal::zero(Positive).isFinite());
    EXPECT_TRUE(Decimal::zero(Positive).isPositive());
    EXPECT_FALSE(Decimal::zero(Positive).isNegative());
    EXPECT_FALSE(Decimal::zero(Positive).isSpecial());
    EXPECT_TRUE(Decimal::zero(Positive).isZero());

    EXPECT_TRUE(Decimal::zero(Negative).isFinite());
    EXPECT_FALSE(Decimal::zero(Negative).isPositive());
    EXPECT_TRUE(Decimal::zero(Negative).isNegative());
    EXPECT_FALSE(Decimal::zero(Negative).isSpecial());
    EXPECT_TRUE(Decimal::zero(Negative).isZero());

    EXPECT_TRUE(Decimal(123).isFinite());
    EXPECT_TRUE(Decimal(123).isPositive());
    EXPECT_FALSE(Decimal(123).isNegative());
    EXPECT_FALSE(Decimal(123).isSpecial());
    EXPECT_FALSE(Decimal(123).isZero());

    EXPECT_TRUE(Decimal(-123).isFinite());
    EXPECT_FALSE(Decimal(-123).isPositive());
    EXPECT_TRUE(Decimal(-123).isNegative());
    EXPECT_FALSE(Decimal(-123).isSpecial());
    EXPECT_FALSE(Decimal(-123).isZero());
}

TEST_F(DecimalTest, PredicatesSpecialValues)
{
    EXPECT_FALSE(Decimal::infinity(Positive).isFinite());
    EXPECT_TRUE(Decimal::infinity(Positive).isPositive());
    EXPECT_FALSE(Decimal::infinity(Positive).isNegative());
    EXPECT_TRUE(Decimal::infinity(Positive).isSpecial());
    EXPECT_FALSE(Decimal::infinity(Positive).isZero());

    EXPECT_FALSE(Decimal::infinity(Negative).isFinite());
    EXPECT_FALSE(Decimal::infinity(Negative).isPositive());
    EXPECT_TRUE(Decimal::infinity(Negative).isNegative());
    EXPECT_TRUE(Decimal::infinity(Negative).isSpecial());
    EXPECT_FALSE(Decimal::infinity(Negative).isZero());

    EXPECT_FALSE(Decimal::nan().isFinite());
    EXPECT_TRUE(Decimal::nan().isSpecial());
    EXPECT_FALSE(Decimal::nan().isZero());
}

TEST_F(DecimalTest, OpAdd)
{
    EXPECT_EQ(encode(0, 0, Positive), Decimal(0) + Decimal(0));
    EXPECT_EQ(Decimal(1), Decimal(2) + Decimal(-1));
    EXPECT_EQ(Decimal(1), Decimal(-1) + Decimal(2));
    EXPECT_EQ(encode(100, 0, Positive), Decimal(99) + Decimal(1));
    EXPECT_EQ(encode(100, 0, Negative), Decimal(-50) + Decimal(-50));
    EXPECT_EQ(encode(1000000000000000, 35, Positive), encode(1, 50, Positive) + Decimal(1));
    EXPECT_EQ(encode(1000000000000000, 35, Positive), Decimal(1) + encode(1, 50, Positive));
    EXPECT_EQ(encode(10000000001, 0, Positive), encode(1, 10, Positive) + Decimal(1));
    EXPECT_EQ(encode(10000000001, 0, Positive), Decimal(1) + encode(1, 10, Positive));
    EXPECT_EQ(encode(1, 0, Positive), encode(1, -1022, Positive) + encode(1, 0, Positive));
    EXPECT_EQ(encode(2, -1022, Positive), encode(1, -1022, Positive) + encode(1, -1022, Positive));
}

TEST_F(DecimalTest, OpAddBigE)
{
    EXPECT_EQ(encode(1, 1022, Positive), encode(1, 1022, Positive) + encode(1, 0, Positive));
    EXPECT_EQ(encode(2, 1022, Positive), encode(1, 1022, Positive) + encode(1, 1022, Positive));
    EXPECT_EQ(Decimal::infinity(Positive), encode(uint64_t(-1), 1022, Positive) + encode(1, 0, Positive));
}

TEST_F(DecimalTest, OpAddSmallE)
{
    EXPECT_EQ(encode(1, 0, Positive), encode(1, -1022, Positive) + encode(1, 0, Positive));
    EXPECT_EQ(encode(2, -1022, Positive), encode(1, -1022, Positive) + encode(1, -1022, Positive));
}

TEST_F(DecimalTest, OpAddSpecialValues)
{
    const Decimal Infinity(Decimal::infinity(Positive));
    const Decimal MinusInfinity(Decimal::infinity(Negative));
    const Decimal NaN(Decimal::nan());
    const Decimal Ten(10);

    EXPECT_EQ(Infinity, Infinity + Infinity);
    EXPECT_EQ(NaN, Infinity + MinusInfinity);
    EXPECT_EQ(NaN, MinusInfinity + Infinity);
    EXPECT_EQ(MinusInfinity, MinusInfinity + MinusInfinity);

    EXPECT_EQ(Infinity, Infinity + Ten);
    EXPECT_EQ(Infinity, Ten + Infinity);
    EXPECT_EQ(MinusInfinity, MinusInfinity + Ten);
    EXPECT_EQ(MinusInfinity, Ten + MinusInfinity);

    EXPECT_EQ(NaN, NaN + NaN);
    EXPECT_EQ(NaN, NaN + Ten);
    EXPECT_EQ(NaN, Ten + NaN);
}

TEST_F(DecimalTest, OpCompare)
{
    EXPECT_TRUE(Decimal(0) == Decimal(0));
    EXPECT_TRUE(Decimal(0) != Decimal(1));
    EXPECT_TRUE(Decimal(0) < Decimal(1));
    EXPECT_TRUE(Decimal(0) <= Decimal(0));
    EXPECT_TRUE(Decimal(0) > Decimal(-1));
    EXPECT_TRUE(Decimal(0) >= Decimal(0));

    EXPECT_FALSE(Decimal(1) == Decimal(2));
    EXPECT_FALSE(Decimal(1) != Decimal(1));
    EXPECT_FALSE(Decimal(1) < Decimal(0));
    EXPECT_FALSE(Decimal(1) <= Decimal(0));
    EXPECT_FALSE(Decimal(1) > Decimal(2));
    EXPECT_FALSE(Decimal(1) >= Decimal(2));
}

TEST_F(DecimalTest, OpCompareSpecialValues)
{
    EXPECT_TRUE(Decimal(1) < Decimal::infinity(Positive));
    EXPECT_TRUE(Decimal(1) > Decimal::infinity(Negative));
}

TEST_F(DecimalTest, OpDiv)
{
    EXPECT_EQ(encode(0, 0, Positive), Decimal(0) / Decimal(1));
    EXPECT_EQ(encode(2, 0, Negative), Decimal(2) / Decimal(-1));
    EXPECT_EQ(encode(5, -1, Negative), Decimal(-1) / Decimal(2));
    EXPECT_EQ(encode(99, 0, Positive), Decimal(99) / Decimal(1));
    EXPECT_EQ(Decimal(1), Decimal(-50) / Decimal(-50));
    EXPECT_EQ(encode(3333333333333333, -16, Positive), Decimal(1) / Decimal(3));
    EXPECT_EQ(encode(12345678901234, -1, Positive), encode(12345678901234, 0, Positive) / Decimal(10));
}

TEST_F(DecimalTest, OpDivBigE)
{
    EXPECT_EQ(encode(1, 1022, Positive), encode(1, 1022, Positive) / encode(1, 0, Positive));
    EXPECT_EQ(encode(1, 0, Positive), encode(1, 1022, Positive) / encode(1, 1022, Positive));
}

TEST_F(DecimalTest, OpDivSmallE)
{
    EXPECT_EQ(encode(1, -1022, Positive), encode(1, -1022, Positive) / encode(1, 0, Positive));
    EXPECT_EQ(encode(1, 0, Positive), encode(1, -1022, Positive) / encode(1, -1022, Positive));
}

TEST_F(DecimalTest, OpDivSpecialValues)
{
    const Decimal Infinity(Decimal::infinity(Positive));
    const Decimal MinusInfinity(Decimal::infinity(Negative));
    const Decimal NaN(Decimal::nan());
    const Decimal Zero(Decimal::zero(Positive));
    const Decimal MinusZero(Decimal::zero(Negative));
    const Decimal Ten(10);
    const Decimal MinusTen(-10);

    EXPECT_EQ(NaN, Zero / Zero);
    EXPECT_EQ(NaN, Zero / MinusZero);
    EXPECT_EQ(NaN, MinusZero / Zero);
    EXPECT_EQ(NaN, MinusZero / MinusZero);

    EXPECT_EQ(Infinity, Ten / Zero);
    EXPECT_EQ(MinusInfinity, Ten / MinusZero);
    EXPECT_EQ(MinusInfinity, MinusTen / Zero);
    EXPECT_EQ(Infinity, MinusTen / MinusZero);

    EXPECT_EQ(Infinity, Infinity / Zero);
    EXPECT_EQ(MinusInfinity, Infinity / MinusZero);
    EXPECT_EQ(MinusInfinity, MinusInfinity / Zero);
    EXPECT_EQ(Infinity, MinusInfinity / MinusZero);

    EXPECT_EQ(NaN, Infinity / Infinity);
    EXPECT_EQ(NaN, Infinity / MinusInfinity);
    EXPECT_EQ(NaN, MinusInfinity / Infinity);
    EXPECT_EQ(NaN, MinusInfinity / MinusInfinity);

    EXPECT_EQ(Zero, Ten / Infinity);
    EXPECT_EQ(MinusZero, Ten / MinusInfinity);
    EXPECT_EQ(MinusZero, MinusTen / Infinity);
    EXPECT_EQ(Zero, MinusTen / MinusInfinity);

    EXPECT_EQ(NaN, NaN / NaN);
    EXPECT_EQ(NaN, NaN / Ten);
    EXPECT_EQ(NaN, Ten / NaN);
}

TEST_F(DecimalTest, OpMul)
{
    EXPECT_EQ(encode(0, 0, Positive), Decimal(0) * Decimal(0));
    EXPECT_EQ(encode(2, 0, Negative), Decimal(2) * Decimal(-1));
    EXPECT_EQ(encode(2, 0, Negative), Decimal(-1) * Decimal(2));
    EXPECT_EQ(encode(99, 0, Positive), Decimal(99) * Decimal(1));
    EXPECT_EQ(encode(2500, 0, Positive), Decimal(-50) * Decimal(-50));
}

TEST_F(DecimalTest, OpMulBigE)
{
    EXPECT_EQ(encode(1, 1022, Positive), encode(1, 1022, Positive) * encode(1, 0, Positive));
    EXPECT_EQ(Decimal::infinity(Positive), encode(1, 1022, Positive) * encode(1, 1022, Positive));
}

TEST_F(DecimalTest, OpMulSmallE)
{
    EXPECT_EQ(encode(1, -1022, Positive), encode(1, -1022, Positive) * encode(1, 0, Positive));
    EXPECT_EQ(encode(0, 0, Positive), encode(1, -1022, Positive) * encode(1, -1022, Positive));
}

TEST_F(DecimalTest, OpMulSpecialValues)
{
    const Decimal Infinity(Decimal::infinity(Positive));
    const Decimal MinusInfinity(Decimal::infinity(Negative));
    const Decimal NaN(Decimal::nan());
    const Decimal Ten(10);
    const Decimal MinusTen(-10);
    const Decimal Zero(Decimal::zero(Positive));
    const Decimal MinusZero(Decimal::zero(Negative));

    EXPECT_EQ(Infinity, Infinity * Infinity);
    EXPECT_EQ(MinusInfinity, Infinity * MinusInfinity);
    EXPECT_EQ(MinusInfinity, MinusInfinity * Infinity);
    EXPECT_EQ(Infinity, MinusInfinity * MinusInfinity);

    EXPECT_EQ(NaN, Infinity * Zero);
    EXPECT_EQ(NaN, Zero * MinusInfinity);
    EXPECT_EQ(NaN, MinusInfinity * Zero);
    EXPECT_EQ(NaN, MinusInfinity * Zero);

    EXPECT_EQ(NaN, Infinity * MinusZero);
    EXPECT_EQ(NaN, MinusZero * MinusInfinity);
    EXPECT_EQ(NaN, MinusInfinity * MinusZero);
    EXPECT_EQ(NaN, MinusInfinity * MinusZero);

    EXPECT_EQ(Infinity, Infinity * Ten);
    EXPECT_EQ(Infinity, Ten * Infinity);
    EXPECT_EQ(MinusInfinity, MinusInfinity * Ten);
    EXPECT_EQ(MinusInfinity, Ten * MinusInfinity);

    EXPECT_EQ(MinusInfinity, Infinity * MinusTen);
    EXPECT_EQ(MinusInfinity, MinusTen * Infinity);
    EXPECT_EQ(Infinity, MinusInfinity * MinusTen);
    EXPECT_EQ(Infinity, MinusTen * MinusInfinity);

    EXPECT_EQ(NaN, NaN * NaN);
    EXPECT_EQ(NaN, NaN * Ten);
    EXPECT_EQ(NaN, Ten * NaN);
}

TEST_F(DecimalTest, OpSub)
{
    EXPECT_EQ(encode(0, 0, Positive), Decimal(0) - Decimal(0));
    EXPECT_EQ(encode(3, 0, Positive), Decimal(2) - Decimal(-1));
    EXPECT_EQ(encode(3, 0, Negative), Decimal(-1) - Decimal(2));
    EXPECT_EQ(encode(98, 0, Positive), Decimal(99) - Decimal(1));
    EXPECT_EQ(encode(0, 0, Positive), Decimal(-50) - Decimal(-50));
    EXPECT_EQ(encode(1000000000000000, 35, Positive), encode(1, 50, Positive) - Decimal(1));
    EXPECT_EQ(encode(1000000000000000, 35, Negative), Decimal(1) - encode(1, 50, Positive));
}

TEST_F(DecimalTest, OpSubBigE)
{
    EXPECT_EQ(encode(1, 1022, Positive), encode(1, 1022, Positive) - encode(1, 0, Positive));
    EXPECT_EQ(encode(0, 0, Positive), encode(1, 1022, Positive) - encode(1, 1022, Positive));
}

TEST_F(DecimalTest, OpSubSmallE)
{
    EXPECT_EQ(encode(UINT64_C(10000000000000000), -16, Negative), encode(1, -1022, Positive) - encode(1, 0, Positive));
    EXPECT_EQ(encode(0, 0, Positive), encode(1, -1022, Positive) - encode(1, -1022, Positive));
}

TEST_F(DecimalTest, OpSubSpecialValues)
{
    const Decimal Infinity(Decimal::infinity(Positive));
    const Decimal MinusInfinity(Decimal::infinity(Negative));
    const Decimal NaN(Decimal::nan());
    const Decimal Ten(10);

    EXPECT_EQ(NaN, Infinity - Infinity);
    EXPECT_EQ(Infinity, Infinity - MinusInfinity);
    EXPECT_EQ(MinusInfinity, MinusInfinity - Infinity);
    EXPECT_EQ(NaN, MinusInfinity - MinusInfinity);

    EXPECT_EQ(Infinity, Infinity - Ten);
    EXPECT_EQ(MinusInfinity, Ten - Infinity);
    EXPECT_EQ(MinusInfinity, MinusInfinity - Ten);
    EXPECT_EQ(Infinity, Ten - MinusInfinity);

    EXPECT_EQ(NaN, NaN - NaN);
    EXPECT_EQ(NaN, NaN - Ten);
    EXPECT_EQ(NaN, Ten - NaN);
}

TEST_F(DecimalTest, Properties)
{
    EXPECT_TRUE(Decimal(0).isFinite());
    EXPECT_FALSE(Decimal(0).isSpecial());
}

TEST_F(DecimalTest, PropertiesSpecial)
{
    EXPECT_TRUE(Decimal::infinity(Positive).isSpecial());
    EXPECT_FALSE(Decimal::infinity(Positive).isFinite());

    EXPECT_TRUE(Decimal::infinity(Negative).isSpecial());
    EXPECT_FALSE(Decimal::infinity(Negative).isFinite());

    EXPECT_TRUE(Decimal::nan().isSpecial());
    EXPECT_FALSE(Decimal::nan().isFinite());
}

// LayoutTests/fast/forms/number/number-stepup-stepdown-from-renderer
TEST_F(DecimalTest, RealWorldExampleNumberStepUpStepDownFromRenderer)
{
    EXPECT_EQ(String("10"), stepDown("0", "100", "10", "19", 1));
    EXPECT_EQ(String("90"), stepUp("0", "99", "10", "89", 1));
    EXPECT_EQ(String("1"), stepUp("0", "1", "0.33333333333333333", "0", 3)); // step=1/3
    EXPECT_EQ(String("0.01"), stepUp("0", "0.01", "0.0033333333333333333", "0", 3)); // step=1/300
    EXPECT_EQ(String("1"), stepUp("0", "1", "0.003921568627450980", "0", 255)); // step=1/255
    EXPECT_EQ(String("1"), stepUp("0", "1", "0.1", "0", 10));
}

TEST_F(DecimalTest, RealWorldExampleNumberStepUpStepDownFromRendererRounding)
{
    EXPECT_EQ(String("5.015"), stepUp("0", "100", "0.005", "5.005", 2));
    EXPECT_EQ(String("5.06"), stepUp("0", "100", "0.005", "5.005", 11));
    EXPECT_EQ(String("5.065"), stepUp("0", "100", "0.005", "5.005", 12));

    EXPECT_EQ(String("5.015"), stepUp("4", "9", "0.005", "5.005", 2));
    EXPECT_EQ(String("5.06"), stepUp("4", "9", "0.005", "5.005", 11));
    EXPECT_EQ(String("5.065"), stepUp("4", "9", "0.005", "5.005", 12));
}

TEST_F(DecimalTest, RealWorldExampleRangeStepUpStepDown)
{
    EXPECT_EQ(String("1e+38"), stepUp("0", "1E38", "1", "1E38", 9));
    EXPECT_EQ(String("1e+38"), stepDown("0", "1E38", "1", "1E38", 9));
}

TEST_F(DecimalTest, Remainder)
{
    EXPECT_EQ(encode(9, -1, Negative), encode(21, -1, Positive).remainder(3));
    EXPECT_EQ(Decimal(1), Decimal(10).remainder(3));
    EXPECT_EQ(encode(1, 0, Negative), Decimal(-10).remainder(3));
    EXPECT_EQ(encode(2, -1, Positive), encode(102, -1, Positive).remainder(1));
    EXPECT_EQ(encode(1, -1, Positive), Decimal(10).remainder(encode(3, -1, Positive)));
    EXPECT_EQ(encode(3, -1, Negative), encode(36, -1, Positive).remainder(encode(13, -1, Positive)));
}

TEST_F(DecimalTest, RemainderSpecialValues)
{
    EXPECT_EQ(Decimal::infinity(Positive), Decimal::infinity(Positive).remainder(1));
    EXPECT_EQ(Decimal::nan(), Decimal::nan().remainder(1));
}

TEST_F(DecimalTest, Round)
{
    EXPECT_EQ(Decimal(1), (Decimal(9) / Decimal(10)).round());
    EXPECT_EQ(Decimal(25), (Decimal(5) / fromString("0.200")).round());
    EXPECT_EQ(Decimal(3), (Decimal(5) / Decimal(2)).round());
    EXPECT_EQ(Decimal(1), (Decimal(2) / Decimal(3)).round());
    EXPECT_EQ(Decimal(3), (Decimal(10) / Decimal(3)).round());
    EXPECT_EQ(Decimal(3), (Decimal(1) / fromString("0.3")).round());
    EXPECT_EQ(Decimal(10), (Decimal(1) / fromString("0.1")).round());
    EXPECT_EQ(Decimal(5), (Decimal(1) / fromString("0.2")).round());
    EXPECT_EQ(Decimal(10), (fromString("10.2") / 1).round());
}

TEST_F(DecimalTest, RoundSepcialValues)
{
    EXPECT_EQ(Decimal::infinity(Positive), Decimal::infinity(Positive).round());
    EXPECT_EQ(Decimal::nan(), Decimal::nan().round());
}

TEST_F(DecimalTest, ToStringSpecial)
{
    EXPECT_EQ(String("Infinity"), Decimal::infinity(Positive).toString());
    EXPECT_EQ(String("-Infinity"), Decimal::infinity(Negative).toString());
    EXPECT_EQ(String("NaN"), Decimal::nan().toString());
}

Return to Bug 87360

Lines 1083-1088 SOURCES += \ a/Source/WebCore/Target.pri_sec1
- a/Source/WebCore/Target.pri +2 lines
1083	platform/ContentType.cpp \	1083	platform/ContentType.cpp \
1084	platform/CrossThreadCopier.cpp \	1084	platform/CrossThreadCopier.cpp \
1085	platform/DateComponents.cpp \	1085	platform/DateComponents.cpp \
		1086	platform/Decimal.cpp \
1086	platform/DragData.cpp \	1087	platform/DragData.cpp \
1087	platform/DragImage.cpp \	1088	platform/DragImage.cpp \
1088	platform/EventTracer.cpp \	1089	platform/EventTracer.cpp \
Lines 2200-2205 HEADERS += \ a/Source/WebCore/Target.pri_sec2
2200	platform/ContextMenu.h \	2201	platform/ContextMenu.h \
2201	platform/CrossThreadCopier.h \	2202	platform/CrossThreadCopier.h \
2202	platform/DateComponents.h \	2203	platform/DateComponents.h \
		2204	platform/Decimal.h \
2203	platform/DragData.h \	2205	platform/DragData.h \
2204	platform/DragImage.h \	2206	platform/DragImage.h \
2205	platform/EventTracer.h \	2207	platform/EventTracer.h \

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +85 lines
		1	2012-05-24 Yoshifumi Inoue <yosin@chromium.org>
		2
		3	[Platform] Introduce Decimal class for Number/Range input type.
		4	https://bugs.webkit.org/show_bug.cgi?id=87360
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This patch added new class Decimal for decimal arithmatic in two
		9	files: platform/Decimal.cpp and Decimal.h with unit test.
		10
		11	Test: WebKit/chromium/tests/DecimalTest.cpp
		12
		13	* CMakeLists.txt:
		14	* GNUmakefile.list.am:
		15	* Target.pri:
		16	* WebCore.gypi:
		17	* WebCore.vcproj/WebCore.vcproj:
		18	* WebCore.xcodeproj/project.pbxproj:
		19	* platform/Decimal.cpp: Added.
		20	(WebCore):
		21	(DecimalPrivate):
		22	(SpecialValueHandler):
		23	(UInt128):
		24	(WebCore::DecimalPrivate::UInt128::high):
		25	(WebCore::DecimalPrivate::UInt128::low):
		26	(WebCore::DecimalPrivate::UInt128::isZero):
		27	(WebCore::DecimalPrivate::countDigits):
		28	(WebCore::DecimalPrivate::multiplyHigh):
		29	(WebCore::DecimalPrivate::power):
		30	(WebCore::DecimalPrivate::scaleDown):
		31	(WebCore::DecimalPrivate::scaleUp):
		32	(WebCore::DecimalPrivate::SpecialValueHandler::SpecialValueHandler):
		33	(WebCore::DecimalPrivate::SpecialValueHandler::handle):
		34	(WebCore::DecimalPrivate::SpecialValueHandler::value):
		35	(WebCore::DecimalPrivate::UInt128::UInt128):
		36	(WebCore::DecimalPrivate::UInt128::operator /=):
		37	(WebCore::DecimalPrivate::UInt128::multiply):
		38	(WebCore::Decimal::EncodedData::EncodedData):
		39	(WebCore::Decimal::EncodedData::coefficient):
		40	(WebCore::Decimal::EncodedData::formatClass)
		41	(WebCore::Decimal::EncodedData::exponent):
		42	(WebCore::Decimal::EncodedData::isFinite):
		43	(WebCore::Decimal::EncodedData::isSpecial):
		44	(WebCore::Decimal::EncodedData::isZero):
		45	(WebCore::Decimal::EncodedData::sign):
		46	(WebCore::Decimal::EncodedData::setSign):
		47	(WebCore::Decimal::Decimal):
		48	(WebCore::Decimal::operator =):
		49	(WebCore::Decimal::operator +=):
		50	(WebCore::Decimal::operator -=):
		51	(WebCore::Decimal::operator *=):
		52	(WebCore::Decimal::operator /=):
		53	(WebCore::Decimal::operator -):
		54	(WebCore::Decimal::operator +):
		55	(WebCore::Decimal::operator *):
		56	(WebCore::Decimal::operator /):
		57	(WebCore::Decimal::operator==):
		58	(WebCore::Decimal::operator!=):
		59	(WebCore::Decimal::operator <):
		60	(WebCore::Decimal::operator <=):
		61	(WebCore::Decimal::operator >):
		62	(WebCore::Decimal::operator >=):
		63	(WebCore::Decimal::exponent):
		64	(WebCore::Decimal::sign):
65	(WebCore::Decimal::abs):
66	(WebCore::Decimal::ceiling):
67	(WebCore::Decimal::compareTo):
68	(WebCore::Decimal::fastEquals):
69	(WebCore::Decimal::floor):
70	(WebCore::Decimal::fromString):
71	(WebCore::Decimal::infinity):
72	(WebCore::Decimal::nan):
73	(WebCore::Decimal::remainder):
74	(WebCore::Decimal::round):
75	(WebCore::Decimal::toString):
76	(WebCore::Decimal::zero):
77	* platform/Decimal.h: Added.
78	(WebCore::Decimal::isFinite):
79	(WebCore::Decimal::isNegative):
80	(WebCore::Decimal::isPositive):
81	(WebCore::Decimal::isSpecial):
82	(WebCore::Decimal::isZero):
83	(WebCore::Decimal::value):
84	(WebCore::Decimal::invertSign):
85
1	2012-05-27 Yoshifumi Inoue <yosin@chromium.org>	86	2012-05-27 Yoshifumi Inoue <yosin@chromium.org>
2		87
3	[WTF] Introduce UINT64_C to MathExtras.h	88	[WTF] Introduce UINT64_C to MathExtras.h

Lines 1-3 a/Source/WebKit/chromium/ChangeLog_sec1
- a/Source/WebKit/chromium/ChangeLog +22 lines
		1	2012-05-24 Yoshifumi Inoue <yosin@chromium.org>
		2
		3	[Platform] Introduce Decimal class for Number/Range input type.
		4	https://bugs.webkit.org/show_bug.cgi?id=87360
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This patch added unit test for Decimal class.
		9
		10	* WebKit.gypi:
		11	* tests/DecimalTest.cpp: Added.
		12	(WebCore::operator<<): Output Decimal for unit test debugging
		13	(DecimalTest):
		14	(DecimalStepRange):
		15	(DecimalTest::DecimalStepRange::DecimalStepRange):
		16	(DecimalTest::DecimalStepRange::clampValue):
		17	(DecimalTest::DecimalTest::encode):
		18	(DecimalTest::DecimalTest::fromString):
		19	(DecimalTest::DecimalTest::stepDown):
		20	(DecimalTest::DecimalTest::stepUp):
		21	(DecimalTest::TEST_F):
		22
1	2012-05-25 Ryosuke Niwa <rniwa@webkit.org>	23	2012-05-25 Ryosuke Niwa <rniwa@webkit.org>
2		24
3	Roll chromium DEPS from r139156 to r139184.	25	Roll chromium DEPS from r139156 to r139184.

Lines 271-276 a/Source/WebCore/WebCore.gypi_sec1
- a/Source/WebCore/WebCore.gypi +2 lines
271	'platform/CookiesStrategy.h',	271	'platform/CookiesStrategy.h',
272	'platform/Cursor.h',	272	'platform/Cursor.h',
273	'platform/DateComponents.h',	273	'platform/DateComponents.h',
		274	'platform/Decimal.h'
274	'platform/DragData.h',	275	'platform/DragData.h',
275	'platform/DragImage.h',	276	'platform/DragImage.h',
276	'platform/EventTracer.h',	277	'platform/EventTracer.h',
Lines 3149-3154 a/Source/WebCore/WebCore.gypi_sec2
3149	'platform/CrossThreadCopier.h',	3150	'platform/CrossThreadCopier.h',
3150	'platform/Cursor.cpp',	3151	'platform/Cursor.cpp',
3151	'platform/DateComponents.cpp',	3152	'platform/DateComponents.cpp',
		3153	'platform/Decimal.cpp',
3152	'platform/DragData.cpp',	3154	'platform/DragData.cpp',
3153	'platform/DragImage.cpp',	3155	'platform/DragImage.cpp',
3154	'platform/EventLoop.h',	3156	'platform/EventLoop.h',

Lines 1194-1199 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec1
- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj +8 lines
1194	450CEBF015073BBE002BB149 /* LabelableElement.cpp in Sources / = {isa = PBXBuildFile; fileRef = 450CEBEE15073BBE002BB149 / LabelableElement.cpp */; };	1194	450CEBF015073BBE002BB149 /* LabelableElement.cpp in Sources / = {isa = PBXBuildFile; fileRef = 450CEBEE15073BBE002BB149 / LabelableElement.cpp */; };
1195	450CEBF115073BBE002BB149 /* LabelableElement.h in Headers / = {isa = PBXBuildFile; fileRef = 450CEBEF15073BBE002BB149 / LabelableElement.h */; settings = {ATTRIBUTES = (Private, ); }; };	1195	450CEBF115073BBE002BB149 /* LabelableElement.h in Headers / = {isa = PBXBuildFile; fileRef = 450CEBEF15073BBE002BB149 / LabelableElement.h */; settings = {ATTRIBUTES = (Private, ); }; };
1196	45BAC2B01360BBAB005DA258 /* IconURL.h in Headers / = {isa = PBXBuildFile; fileRef = 45BAC2AF1360BBAB005DA258 / IconURL.h */; settings = {ATTRIBUTES = (Private, ); }; };	1196	45BAC2B01360BBAB005DA258 /* IconURL.h in Headers / = {isa = PBXBuildFile; fileRef = 45BAC2AF1360BBAB005DA258 / IconURL.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1197	45FEA5CF156DDE8C00654101 /* Decimal.cpp in Sources / = {isa = PBXBuildFile; fileRef = 45FEA5CD156DDE8C00654101 / Decimal.cpp */; };
		1198	45FEA5D0156DDE8C00654101 /* Decimal.h in Headers / = {isa = PBXBuildFile; fileRef = 45FEA5CE156DDE8C00654101 / Decimal.h */; settings = {ATTRIBUTES = (Private, ); }; };
1197	4614A1FE0B23A8D600446E1C /* copyCursor.png in Resources / = {isa = PBXBuildFile; fileRef = 4614A1FD0B23A8D600446E1C / copyCursor.png */; };	1199	4614A1FE0B23A8D600446E1C /* copyCursor.png in Resources / = {isa = PBXBuildFile; fileRef = 4614A1FD0B23A8D600446E1C / copyCursor.png */; };
1198	46700ED0127B96CB00F5D5D6 /* FileWriterSync.cpp in Sources / = {isa = PBXBuildFile; fileRef = 46700ECE127B96CB00F5D5D6 / FileWriterSync.cpp */; };	1200	46700ED0127B96CB00F5D5D6 /* FileWriterSync.cpp in Sources / = {isa = PBXBuildFile; fileRef = 46700ECE127B96CB00F5D5D6 / FileWriterSync.cpp */; };
1199	46700ED1127B96CB00F5D5D6 /* FileWriterSync.h in Headers / = {isa = PBXBuildFile; fileRef = 46700ECF127B96CB00F5D5D6 / FileWriterSync.h */; };	1201	46700ED1127B96CB00F5D5D6 /* FileWriterSync.h in Headers / = {isa = PBXBuildFile; fileRef = 46700ECF127B96CB00F5D5D6 / FileWriterSync.h */; };
Lines 8195-8200 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec2
8195	450CEBEE15073BBE002BB149 /* LabelableElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LabelableElement.cpp; sourceTree = "<group>"; };	8197	450CEBEE15073BBE002BB149 /* LabelableElement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LabelableElement.cpp; sourceTree = "<group>"; };
8196	450CEBEF15073BBE002BB149 /* LabelableElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LabelableElement.h; sourceTree = "<group>"; };	8198	450CEBEF15073BBE002BB149 /* LabelableElement.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LabelableElement.h; sourceTree = "<group>"; };
8197	45BAC2AF1360BBAB005DA258 /* IconURL.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IconURL.h; sourceTree = "<group>"; };	8199	45BAC2AF1360BBAB005DA258 /* IconURL.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IconURL.h; sourceTree = "<group>"; };
		8200	45FEA5CD156DDE8C00654101 /* Decimal.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Decimal.cpp; sourceTree = "<group>"; };
		8201	45FEA5CE156DDE8C00654101 /* Decimal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Decimal.h; sourceTree = "<group>"; };
8198	4614A1FD0B23A8D600446E1C /* copyCursor.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = copyCursor.png; sourceTree = "<group>"; };	8202	4614A1FD0B23A8D600446E1C /* copyCursor.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = copyCursor.png; sourceTree = "<group>"; };
8199	46700ECE127B96CB00F5D5D6 /* FileWriterSync.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FileWriterSync.cpp; path = Modules/filesystem/FileWriterSync.cpp; sourceTree = "<group>"; };	8203	46700ECE127B96CB00F5D5D6 /* FileWriterSync.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = FileWriterSync.cpp; path = Modules/filesystem/FileWriterSync.cpp; sourceTree = "<group>"; };
8200	46700ECF127B96CB00F5D5D6 /* FileWriterSync.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FileWriterSync.h; path = Modules/filesystem/FileWriterSync.h; sourceTree = "<group>"; };	8204	46700ECF127B96CB00F5D5D6 /* FileWriterSync.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FileWriterSync.h; path = Modules/filesystem/FileWriterSync.h; sourceTree = "<group>"; };
Lines 20324-20329 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec3
20324	F587868402DE3B8601EA4122 /* Cursor.h */,	20328	F587868402DE3B8601EA4122 /* Cursor.h */,
20325	A5732B08136A161D005C8D7C /* DateComponents.cpp */,	20329	A5732B08136A161D005C8D7C /* DateComponents.cpp */,
20326	A5732B09136A161D005C8D7C /* DateComponents.h */,	20330	A5732B09136A161D005C8D7C /* DateComponents.h */,
		20331	45FEA5CD156DDE8C00654101 /* Decimal.cpp */,
		20332	45FEA5CE156DDE8C00654101 /* Decimal.h */,
20327	A79546420B5C4CB4007B438F /* DragData.cpp */,	20333	A79546420B5C4CB4007B438F /* DragData.cpp */,
20328	A7B6E69D0B291A9600D0529F /* DragData.h */,	20334	A7B6E69D0B291A9600D0529F /* DragData.h */,
20329	A7CFB3CF0B7ED10A0070C32D /* DragImage.cpp */,	20335	A7CFB3CF0B7ED10A0070C32D /* DragImage.cpp */,
Lines 22083-22088 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec4
22083	F55B3DB61251F12D003EF269 /* DateInputType.h in Headers */,	22089	F55B3DB61251F12D003EF269 /* DateInputType.h in Headers */,
22084	F55B3DB81251F12D003EF269 /* DateTimeInputType.h in Headers */,	22090	F55B3DB81251F12D003EF269 /* DateTimeInputType.h in Headers */,
22085	F55B3DBA1251F12D003EF269 /* DateTimeLocalInputType.h in Headers */,	22091	F55B3DBA1251F12D003EF269 /* DateTimeLocalInputType.h in Headers */,
		22092	45FEA5D0156DDE8C00654101 /* Decimal.h in Headers */,
22086	A8C228A111D5722E00D5A7D3 /* DecodedDataDocumentParser.h in Headers */,	22093	A8C228A111D5722E00D5A7D3 /* DecodedDataDocumentParser.h in Headers */,
22087	CECCFC3B141973D5002A0AC1 /* DecodeEscapeSequences.h in Headers */,	22094	CECCFC3B141973D5002A0AC1 /* DecodeEscapeSequences.h in Headers */,
22088	4162A451101145AE00DFF3ED /* DedicatedWorkerContext.h in Headers */,	22095	4162A451101145AE00DFF3ED /* DedicatedWorkerContext.h in Headers */,
Lines 25577-25582 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec5
25577	F55B3DB51251F12D003EF269 /* DateInputType.cpp in Sources */,	25584	F55B3DB51251F12D003EF269 /* DateInputType.cpp in Sources */,
25578	F55B3DB71251F12D003EF269 /* DateTimeInputType.cpp in Sources */,	25585	F55B3DB71251F12D003EF269 /* DateTimeInputType.cpp in Sources */,
25579	F55B3DB91251F12D003EF269 /* DateTimeLocalInputType.cpp in Sources */,	25586	F55B3DB91251F12D003EF269 /* DateTimeLocalInputType.cpp in Sources */,
		25587	45FEA5CF156DDE8C00654101 /* Decimal.cpp in Sources */,
25580	A8C228A211D5722E00D5A7D3 /* DecodedDataDocumentParser.cpp in Sources */,	25588	A8C228A211D5722E00D5A7D3 /* DecodedDataDocumentParser.cpp in Sources */,
25581	4162A450101145AE00DFF3ED /* DedicatedWorkerContext.cpp in Sources */,	25589	4162A450101145AE00DFF3ED /* DedicatedWorkerContext.cpp in Sources */,
25582	41A3D58E101C152D00316D07 /* DedicatedWorkerThread.cpp in Sources */,	25590	41A3D58E101C152D00316D07 /* DedicatedWorkerThread.cpp in Sources */,

Line 0 a/Source/WebCore/platform/Decimal.h_sec1
- a/Source/WebCore/platform/Decimal.h +147 lines
		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	#ifndef Decimal_h
		31	#define Decimal_h
		32
		33	#include <stdint.h>
		34	#include <wtf/text/WTFString.h>
		35
		36	namespace WebCore {
		37
		38	// This class represents decimal base floating point number.
		39	//
		40	// FIXME: Once all C++ compiler support decimal type, we should replace this
		41	// class to compiler supported one. See below URI for current status of decimal
		42	// type for C++: // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1977.html
		43	class Decimal {
		44	public:
		45	enum Sign {
		46	Positive,
		47	Negative,
		48	};
		49
		50	// You should not use FormatClass. This is for implementation.
		51	enum FormatClass {
		52	ClassInfinity,
		53	ClassNormal,
		54	ClassNaN,
		55	ClassZero,
		56	};
		57
		58	// You should not use EncodedData other than unit testing.
		59	class EncodedData {
		60	public:
		61	EncodedData(Sign, FormatClass);
		62	EncodedData(Sign, int exponent, uint64_t coefficient);
		63
		64	bool operator==(const EncodedData&) const;
65	bool operator!=(const EncodedData& another) const { return !operator==(another); }
66
67	uint64_t coefficient() const { return m_coefficient; }
68	int countDigits() const;
69	int exponent() const { return m_exponent; }
70	FormatClass formatClass() const { return m_formatClass; }
71	bool isFinite() const { return !isSpecial(); }
72	bool isSpecial() const { return m_formatClass == ClassInfinity \|\| m_formatClass == ClassNaN; }
73	bool isZero() const { return m_formatClass == ClassZero; }
74	Sign sign() const { return m_sign; }
75	void setSign(Sign sign) { m_sign = sign; }
76
77	private:
78	uint64_t m_coefficient;
79	int16_t m_exponent;
80	FormatClass m_formatClass;
81	Sign m_sign;
82	};
83
84	Decimal(int32_t = 0);
85	Decimal(Sign, int exponent, uint64_t coefficient);
86	Decimal(const Decimal&);
87
88	Decimal& operator=(const Decimal&);
89	Decimal& operator+=(const Decimal&);
90	Decimal& operator-=(const Decimal&);
91	Decimal& operator*=(const Decimal&);
92	Decimal& operator/=(const Decimal&);
93
94	Decimal operator-() const;
95
96	bool operator==(const Decimal&) const;
97	bool operator!=(const Decimal&) const;
98	bool operator<(const Decimal&) const;
99	bool operator<=(const Decimal&) const;
100	bool operator>(const Decimal&) const;
101	bool operator>=(const Decimal&) const;
102
103	Decimal operator+(const Decimal&) const;
104	Decimal operator-(const Decimal&) const;
105	Decimal operator*(const Decimal&) const;
106	Decimal operator/(const Decimal&) const;
107
108	int exponent() const;
109	bool isFinite() const { return m_data.isFinite(); }
110	bool isNegative() const { return sign() == Negative; }
111	bool isPositive() const { return sign() == Positive; }
112	bool isSpecial() const { return m_data.isSpecial(); }
113	bool isZero() const { return m_data.isZero(); }
114
115	Decimal abs() const;
116	Decimal ceiling() const;
117	Decimal floor() const;
118	Decimal remainder(const Decimal&) const;
119	Decimal round() const;
120	String toString() const;
121
122	static Decimal fromString(const String&);
123	static Decimal infinity(Sign);
124	static Decimal nan();
125	static Decimal zero(Sign);
126
127	// You should not use below methods. We expose them for unit testing.
128	explicit Decimal(const EncodedData&);
129	const EncodedData& value() const { return m_data; }
130
131	private:
132	Decimal(double);
133	Decimal compareTo(const Decimal&) const;
134
135	static inline Sign invertSign(Sign sign)
136	{
137	return sign == Negative ? Positive : Negative;
138	}
139
140	Sign sign() const;
141
142	EncodedData m_data;
143	};
144
145	} // namespace WebCore
146
147	#endif // Decimal_h