Changeset 29020 in webkit

Timestamp:

Dec 28, 2007 8:01:13 PM (16 years ago)

Author:

eric@webkit.org

Message:

Reviewed by Oliver.

Fix (-0).toFixed() and re-factor a little
Fix (-0).toExponential() and printing of trailing 0s in toExponential
Fix toPrecision(nan) handling

• kjs/number_object.cpp: (KJS::numberToFixed): (KJS::fractionalPartToString): (KJS::numberToExponential): (KJS::numberToPrecision):

Location:

trunk

Files:

• JavaScriptCore/ChangeLog (modified) (1 diff)
• JavaScriptCore/kjs/number_object.cpp (modified) (7 diffs)
• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/js/number-toExponential-expected.txt (added)
• LayoutTests/fast/js/number-toString-expected.txt (added)
• LayoutTests/fast/js/number-toString.html (added)
• LayoutTests/fast/js/number-tofixed-expected.txt (modified) (1 diff)
• LayoutTests/fast/js/number-toprecision-expected.txt (modified) (1 diff)
• LayoutTests/fast/js/resources/number-toExponential.js (added)
• LayoutTests/fast/js/resources/number-toString.js (added)
• LayoutTests/fast/js/resources/number-tofixed.js (modified) (1 diff)
• LayoutTests/fast/js/resources/number-toprecision.js (modified) (1 diff)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2007-12-28  Eric Seidel  <eric@webkit.org>
+
+        Reviewed by Oliver.
+
+        Fix (-0).toFixed() and re-factor a little
+        Fix (-0).toExponential() and printing of trailing 0s in toExponential
+        Fix toPrecision(nan) handling
+
+        * kjs/number_object.cpp:
+        (KJS::numberToFixed):
+        (KJS::fractionalPartToString):
+        (KJS::numberToExponential):
+        (KJS::numberToPrecision):
+
 2007-12-28  Eric Seidel  <eric@webkit.org>
 

trunk/JavaScriptCore/kjs/number_object.cpp

@@ -209 +209 @@
         s.append('-');
         x = -x;
-    }
+    } else if (x == -0.0)
+        x = 0;
 
     if (x >= pow(10.0, 21.0))
@@ -234 +235 @@
         return jsString(s + m.substr(0, kMinusf) + "." + m.substr(kMinusf));
     return jsString(s + m.substr(0, kMinusf));
+}
+
+void fractionalPartToString(char* buf, int& i, const char* result, int resultLength, int fractionalDigits)
+{
+    if (fractionalDigits <= 0)
+        return;
+
+    int fDigitsInResult = static_cast<int>(resultLength) - 1;
+    buf[i++] = '.';
+    if (fDigitsInResult > 0) {
+        if (fractionalDigits < fDigitsInResult) {
+            strncpy(buf + i, result + 1, fractionalDigits);
+            i += fractionalDigits;
+        } else {
+            strcpy(buf + i, result + 1);
+            i += static_cast<int>(resultLength) - 1;
+        }
+    }
+
+    for (int j = 0; j < fractionalDigits - fDigitsInResult; j++)
+        buf[i++] = '0';
 }
 
@@ -259 +281 @@
         return jsString(UString::from(x));
 
-    JSValue* fractionDigits = args[0];
-    double df = fractionDigits->toInteger(exec);
+    JSValue* fractionalDigitsValue = args[0];
+    double df = fractionalDigitsValue->toInteger(exec);
     if (!(df >= 0 && df <= 20))
         return throwError(exec, RangeError, "toExponential() argument must between 0 and 20");
-    int f = (int)df;
-    bool includeAllDigits = fractionDigits->isUndefined();
+    int fractionalDigits = (int)df;
+    bool includeAllDigits = fractionalDigitsValue->isUndefined();
 
     int decimalAdjust = 0;
