Implemented Number.prototype.toFixed()

JerryScript-DCO-1.0-Signed-off-by: László Langó llango.u-szeged@partner.samsung.com
JerryScript-DCO-1.0-Signed-off-by: Dániel Bátyai dbatyai.u-szeged@partner.samsung.com
JerryScript-DCO-1.0-Signed-off-by: Tamas Czene tczene.u-szeged@partner.samsung.com

jerry-core/ecma/base/ecma-helpers-conversion.cpp

@@ -866,10 +866,11 @@ ecma_number_to_int32 (ecma_number_t value) /**< unsigned 32-bit integer value */
 
 #if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64
 /**
- * Perform conversion of binary representation of number to decimal representation with decimal exponent
+  * Perform conversion of 128-bit binary representation of number
+  * to decimal representation with decimal exponent.
   */
 static void
-ecma_number_to_zt_string_to_decimal (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ARG (fraction_uint128), /**< mantissa */
+ecma_number_helper_binary_to_decimal (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ARG (fraction_uint128), /**< mantissa */
                                       int32_t binary_exponent, /**< binary exponent */
                                       int32_t *out_decimal_exp_p) /**< out: decimal exponent */
 {
@@ -927,13 +928,21 @@ ecma_number_to_zt_string_to_decimal (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ARG (
   }
 
   *out_decimal_exp_p = decimal_exp;
-} /* ecma_number_to_zt_string_to_decimal */
+} /* ecma_number_helper_binary_to_decimal */
+
+#endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64 */
 
 /**
- * Calculate s, n and k parameters for specified ecma-number according to ECMA-262 v5, 9.8.1, item 5
+  * Perform conversion of ecma-number to decimal representation with decimal exponent
+  *
+  * Note:
+  *      The calculated values correspond to s, n, k parameters in ECMA-262 v5, 9.8.1, item 5:
+  *         - s represents digits of the number;
+  *         - k is the number of digits;
+  *         - n is the decimal exponent.
   */
-static void
+void
-ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number */
+ecma_number_to_decimal (ecma_number_t num, /**< ecma-number */
                         uint64_t *out_digits_p, /**< out: digits */
                         int32_t *out_digits_num_p, /**< out: number of digits */
                         int32_t *out_decimal_exp_p) /**< out: decimal exponent */
@@ -942,6 +951,7 @@ ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number
   JERRY_ASSERT (!ecma_number_is_zero (num));
   JERRY_ASSERT (!ecma_number_is_infinity (num));
 
+#if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64
   ecma_number_t num_m1 = ecma_number_get_prev (num);
   ecma_number_t num_p1 = ecma_number_get_next (num);
 
@@ -978,9 +988,9 @@ ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number
                                               (fraction_uint64_p1) >> 32u,
                                               ((fraction_uint64_p1) << 32u) >> 32u);
 
-  ecma_number_to_zt_string_to_decimal (fraction_uint128, binary_exponent, &decimal_exp);
+  ecma_number_helper_binary_to_decimal (fraction_uint128, binary_exponent, &decimal_exp);
-  ecma_number_to_zt_string_to_decimal (fraction_uint128_m1, binary_exponent_m1, &decimal_exp_m1);
+  ecma_number_helper_binary_to_decimal (fraction_uint128_m1, binary_exponent_m1, &decimal_exp_m1);
-  ecma_number_to_zt_string_to_decimal (fraction_uint128_p1, binary_exponent_p1, &decimal_exp_p1);
+  ecma_number_helper_binary_to_decimal (fraction_uint128_p1, binary_exponent_p1, &decimal_exp_p1);
 
   if (ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_ZERO (fraction_uint128_m1))
   {
@@ -1018,7 +1028,6 @@ ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number
 
   /* While fraction doesn't fit to integer, divide it by 10
        and simultaneously increment decimal exponent */
-#if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64
   uint64_t digits_min, digits_max;
 
   while (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128_m1, 63))
@@ -1036,27 +1045,6 @@ ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number
   ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ROUND_MIDDLE_AND_LOW_TO_UINT64 (fraction_uint128_p1, digits_max);
 
   digits_min++;