-    if (!includeAllDigits) {
+    if (x && !includeAllDigits) {
         double logx = floor(log10(fabs(x)));
         x /= pow(10.0, logx);
-        const double tenToTheF = pow(10.0, f);
+        const double tenToTheF = pow(10.0, fractionalDigits);
         double fx = floor(x * tenToTheF) / tenToTheF;
         double cx = ceil(x * tenToTheF) / tenToTheF;
@@ -285 +307 @@
         return jsString("NaN");
 
+    if (x == -0.0) // (-0.0).toExponential() should print as 0 instead of -0
+        x = 0;
+
     int decimalPoint;
     int sign;
     char* result = kjs_dtoa(x, 0, 0, &decimalPoint, &sign, NULL);
-    size_t length = strlen(result);
+    size_t resultLength = strlen(result);
     decimalPoint += decimalAdjust;
 
     int i = 0;
-    char buf[80];
+    char buf[80]; // digit + '.' + fractionDigits (max 20) + 'e' + sign + exponent (max?)
     if (sign)
         buf[i++] = '-';
@@ -302 +327 @@
 
         if (includeAllDigits)
-            f = static_cast<int>(length) - 1;
-
-        if (length > 1 && f > 0) {
-            buf[i++] = '.';
-            int haveFDigits = static_cast<int>(length) - 1;
-            if (f < haveFDigits) {
-                strncpy(buf + i, result + 1, f);
-                i += f;
-            } else {
-                strcpy(buf + i, result + 1);
-                i += static_cast<int>(length) - 1;
-                for (int j = 0; j < f - haveFDigits; j++)
-                    buf[i++] = '0';
-            }
-        }
+            fractionalDigits = static_cast<int>(resultLength) - 1;
+
+        fractionalPartToString(buf, i, result, resultLength, fractionalDigits);
         exponentialPartToString(buf, i, decimalPoint);
         buf[i++] = '\0';
     }
-
     ASSERT(i <= 80);
 
@@ -332 +344 @@
     double doublePrecision = args[0]->toIntegerPreserveNaN(exec);
     double x = v->toNumber(exec);
-    if (isnan(doublePrecision) || isnan(x) || isinf(x))
+    if (args[0]->isUndefined() || isnan(x) || isinf(x))
         return jsString(v->toString(exec));
 
@@ -347 +359 @@
     int e = 0;
     UString m;
-    if (x != 0) {
+    if (x) {
         e = static_cast<int>(log10(x));
         double tens = intPow10(e - precision + 1);

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2007-12-28  Eric Seidel  <eric@webkit.org>
+
+        Reviewed by Oliver.
+
+        Add more tests for toFixed, toPrecision and toExponential
+        Add tests for toString to match Firefox's behavior
+        
+        All tests pass in Firefox, but some fail in WebKit
+        I've chosen to land failing tests as I expect we'll move closer
+        towards Firefox's behavior in the future, and it's better to have
+        the tests now thus to notice any behavior changes in the future.
+
+        * fast/js/number-toExponential-expected.txt: Added.
+        * fast/js/number-toString-expected.txt: Added.
+        * fast/js/number-toString.html: Added.
+        * fast/js/number-tofixed-expected.txt:
+        * fast/js/number-toprecision-expected.txt:
+        * fast/js/resources/number-toExponential.js: Added.
+        * fast/js/resources/number-toString.js: Added.
+        * fast/js/resources/number-tofixed.js:
+        * fast/js/resources/number-toprecision.js:
+
 2007-12-29  Nikolas Zimmermann  <zimmermann@kde.org>
 

trunk/LayoutTests/fast/js/number-tofixed-expected.txt

@@ -26 +26 @@
 PASS (-0.55).toFixed(1) is '-0.6'
 PASS (-0.551).toFixed(1) is '-0.6'
+PASS (0.0).toFixed(4) is "0.0000"
+PASS (-0.0).toFixed(4) is "0.0000"
+PASS (0.0).toFixed() is "0"
+PASS (-0.0).toFixed() is "0"
+PASS (1234.567).toFixed() is "1235"
+PASS (1234.567).toFixed(0) is "1235"
+PASS (1234.567).toFixed(1) is "1234.6"
+PASS (1234.567).toFixed(2) is "1234.57"
+PASS (1234.567).toFixed(5) is "1234.56700"
+FAIL (1234.567).toFixed(20) should be 1234.56700000000000727596. Was 1234.56700000000000000000.
+FAIL (1234.567).toFixed(21) should be 1234.567000000000007275958. Threw exception RangeError: toFixed() digits argument must be between 0 and 20
+FAIL (1234.567).toFixed(100) should be 1234.5670000000000072759576141834259033203125000000000000000000000000000000000000000000000000000000000000. Threw exception RangeError: toFixed() digits argument must be between 0 and 20
+PASS (1234.567).toFixed(101) threw exception RangeError: toFixed() digits argument must be between 0 and 20.
+FAIL (1234.567).toFixed(-1) should be 1230. Threw exception RangeError: toFixed() digits argument must be between 0 and 20
+FAIL (1234.567).toFixed(-4) should be 0. Threw exception RangeError: toFixed() digits argument must be between 0 and 20
+FAIL (1234.567).toFixed(-5) should be 0. Threw exception RangeError: toFixed() digits argument must be between 0 and 20
+FAIL (1234.567).toFixed(-20) should be 0. Threw exception RangeError: toFixed() digits argument must be between 0 and 20
+PASS (1234.567).toFixed(-21) threw exception RangeError: toFixed() digits argument must be between 0 and 20.
+PASS (1234.567).toFixed(posInf) threw exception RangeError: toFixed() digits argument must be between 0 and 20.
+PASS (1234.567).toFixed(negInf) threw exception RangeError: toFixed() digits argument must be between 0 and 20.
+PASS (1234.567).toFixed(nan) is "1235"
+PASS posInf.toFixed() is "Infinity"
+PASS negInf.toFixed() is "-Infinity"
+PASS nan.toFixed() is "NaN"
 PASS successfullyParsed is true
 

trunk/LayoutTests/fast/js/number-toprecision-expected.txt

@@ -4 +4 @@
 
 
-PASS (0.999).toPrecision(1) is '1'
-PASS (0.999).toPrecision(2) is '1.0'
-PASS (0.999).toPrecision(3) is '0.999'
+PASS (0.999).toPrecision(1) is "1"
+PASS (0.999).toPrecision(2) is "1.0"
+PASS (0.999).toPrecision(3) is "0.999"
+PASS (0.0).toPrecision(4) is "0.000"
+PASS (-0.0).toPrecision(4) is "0.000"
+FAIL (0.0).toPrecision() should be 0. Threw exception RangeError: toPrecision() argument must be between 1 and 21
+FAIL (-0.0).toPrecision() should be 0. Threw exception RangeError: toPrecision() argument must be between 1 and 21
+FAIL (1234.567).toPrecision() should be 1234.567. Threw exception RangeError: toPrecision() argument must be between 1 and 21
+PASS (1234.567).toPrecision(0) threw exception RangeError: toPrecision() argument must be between 1 and 21.
+PASS (1234.567).toPrecision(-1) threw exception RangeError: toPrecision() argument must be between 1 and 21.
+PASS (1234.567).toPrecision(1) is "1e+3"
+PASS (1234.567).toPrecision(2) is "1.2e+3"
+PASS (1234.567).toPrecision(5) is "1234.6"
+FAIL (1234.567).toPrecision(21) should be 1234.56700000000000728. Was 1234.56700000000000000.
+FAIL (1234.567).toPrecision(22) should be 1234.567000000000007276. Threw exception RangeError: toPrecision() argument must be between 1 and 21
+FAIL (1234.567).toPrecision(100) should be 1234.567000000000007275957614183425903320312500000000000000000000000000000000000000000000000000000000. Threw exception RangeError: toPrecision() argument must be between 1 and 21
+PASS (1234.567).toPrecision(101) threw exception RangeError: toPrecision() argument must be between 1 and 21.
+PASS (1234.567).toPrecision(posInf) threw exception RangeError: toPrecision() argument must be between 1 and 21.
+PASS (1234.567).toPrecision(negInf) threw exception RangeError: toPrecision() argument must be between 1 and 21.
+PASS (1234.567).toPrecision(nan) threw exception RangeError: toPrecision() argument must be between 1 and 21.
+PASS posInf.toPrecision() is "Infinity"
+PASS negInf.toPrecision() is "-Infinity"
+PASS nan.toPrecision() is "NaN"
 PASS successfullyParsed is true
 

trunk/LayoutTests/fast/js/resources/number-tofixed.js

@@ -34 +34 @@
 shouldBe("(-0.551).toFixed(1)", "'-0.6'");
 
+var posInf = 1/0;
+var negInf = -1/0;
+var nan = 0/0;
+
+// From Acid3, http://bugs.webkit.org/show_bug.cgi?id=16640
+shouldBeEqualToString("(0.0).toFixed(4)", "0.0000");
+shouldBeEqualToString("(-0.0).toFixed(4)", "0.0000");
+shouldBeEqualToString("(0.0).toFixed()", "0");
+shouldBeEqualToString("(-0.0).toFixed()", "0");
+
+// From http://bugs.webkit.org/show_bug.cgi?id=5258
+shouldBeEqualToString("(1234.567).toFixed()", "1235");
+shouldBeEqualToString("(1234.567).toFixed(0)", "1235");
+// 0 equivilents
+shouldBeEqualToString("(1234.567).toFixed(null)", "1235");
+shouldBeEqualToString("(1234.567).toFixed(false)", "1235");
+shouldBeEqualToString("(1234.567).toFixed('foo')", "1235");
+shouldBeEqualToString("(1234.567).toFixed(nan)", "1235"); // nan is treated like 0
+
+shouldBeEqualToString("(1234.567).toFixed(1)", "1234.6");
+shouldBeEqualToString("(1234.567).toFixed(true)", "1234.6"); // just like 1
+shouldBeEqualToString("(1234.567).toFixed('1')", "1234.6"); // just like 1
+
+shouldBeEqualToString("(1234.567).toFixed(2)", "1234.57");
+shouldBeEqualToString("(1234.567).toFixed(5)", "1234.56700");
+shouldBeEqualToString("(1234.567).toFixed(20)", "1234.56700000000000727596");
+
+// SpiderMonkey allows precision values -20 to 100, we only allow 0 to 20 currently
+shouldBeEqualToString("(1234.567).toFixed(21)", "1234.567000000000007275958");
+shouldBeEqualToString("(1234.567).toFixed(100)", "1234.5670000000000072759576141834259033203125000000000000000000000000000000000000000000000000000000000000");
+shouldThrow("(1234.567).toFixed(101)");
+shouldBeEqualToString("(1234.567).toFixed(-1)", "1230");
+shouldBeEqualToString("(1234.567).toFixed(-4)", "0");
+shouldBeEqualToString("(1234.567).toFixed(-5)", "0");
+shouldBeEqualToString("(1234.567).toFixed(-20)", "0");
+shouldThrow("(1234.567).toFixed(-21)");
+
+shouldThrow("(1234.567).toFixed(posInf)");
+shouldThrow("(1234.567).toFixed(negInf)");
+
+shouldBeEqualToString("posInf.toFixed()", "Infinity");
+shouldBeEqualToString("negInf.toFixed()", "-Infinity");
+shouldBeEqualToString("nan.toFixed()", "NaN");
+
 var successfullyParsed = true;

trunk/LayoutTests/fast/js/resources/number-toprecision.js

@@ -4 +4 @@
     '.');
 
-shouldBe("(0.999).toPrecision(1)", "'1'");
-shouldBe("(0.999).toPrecision(2)", "'1.0'");
-shouldBe("(0.999).toPrecision(3)", "'0.999'");
+shouldBeEqualToString("(0.999).toPrecision(1)", "1");
+shouldBeEqualToString("(0.999).toPrecision(2)", "1.0");
+shouldBeEqualToString("(0.999).toPrecision(3)", "0.999");
 
+var posInf = 1/0;
+var negInf = -1/0;
+var nan = 0/0;
+
+shouldBeEqualToString("(0.0).toPrecision(4)", "0.000");
+shouldBeEqualToString("(-0.0).toPrecision(4)", "0.000");
+shouldBeEqualToString("(0.0).toPrecision()", "0");
+shouldBeEqualToString("(-0.0).toPrecision()", "0");
+shouldBeEqualToString("(1234.567).toPrecision()", "1234.567");
+shouldThrow("(1234.567).toPrecision(0)");
+shouldThrow("(1234.567).toPrecision(null)"); // just like 0
+shouldThrow("(1234.567).toPrecision(false)"); // just like 0
+shouldThrow("(1234.567).toPrecision('foo')"); // just like 0
+shouldThrow("(1234.567).toPrecision(-1)");
+shouldBeEqualToString("(1234.567).toPrecision(1)", "1e+3");
+shouldBeEqualToString("(1234.567).toPrecision(true)", "1e+3"); // just like 1
+shouldBeEqualToString("(1234.567).toPrecision('1')", "1e+3"); // just like 1
+shouldBeEqualToString("(1234.567).toPrecision(2)", "1.2e+3");
+shouldBeEqualToString("(1234.567).toPrecision(5)", "1234.6");
+shouldBeEqualToString("(1234.567).toPrecision(21)", "1234.56700000000000728");
+// SpiderMonkey allows precision values 1 to 100, we only allow 1 to 21 currently
+shouldBeEqualToString("(1234.567).toPrecision(22)", "1234.567000000000007276");
+shouldBeEqualToString("(1234.567).toPrecision(100)", "1234.567000000000007275957614183425903320312500000000000000000000000000000000000000000000000000000000");
+shouldThrow("(1234.567).toPrecision(101)");
+
+shouldThrow("(1234.567).toPrecision(posInf)");
+shouldThrow("(1234.567).toPrecision(negInf)");
+shouldThrow("(1234.567).toPrecision(nan)"); // nan is treated like 0
+
+shouldBeEqualToString("posInf.toPrecision()", "Infinity");
+shouldBeEqualToString("negInf.toPrecision()", "-Infinity");
+shouldBeEqualToString("nan.toPrecision()", "NaN");
 
 var successfullyParsed = true;