-#elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32
-  uint64_t digits_uint64;
-  uint32_t digits_min, digits_max;
-
-  while (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128_m1, 31))
-  {
-    ECMA_NUMBER_CONVERSION_128BIT_INTEGER_DIV_10 (fraction_uint128_m1);
-    decimal_exp_m1++;
-  }
-  while (!ECMA_NUMBER_CONVERSION_128BIT_INTEGER_IS_HIGH_BIT_MASK_ZERO (fraction_uint128_p1, 31))
-  {
-    ECMA_NUMBER_CONVERSION_128BIT_INTEGER_DIV_10 (fraction_uint128_p1);
-    decimal_exp_p1++;
-  }
-
-  ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ROUND_MIDDLE_AND_LOW_TO_UINT64 (fraction_uint128_m1, digits_uint64);
-  digits_min = (uint32_t) digits_uint64 + 1;
-
-  ECMA_NUMBER_CONVERSION_128BIT_INTEGER_ROUND_MIDDLE_AND_LOW_TO_UINT64 (fraction_uint128_p1, digits_uint64);
-  digits_max = (uint32_t) digits_uint64;
-#endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */
 
   if (decimal_exp_m1 < decimal_exp_p1)
   {
@@ -1085,11 +1073,8 @@ ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number
 
   uint64_t digits = (digits_min + digits_max + 1) / 2;
   int32_t digits_num = 0;
-#if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64
   uint64_t t = digits;
-#elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32
+
-  uint32_t t = (uint32_t) digits;
-#endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */
   while (t != 0)
   {
     t /= 10;
@@ -1101,106 +1086,9 @@ ecma_number_to_zt_string_calc_number_params (ecma_number_t num, /**< ecma-number
   *out_digits_p = digits;
   *out_digits_num_p = digits_num;
   *out_decimal_exp_p = decimal_exp_p1 + digits_num;
-} /* ecma_number_to_zt_string_calc_number_params */
-
-#endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64 */
-
-/**
- * Convert ecma-number to zero-terminated string
- *
- * See also:
- *          ECMA-262 v5, 9.8.1
- *
- *
- * @return length of zt-string
- */
-ecma_length_t
-ecma_number_to_zt_string (ecma_number_t num, /**< ecma-number */
-                          ecma_char_t *buffer_p, /**< buffer for zt-string */
-                          ssize_t buffer_size) /**< size of buffer */
-{
-  const ecma_char_t digits[10] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
-  const ecma_char_t e_chars[2] = { 'e', 'E' };
-  const ecma_char_t plus_char = '+';
-  const ecma_char_t minus_char = '-';
-  const ecma_char_t dot_char = '.';
-
-  if (ecma_number_is_nan (num))
-  {
-    // 1.
-    ecma_copy_zt_string_to_buffer (ecma_get_magic_string_zt (ECMA_MAGIC_STRING_NAN),
-                                   buffer_p,
-                                   buffer_size);
-  }
-  else
-  {
-    ecma_char_t *dst_p = buffer_p;
-
-    if (ecma_number_is_zero (num))
-    {
-      // 2.
-      *dst_p++ = digits[0];
-      *dst_p++ = ECMA_CHAR_NULL;
-
-      JERRY_ASSERT ((uint8_t*)dst_p - (uint8_t*)buffer_p <= (ssize_t) buffer_size);
-    }
-    else if (ecma_number_is_negative (num))
-    {
-      // 3.
-      *dst_p++ = minus_char;
-      ssize_t new_buffer_size = (buffer_size - ((uint8_t*)dst_p - (uint8_t*)buffer_p));
-      ecma_number_to_zt_string (ecma_number_negate (num), dst_p, new_buffer_size);
-    }
-    else if (ecma_number_is_infinity (num))
-    {
-      // 4.
-      ecma_copy_zt_string_to_buffer (ecma_get_magic_string_zt (ECMA_MAGIC_STRING_INFINITY_UL),
-                                     buffer_p,
-                                     buffer_size);
-    }
-    else
-    {
-      ecma_number_t p = ecma_number_get_prev (num);
-      ecma_number_t q = ecma_number_get_next (p);
-      JERRY_ASSERT (q == num);
-
-      // 5.
-      uint32_t num_uint32 = ecma_number_to_uint32 (num);
-      if (ecma_uint32_to_number (num_uint32) == num)
-      {
-        ecma_uint32_to_string (num_uint32, dst_p, buffer_size);
-      }
-      else
-      {
-#if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64
-        uint64_t fraction_uint64;
-        int32_t binary_exponent;
-
-        ecma_number_get_fraction_and_exponent (num, &fraction_uint64, &binary_exponent);
-
-        /* mantissa */
-        uint64_t s_uint64;
-        /* decimal exponent */
-        int32_t n;
-        /* number of digits in k */
-        int32_t k;
-
-        ecma_number_to_zt_string_calc_number_params (num,
-                                                     &s_uint64,
-                                                     &k,
-                                                     &n);
-
-#if CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT64
-        uint64_t s = s_uint64;
-#elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32
-        uint32_t s = (uint32_t) s_uint64;
-
-        JERRY_ASSERT (s == s_uint64);
-#endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */
 
 #elif CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32
   /* Less precise conversion */
-
   uint64_t fraction_uint64;
   uint32_t fraction;
   int32_t exponent;
@@ -1312,7 +1200,90 @@ ecma_number_to_zt_string (ecma_number_t num, /**< ecma-number */
     k++;
     frac_part = new_frac_part;
   }
+
+  JERRY_ASSERT (k > 0);
+
+  *out_digits_p = s;
+  *out_digits_num_p = k;
+  *out_decimal_exp_p = n;
 #endif /* CONFIG_ECMA_NUMBER_TYPE == CONFIG_ECMA_NUMBER_FLOAT32 */
+} /* ecma_number_to_decimal */
+
+/**
+ * Convert ecma-number to zero-terminated string
+ *
+ * See also:
+ *          ECMA-262 v5, 9.8.1
+ *
+ *
+ * @return length of zt-string
+ */
+ecma_length_t
+ecma_number_to_zt_string (ecma_number_t num, /**< ecma-number */
+                          ecma_char_t *buffer_p, /**< buffer for zt-string */
+                          ssize_t buffer_size) /**< size of buffer */
+{
+  const ecma_char_t digits[10] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
+  const ecma_char_t e_chars[2] = { 'e', 'E' };
+  const ecma_char_t plus_char = '+';
+  const ecma_char_t minus_char = '-';
+  const ecma_char_t dot_char = '.';
+
+  if (ecma_number_is_nan (num))
+  {
+    // 1.
+    ecma_copy_zt_string_to_buffer (ecma_get_magic_string_zt (ECMA_MAGIC_STRING_NAN),
+                                   buffer_p,
+                                   buffer_size);
+  }
+  else
+  {
+    ecma_char_t *dst_p = buffer_p;
+
+    if (ecma_number_is_zero (num))
+    {
+      // 2.
+      *dst_p++ = digits[0];
+      *dst_p++ = ECMA_CHAR_NULL;
+
+      JERRY_ASSERT ((uint8_t*)dst_p - (uint8_t*)buffer_p <= (ssize_t) buffer_size);
+    }
+    else if (ecma_number_is_negative (num))
+    {
+      // 3.
+      *dst_p++ = minus_char;
+      ssize_t new_buffer_size = (buffer_size - ((uint8_t*)dst_p - (uint8_t*)buffer_p));
+      ecma_number_to_zt_string (ecma_number_negate (num), dst_p, new_buffer_size);
+    }
+    else if (ecma_number_is_infinity (num))
+    {
+      // 4.
+      ecma_copy_zt_string_to_buffer (ecma_get_magic_string_zt (ECMA_MAGIC_STRING_INFINITY_UL),
+                                     buffer_p,
+                                     buffer_size);
+    }
+    else
+    {
+      ecma_number_t p = ecma_number_get_prev (num);
+      ecma_number_t q = ecma_number_get_next (p);
+      JERRY_ASSERT (q == num);
+
+      // 5.
+      uint32_t num_uint32 = ecma_number_to_uint32 (num);
+      if (ecma_uint32_to_number (num_uint32) == num)
+      {
+        ecma_uint32_to_string (num_uint32, dst_p, buffer_size);
+      }
+      else
+      {
+        /* mantissa */
+        uint64_t s;
+        /* decimal exponent */
+        int32_t n;
+        /* number of digits in k */
+        int32_t k;
+
+        ecma_number_to_decimal (num, &s, &k, &n);
 
         // 6.
         if (k <= n && n <= 21)

jerry-core/ecma/base/ecma-helpers-number.cpp

@@ -1,4 +1,5 @@
 /* Copyright 2014 Samsung Electronics Co., Ltd.
+ * Copyright 2015 University of Szeged.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

jerry-core/ecma/base/ecma-helpers.h

@@ -1,4 +1,5 @@
 /* Copyright 2014-2015 Samsung Electronics Co., Ltd.
+ * Copyright 2015 University of Szeged.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -192,6 +193,10 @@ extern ecma_number_t ecma_number_sqrt (ecma_number_t num);
 extern ecma_number_t ecma_number_abs (ecma_number_t num);
 extern ecma_number_t ecma_number_ln (ecma_number_t num);
 extern ecma_number_t ecma_number_exp (ecma_number_t num);
+extern void ecma_number_to_decimal (ecma_number_t num,
+                                    uint64_t *out_digits_p,
+                                    int32_t *out_digits_num_p,
+                                    int32_t *out_decimal_exp_p);
 
 /* ecma-helpers-values-collection.c */
 

jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.cpp

@@ -1,4 +1,5 @@
 /* Copyright 2014-2015 Samsung Electronics Co., Ltd.
+ * Copyright 2015 University of Szeged.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -44,6 +45,34 @@
  * @{
  */
 
+/**
+ * Helper for rounding numbers
+ *
+ * @return rounded number
+ */
+static uint64_t
+ecma_builtin_number_prototype_helper_round (uint64_t digits, /**< actual number **/
+                                            int32_t round_num) /**< number of digits to round off **/
+{
+  int8_t digit = 0;
+
+  /* Remove unneeded precision digits. */
+  while (round_num > 0)
+  {
+    digit = (int8_t) (digits % 10);
+    digits /= 10;
+    round_num--;
+  }
+
+  /* Round the last digit up if neccessary */
+  if (digit >= 5)
+  {
+    digits++;
+  }
+
+  return digits;
+} /* ecma_builtin_number_prototype_helper_round */
+
 /**
  * The Number.prototype object's 'toString' routine
  *
@@ -166,7 +195,185 @@ static ecma_completion_value_t
 ecma_builtin_number_prototype_object_to_fixed (ecma_value_t this_arg, /**< this argument */
                                                ecma_value_t arg) /**< routine's argument */
 {
-  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ECMA_OP_TO_NUMBER_TRY_CATCH (this_num, this_arg, ret_value);
+  ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
+
+  /* 1. */
+  int32_t frac_digits = ecma_number_to_int32 (arg_num);
+
+  /* 2. */
+  if (frac_digits < 0 || frac_digits > 20)
+  {
+    ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_RANGE));
+  }
+  else
+  {
+    /* 4. */
+    if (ecma_number_is_nan (this_num))
+    {
+      ecma_string_t *nan_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_NAN);
+      ret_value = ecma_make_normal_completion_value (ecma_make_string_value (nan_str_p));
+    }
+    else
+    {
+      bool is_negative = false;
+
+      /* 6. */
+      if (ecma_number_is_negative (this_num))
+      {
+        is_negative = true;
+        this_num *= -1;
+      }
+
+      /* We handle infinities separately. */
+      if (ecma_number_is_infinity (this_num))
+      {
+        ecma_string_t *infinity_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_INFINITY_UL);
+
+        if (is_negative)
+        {
+          ecma_string_t *neg_str_p = ecma_new_ecma_string ((const ecma_char_t *) "-");
+          ecma_string_t *neg_inf_str_p = ecma_concat_ecma_strings (neg_str_p, infinity_str_p);
+          ecma_deref_ecma_string (infinity_str_p);
+          ecma_deref_ecma_string (neg_str_p);
+          ret_value = ecma_make_normal_completion_value (ecma_make_string_value (neg_inf_str_p));
+        }
+        else
+        {
+          ret_value = ecma_make_normal_completion_value (ecma_make_string_value (infinity_str_p));
+        }
+      }
+      else
+      {
+        uint64_t digits = 0;
+        int32_t num_digits = 0;
+        int32_t exponent = 1;
+
+        /* Get the parameters of the number if non-zero. */
+        if (!ecma_number_is_zero (this_num))
+        {
+          ecma_number_to_decimal (this_num, &digits, &num_digits, &exponent);
+        }
+
+        digits = ecma_builtin_number_prototype_helper_round (digits, num_digits - exponent - frac_digits);
+
+        /* 7. */
+        if (exponent > 21)
+        {
+          ret_value = ecma_builtin_number_prototype_object_to_string (this_arg, NULL, 0);
+        }
+        /* 8. */
+        else
+        {
+          /* Buffer that is used to construct the string. */
+          int buffer_size = (exponent > 0) ? exponent + frac_digits + 1 : frac_digits + 2;
+          JERRY_ASSERT (buffer_size > 0);
+          MEM_DEFINE_LOCAL_ARRAY (buff, buffer_size, ecma_char_t);
+
+          ecma_char_t* p = buff;
+
+          if (is_negative)
+          {
+            *p++ = '-';
+          }
+
+          int8_t digit = 0;
+          uint64_t s = 1;
+
+          /* Calculate the magnitude of the number. This is used to get the digits from left to right. */
+          while (s <= digits)
+          {
+            s *= 10;
+          }
+
+          if (exponent <= 0)
+          {
+            /* Add leading zeros. */
+            *p++ = '0';
+
+            if (frac_digits != 0)
+            {
+              *p++ = '.';
+            }
+
+            for (int i = 0; i < -exponent && i < frac_digits; i++)
+            {
+              *p++ = '0';
+            }
+
+            /* Add significant digits. */
+            for (int i = -exponent; i < frac_digits; i++)
+            {
+              digit = 0;
+              s /= 10;
+
+              while (digits >= s && s > 0)
+              {
+                digits -= s;
+                digit++;
+              }
+
+              *p = (ecma_char_t) ((ecma_char_t) digit + '0');
+              p++;
+            }
+          }
+          else
+          {
+            /* Add significant digits. */
+            for (int i = 0; i < exponent; i++)
+            {
+              digit = 0;
+              s /= 10;
+
+              while (digits >= s && s > 0)
+              {
+                digits -= s;
+                digit++;
+              }
+
+              *p = (ecma_char_t) ((ecma_char_t) digit + '0');
+              p++;
+            }
+
+            /* Add the decimal point after whole part. */
+            if (frac_digits != 0)
+            {
+              *p++ = '.';
+            }
+
+            /* Add neccessary fracion digits. */
+            for (int i = 0; i < frac_digits; i++)
+            {
+              digit = 0;
+              s /= 10;
+
+              while (digits >= s && s > 0)
+              {
+                digits -= s;
+                digit++;
+              }
+
+              *p = (ecma_char_t) ((ecma_char_t) digit + '0');
+              p++;
+            }
+          }
+
+          /* String terminator. */
+          *p = 0;
+          ecma_string_t* str = ecma_new_ecma_string ((ecma_char_t *) buff);
+
+          ret_value = ecma_make_normal_completion_value (ecma_make_string_value (str));
+          MEM_FINALIZE_LOCAL_ARRAY (buff);
+        }
+      }
+    }
+  }
+
+  ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+  ECMA_OP_TO_NUMBER_FINALIZE (this_num);
+  return ret_value;
 } /* ecma_builtin_number_prototype_object_to_fixed */
 
 /**

tests/jerry/number_prototype_to_fixed.js

@@ -0,0 +1,61 @@
+// Copyright 2015 Samsung Electronics Co., Ltd.
+// Copyright 2015 University of Szeged.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//This test will not pass on FLOAT32 due to precision issues
+
+assert((123.56).toFixed() === "124");
+assert((123.56).toFixed(0) === "124");
+assert((123.56).toFixed(1) === "123.6");
+assert((123.56).toFixed(5) === "123.56000");
+assert((1.23e-10).toFixed(2) === "0.00");
+assert((1.23e+20).toFixed(2) === "123000000000000000000.00");
+assert((1.23e+21).toFixed(2) === "1.23e+21");
+assert((-1.23).toFixed(1) === "-1.2");
+assert((0.00023).toFixed(0) === "0");
+assert((0.356).toFixed(2) === "0.36");
+assert((0.0000356).toFixed(5) === "0.00004");
+assert((0.000030056).toFixed(7) === "0.0000301");
+assert(Infinity.toFixed(0) === "Infinity");
+assert((-Infinity).toFixed(0) === "-Infinity");
+assert(NaN.toFixed(0) === "NaN");
+assert((0.0).toFixed(0) === "0");
+assert((0.0).toFixed(1) === "0.0");
+assert((-0.0).toFixed(0) === "-0");
+assert((-0.0).toFixed(1) === "-0.0");
+assert((123456789012345678901.0).toFixed(20) === "123456789012345680000.00000000000000000000");
+
+var obj = { toFixed : Number.prototype.toFixed };
+assert(obj.toFixed(0) === "NaN");
+
+try {
+    assert(obj.toFixed(-1));
+    assert(false);
+} catch (e) {
+    assert(e instanceof RangeError);
+}
+
+try {
+    (12).toFixed(-1);
+    assert(false);
+} catch (e) {
+    assert(e instanceof RangeError)
+}
+
+try {
+    (12).toFixed(21);
+    assert(false);
+} catch (e) {
+    assert(e instanceof RangeError)
+}