Home | History | Annotate | Download | only in cctest 
      1 // Copyright 2010 the V8 project authors. All rights reserved.
      2 // Redistribution and use in source and binary forms, with or without
      3 // modification, are permitted provided that the following conditions are
      4 // met:
      5 //
      6 //     * Redistributions of source code must retain the above copyright
      7 //       notice, this list of conditions and the following disclaimer.
      8 //     * Redistributions in binary form must reproduce the above
      9 //       copyright notice, this list of conditions and the following
     10 //       disclaimer in the documentation and/or other materials provided
     11 //       with the distribution.
     12 //     * Neither the name of Google Inc. nor the names of its
     13 //       contributors may be used to endorse or promote products derived
     14 //       from this software without specific prior written permission.
     15 //
     16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 
     28 #include <stdlib.h>
     29 
     30 #include "v8.h"
     31 
     32 #include "platform.h"
     33 #include "cctest.h"
     34 #include "double.h"
     35 #include "fixed-dtoa.h"
     36 #include "gay-fixed.h"
     37 
     38 using namespace v8::internal;
     39 
     40 static const int kBufferSize = 500;
     41 
     42 TEST(FastFixedVariousDoubles) {
     43   char buffer_container[kBufferSize];
     44   Vector<char> buffer(buffer_container, kBufferSize);
     45   int length;
     46   int point;
     47 
     48   CHECK(FastFixedDtoa(1.0, 1, buffer, &length, &point));
     49   CHECK_EQ("1", buffer.start());
     50   CHECK_EQ(1, point);
     51 
     52   CHECK(FastFixedDtoa(1.0, 15, buffer, &length, &point));
     53   CHECK_EQ("1", buffer.start());
     54   CHECK_EQ(1, point);
     55 
     56   CHECK(FastFixedDtoa(1.0, 0, buffer, &length, &point));
     57   CHECK_EQ("1", buffer.start());
     58   CHECK_EQ(1, point);
     59 
     60   CHECK(FastFixedDtoa(0xFFFFFFFF, 5, buffer, &length, &point));
     61   CHECK_EQ("4294967295", buffer.start());
     62   CHECK_EQ(10, point);
     63 
     64   CHECK(FastFixedDtoa(4294967296.0, 5, buffer, &length, &point));
     65   CHECK_EQ("4294967296", buffer.start());
     66   CHECK_EQ(10, point);
     67 
     68   CHECK(FastFixedDtoa(1e21, 5, buffer, &length, &point));
     69   CHECK_EQ("1", buffer.start());
     70   // CHECK_EQ(22, point);
     71   CHECK_EQ(22, point);
     72 
     73   CHECK(FastFixedDtoa(999999999999999868928.00, 2, buffer, &length, &point));
     74   CHECK_EQ("999999999999999868928", buffer.start());
     75   CHECK_EQ(21, point);
     76 
     77   CHECK(FastFixedDtoa(6.9999999999999989514240000e+21, 5, buffer,
     78                       &length, &point));
     79   CHECK_EQ("6999999999999998951424", buffer.start());
     80   CHECK_EQ(22, point);
     81 
     82   CHECK(FastFixedDtoa(1.5, 5, buffer, &length, &point));
     83   CHECK_EQ("15", buffer.start());
     84   CHECK_EQ(1, point);
     85 
     86   CHECK(FastFixedDtoa(1.55, 5, buffer, &length, &point));
     87   CHECK_EQ("155", buffer.start());
     88   CHECK_EQ(1, point);
     89 
     90   CHECK(FastFixedDtoa(1.55, 1, buffer, &length, &point));
     91   CHECK_EQ("16", buffer.start());
     92   CHECK_EQ(1, point);
     93 
     94   CHECK(FastFixedDtoa(1.00000001, 15, buffer, &length, &point));
     95   CHECK_EQ("100000001", buffer.start());
     96   CHECK_EQ(1, point);
     97 
     98   CHECK(FastFixedDtoa(0.1, 10, buffer, &length, &point));
     99   CHECK_EQ("1", buffer.start());
    100   CHECK_EQ(0, point);
    101 
    102   CHECK(FastFixedDtoa(0.01, 10, buffer, &length, &point));
    103   CHECK_EQ("1", buffer.start());
    104   CHECK_EQ(-1, point);
    105 
    106   CHECK(FastFixedDtoa(0.001, 10, buffer, &length, &point));
    107   CHECK_EQ("1", buffer.start());
    108   CHECK_EQ(-2, point);
    109 
    110   CHECK(FastFixedDtoa(0.0001, 10, buffer, &length, &point));
    111   CHECK_EQ("1", buffer.start());
    112   CHECK_EQ(-3, point);
    113 
    114   CHECK(FastFixedDtoa(0.00001, 10, buffer, &length, &point));
    115   CHECK_EQ("1", buffer.start());
    116   CHECK_EQ(-4, point);
    117 
    118   CHECK(FastFixedDtoa(0.000001, 10, buffer, &length, &point));
    119   CHECK_EQ("1", buffer.start());
    120   CHECK_EQ(-5, point);
    121 
    122   CHECK(FastFixedDtoa(0.0000001, 10, buffer, &length, &point));
    123   CHECK_EQ("1", buffer.start());
    124   CHECK_EQ(-6, point);
    125 
    126   CHECK(FastFixedDtoa(0.00000001, 10, buffer, &length, &point));
    127   CHECK_EQ("1", buffer.start());
    128   CHECK_EQ(-7, point);
    129 
    130   CHECK(FastFixedDtoa(0.000000001, 10, buffer, &length, &point));
    131   CHECK_EQ("1", buffer.start());
    132   CHECK_EQ(-8, point);
    133 
    134   CHECK(FastFixedDtoa(0.0000000001, 15, buffer, &length, &point));
    135   CHECK_EQ("1", buffer.start());
    136   CHECK_EQ(-9, point);
    137 
    138   CHECK(FastFixedDtoa(0.00000000001, 15, buffer, &length, &point));
    139   CHECK_EQ("1", buffer.start());
    140   CHECK_EQ(-10, point);
    141 
    142   CHECK(FastFixedDtoa(0.000000000001, 15, buffer, &length, &point));
    143   CHECK_EQ("1", buffer.start());
    144   CHECK_EQ(-11, point);
    145 
    146   CHECK(FastFixedDtoa(0.0000000000001, 15, buffer, &length, &point));
    147   CHECK_EQ("1", buffer.start());
    148   CHECK_EQ(-12, point);
    149 
    150   CHECK(FastFixedDtoa(0.00000000000001, 15, buffer, &length, &point));
    151   CHECK_EQ("1", buffer.start());
    152   CHECK_EQ(-13, point);
    153 
    154   CHECK(FastFixedDtoa(0.000000000000001, 20, buffer, &length, &point));
    155   CHECK_EQ("1", buffer.start());
    156   CHECK_EQ(-14, point);
    157 
    158   CHECK(FastFixedDtoa(0.0000000000000001, 20, buffer, &length, &point));
    159   CHECK_EQ("1", buffer.start());
    160   CHECK_EQ(-15, point);
    161 
    162   CHECK(FastFixedDtoa(0.00000000000000001, 20, buffer, &length, &point));
    163   CHECK_EQ("1", buffer.start());
    164   CHECK_EQ(-16, point);
    165 
    166   CHECK(FastFixedDtoa(0.000000000000000001, 20, buffer, &length, &point));
    167   CHECK_EQ("1", buffer.start());
    168   CHECK_EQ(-17, point);
    169 
    170   CHECK(FastFixedDtoa(0.0000000000000000001, 20, buffer, &length, &point));
    171   CHECK_EQ("1", buffer.start());
    172   CHECK_EQ(-18, point);
    173 
    174   CHECK(FastFixedDtoa(0.00000000000000000001, 20, buffer, &length, &point));
    175   CHECK_EQ("1", buffer.start());
    176   CHECK_EQ(-19, point);
    177 
    178   CHECK(FastFixedDtoa(0.10000000004, 10, buffer, &length, &point));
    179   CHECK_EQ("1", buffer.start());
    180   CHECK_EQ(0, point);
    181 
    182   CHECK(FastFixedDtoa(0.01000000004, 10, buffer, &length, &point));
    183   CHECK_EQ("1", buffer.start());
    184   CHECK_EQ(-1, point);
    185 
    186   CHECK(FastFixedDtoa(0.00100000004, 10, buffer, &length, &point));
    187   CHECK_EQ("1", buffer.start());
    188   CHECK_EQ(-2, point);
    189 
    190   CHECK(FastFixedDtoa(0.00010000004, 10, buffer, &length, &point));
    191   CHECK_EQ("1", buffer.start());
    192   CHECK_EQ(-3, point);
    193 
    194   CHECK(FastFixedDtoa(0.00001000004, 10, buffer, &length, &point));
    195   CHECK_EQ("1", buffer.start());
    196   CHECK_EQ(-4, point);
    197 
    198   CHECK(FastFixedDtoa(0.00000100004, 10, buffer, &length, &point));
    199   CHECK_EQ("1", buffer.start());
    200   CHECK_EQ(-5, point);
    201 
    202   CHECK(FastFixedDtoa(0.00000010004, 10, buffer, &length, &point));
    203   CHECK_EQ("1", buffer.start());
    204   CHECK_EQ(-6, point);
    205 
    206   CHECK(FastFixedDtoa(0.00000001004, 10, buffer, &length, &point));
    207   CHECK_EQ("1", buffer.start());
    208   CHECK_EQ(-7, point);
    209 
    210   CHECK(FastFixedDtoa(0.00000000104, 10, buffer, &length, &point));
    211   CHECK_EQ("1", buffer.start());
    212   CHECK_EQ(-8, point);
    213 
    214   CHECK(FastFixedDtoa(0.0000000001000004, 15, buffer, &length, &point));
    215   CHECK_EQ("1", buffer.start());
    216   CHECK_EQ(-9, point);
    217 
    218   CHECK(FastFixedDtoa(0.0000000000100004, 15, buffer, &length, &point));
    219   CHECK_EQ("1", buffer.start());
    220   CHECK_EQ(-10, point);
    221 
    222   CHECK(FastFixedDtoa(0.0000000000010004, 15, buffer, &length, &point));
    223   CHECK_EQ("1", buffer.start());
    224   CHECK_EQ(-11, point);
    225 
    226   CHECK(FastFixedDtoa(0.0000000000001004, 15, buffer, &length, &point));
    227   CHECK_EQ("1", buffer.start());
    228   CHECK_EQ(-12, point);
    229 
    230   CHECK(FastFixedDtoa(0.0000000000000104, 15, buffer, &length, &point));
    231   CHECK_EQ("1", buffer.start());
    232   CHECK_EQ(-13, point);
    233 
    234   CHECK(FastFixedDtoa(0.000000000000001000004, 20, buffer, &length, &point));
    235   CHECK_EQ("1", buffer.start());
    236   CHECK_EQ(-14, point);
    237 
    238   CHECK(FastFixedDtoa(0.000000000000000100004, 20, buffer, &length, &point));
    239   CHECK_EQ("1", buffer.start());
    240   CHECK_EQ(-15, point);
    241 
    242   CHECK(FastFixedDtoa(0.000000000000000010004, 20, buffer, &length, &point));
    243   CHECK_EQ("1", buffer.start());
    244   CHECK_EQ(-16, point);
    245 
    246   CHECK(FastFixedDtoa(0.000000000000000001004, 20, buffer, &length, &point));
    247   CHECK_EQ("1", buffer.start());
    248   CHECK_EQ(-17, point);
    249 
    250   CHECK(FastFixedDtoa(0.000000000000000000104, 20, buffer, &length, &point));
    251   CHECK_EQ("1", buffer.start());
    252   CHECK_EQ(-18, point);
    253 
    254   CHECK(FastFixedDtoa(0.000000000000000000014, 20, buffer, &length, &point));
    255   CHECK_EQ("1", buffer.start());
    256   CHECK_EQ(-19, point);
    257 
    258   CHECK(FastFixedDtoa(0.10000000006, 10, buffer, &length, &point));
    259   CHECK_EQ("1000000001", buffer.start());
    260   CHECK_EQ(0, point);
    261 
    262   CHECK(FastFixedDtoa(0.01000000006, 10, buffer, &length, &point));
    263   CHECK_EQ("100000001", buffer.start());
    264   CHECK_EQ(-1, point);
    265 
    266   CHECK(FastFixedDtoa(0.00100000006, 10, buffer, &length, &point));
    267   CHECK_EQ("10000001", buffer.start());
    268   CHECK_EQ(-2, point);
    269 
    270   CHECK(FastFixedDtoa(0.00010000006, 10, buffer, &length, &point));
    271   CHECK_EQ("1000001", buffer.start());
    272   CHECK_EQ(-3, point);
    273 
    274   CHECK(FastFixedDtoa(0.00001000006, 10, buffer, &length, &point));
    275   CHECK_EQ("100001", buffer.start());
    276   CHECK_EQ(-4, point);
    277 
    278   CHECK(FastFixedDtoa(0.00000100006, 10, buffer, &length, &point));
    279   CHECK_EQ("10001", buffer.start());
    280   CHECK_EQ(-5, point);
    281 
    282   CHECK(FastFixedDtoa(0.00000010006, 10, buffer, &length, &point));
    283   CHECK_EQ("1001", buffer.start());
    284   CHECK_EQ(-6, point);
    285 
    286   CHECK(FastFixedDtoa(0.00000001006, 10, buffer, &length, &point));
    287   CHECK_EQ("101", buffer.start());
    288   CHECK_EQ(-7, point);
    289 
    290   CHECK(FastFixedDtoa(0.00000000106, 10, buffer, &length, &point));
    291   CHECK_EQ("11", buffer.start());
    292   CHECK_EQ(-8, point);
    293 
    294   CHECK(FastFixedDtoa(0.0000000001000006, 15, buffer, &length, &point));
    295   CHECK_EQ("100001", buffer.start());
    296   CHECK_EQ(-9, point);
    297 
    298   CHECK(FastFixedDtoa(0.0000000000100006, 15, buffer, &length, &point));
    299   CHECK_EQ("10001", buffer.start());
    300   CHECK_EQ(-10, point);
    301 
    302   CHECK(FastFixedDtoa(0.0000000000010006, 15, buffer, &length, &point));
    303   CHECK_EQ("1001", buffer.start());
    304   CHECK_EQ(-11, point);
    305 
    306   CHECK(FastFixedDtoa(0.0000000000001006, 15, buffer, &length, &point));
    307   CHECK_EQ("101", buffer.start());
    308   CHECK_EQ(-12, point);
    309 
    310   CHECK(FastFixedDtoa(0.0000000000000106, 15, buffer, &length, &point));
    311   CHECK_EQ("11", buffer.start());
    312   CHECK_EQ(-13, point);
    313 
    314   CHECK(FastFixedDtoa(0.000000000000001000006, 20, buffer, &length, &point));
    315   CHECK_EQ("100001", buffer.start());
    316   CHECK_EQ(-14, point);
    317 
    318   CHECK(FastFixedDtoa(0.000000000000000100006, 20, buffer, &length, &point));
    319   CHECK_EQ("10001", buffer.start());
    320   CHECK_EQ(-15, point);
    321 
    322   CHECK(FastFixedDtoa(0.000000000000000010006, 20, buffer, &length, &point));
    323   CHECK_EQ("1001", buffer.start());
    324   CHECK_EQ(-16, point);
    325 
    326   CHECK(FastFixedDtoa(0.000000000000000001006, 20, buffer, &length, &point));
    327   CHECK_EQ("101", buffer.start());
    328   CHECK_EQ(-17, point);
    329 
    330   CHECK(FastFixedDtoa(0.000000000000000000106, 20, buffer, &length, &point));
    331   CHECK_EQ("11", buffer.start());
    332   CHECK_EQ(-18, point);
    333 
    334   CHECK(FastFixedDtoa(0.000000000000000000016, 20, buffer, &length, &point));
    335   CHECK_EQ("2", buffer.start());
    336   CHECK_EQ(-19, point);
    337 
    338   CHECK(FastFixedDtoa(0.6, 0, buffer, &length, &point));
    339   CHECK_EQ("1", buffer.start());
    340   CHECK_EQ(1, point);
    341 
    342   CHECK(FastFixedDtoa(0.96, 1, buffer, &length, &point));
    343   CHECK_EQ("1", buffer.start());
    344   CHECK_EQ(1, point);
    345 
    346   CHECK(FastFixedDtoa(0.996, 2, buffer, &length, &point));
    347   CHECK_EQ("1", buffer.start());
    348   CHECK_EQ(1, point);
    349 
    350   CHECK(FastFixedDtoa(0.9996, 3, buffer, &length, &point));
    351   CHECK_EQ("1", buffer.start());
    352   CHECK_EQ(1, point);
    353 
    354   CHECK(FastFixedDtoa(0.99996, 4, buffer, &length, &point));
    355   CHECK_EQ("1", buffer.start());
    356   CHECK_EQ(1, point);
    357 
    358   CHECK(FastFixedDtoa(0.999996, 5, buffer, &length, &point));
    359   CHECK_EQ("1", buffer.start());
    360   CHECK_EQ(1, point);
    361 
    362   CHECK(FastFixedDtoa(0.9999996, 6, buffer, &length, &point));
    363   CHECK_EQ("1", buffer.start());
    364   CHECK_EQ(1, point);
    365 
    366   CHECK(FastFixedDtoa(0.99999996, 7, buffer, &length, &point));
    367   CHECK_EQ("1", buffer.start());
    368   CHECK_EQ(1, point);
    369 
    370   CHECK(FastFixedDtoa(0.999999996, 8, buffer, &length, &point));
    371   CHECK_EQ("1", buffer.start());
    372   CHECK_EQ(1, point);
    373 
    374   CHECK(FastFixedDtoa(0.9999999996, 9, buffer, &length, &point));
    375   CHECK_EQ("1", buffer.start());
    376   CHECK_EQ(1, point);
    377 
    378   CHECK(FastFixedDtoa(0.99999999996, 10, buffer, &length, &point));
    379   CHECK_EQ("1", buffer.start());
    380   CHECK_EQ(1, point);
    381 
    382   CHECK(FastFixedDtoa(0.999999999996, 11, buffer, &length, &point));
    383   CHECK_EQ("1", buffer.start());
    384   CHECK_EQ(1, point);
    385 
    386   CHECK(FastFixedDtoa(0.9999999999996, 12, buffer, &length, &point));
    387   CHECK_EQ("1", buffer.start());
    388   CHECK_EQ(1, point);
    389 
    390   CHECK(FastFixedDtoa(0.99999999999996, 13, buffer, &length, &point));
    391   CHECK_EQ("1", buffer.start());
    392   CHECK_EQ(1, point);
    393 
    394   CHECK(FastFixedDtoa(0.999999999999996, 14, buffer, &length, &point));
    395   CHECK_EQ("1", buffer.start());
    396   CHECK_EQ(1, point);
    397 
    398   CHECK(FastFixedDtoa(0.9999999999999996, 15, buffer, &length, &point));
    399   CHECK_EQ("1", buffer.start());
    400   CHECK_EQ(1, point);
    401 
    402   CHECK(FastFixedDtoa(0.00999999999999996, 16, buffer, &length, &point));
    403   CHECK_EQ("1", buffer.start());
    404   CHECK_EQ(-1, point);
    405 
    406   CHECK(FastFixedDtoa(0.000999999999999996, 17, buffer, &length, &point));
    407   CHECK_EQ("1", buffer.start());
    408   CHECK_EQ(-2, point);
    409 
    410   CHECK(FastFixedDtoa(0.0000999999999999996, 18, buffer, &length, &point));
    411   CHECK_EQ("1", buffer.start());
    412   CHECK_EQ(-3, point);
    413 
    414   CHECK(FastFixedDtoa(0.00000999999999999996, 19, buffer, &length, &point));
    415   CHECK_EQ("1", buffer.start());
    416   CHECK_EQ(-4, point);
    417 
    418   CHECK(FastFixedDtoa(0.000000999999999999996, 20, buffer, &length, &point));
    419   CHECK_EQ("1", buffer.start());
    420   CHECK_EQ(-5, point);
    421 
    422   CHECK(FastFixedDtoa(323423.234234, 10, buffer, &length, &point));
    423   CHECK_EQ("323423234234", buffer.start());
    424   CHECK_EQ(6, point);
    425 
    426   CHECK(FastFixedDtoa(12345678.901234, 4, buffer, &length, &point));
    427   CHECK_EQ("123456789012", buffer.start());
    428   CHECK_EQ(8, point);
    429 
    430   CHECK(FastFixedDtoa(98765.432109, 5, buffer, &length, &point));
    431   CHECK_EQ("9876543211", buffer.start());
    432   CHECK_EQ(5, point);
    433 
    434   CHECK(FastFixedDtoa(42, 20, buffer, &length, &point));
    435   CHECK_EQ("42", buffer.start());
    436   CHECK_EQ(2, point);
    437 
    438   CHECK(FastFixedDtoa(0.5, 0, buffer, &length, &point));
    439   CHECK_EQ("1", buffer.start());
    440   CHECK_EQ(1, point);
    441 
    442   CHECK(FastFixedDtoa(1e-23, 10, buffer, &length, &point));
    443   CHECK_EQ("", buffer.start());
    444   CHECK_EQ(-10, point);
    445 
    446   CHECK(FastFixedDtoa(1e-123, 2, buffer, &length, &point));
    447   CHECK_EQ("", buffer.start());
    448   CHECK_EQ(-2, point);
    449 
    450   CHECK(FastFixedDtoa(1e-123, 0, buffer, &length, &point));
    451   CHECK_EQ("", buffer.start());
    452   CHECK_EQ(0, point);
    453 
    454   CHECK(FastFixedDtoa(1e-23, 20, buffer, &length, &point));
    455   CHECK_EQ("", buffer.start());
    456   CHECK_EQ(-20, point);
    457 
    458   CHECK(FastFixedDtoa(1e-21, 20, buffer, &length, &point));
    459   CHECK_EQ("", buffer.start());
    460   CHECK_EQ(-20, point);
    461 
    462   CHECK(FastFixedDtoa(1e-22, 20, buffer, &length, &point));
    463   CHECK_EQ("", buffer.start());
    464   CHECK_EQ(-20, point);
    465 
    466   CHECK(FastFixedDtoa(6e-21, 20, buffer, &length, &point));
    467   CHECK_EQ("1", buffer.start());
    468   CHECK_EQ(-19, point);
    469 
    470   CHECK(FastFixedDtoa(9.1193616301674545152000000e+19, 0,
    471                       buffer, &length, &point));
    472   CHECK_EQ("91193616301674545152", buffer.start());
    473   CHECK_EQ(20, point);
    474 
    475   CHECK(FastFixedDtoa(4.8184662102767651659096515e-04, 19,
    476                       buffer, &length, &point));
    477   CHECK_EQ("4818466210276765", buffer.start());
    478   CHECK_EQ(-3, point);
    479 
    480   CHECK(FastFixedDtoa(1.9023164229540652612705182e-23, 8,
    481                       buffer, &length, &point));
    482   CHECK_EQ("", buffer.start());
    483   CHECK_EQ(-8, point);
    484 
    485   CHECK(FastFixedDtoa(1000000000000000128.0, 0,
    486                       buffer, &length, &point));
    487   CHECK_EQ("1000000000000000128", buffer.start());
    488   CHECK_EQ(19, point);
    489 }
    490 
    491 
    492 TEST(FastFixedDtoaGayFixed) {
    493   char buffer_container[kBufferSize];
    494   Vector<char> buffer(buffer_container, kBufferSize);
    495   bool status;
    496   int length;
    497   int point;
    498 
    499   Vector<const PrecomputedFixed> precomputed =
    500       PrecomputedFixedRepresentations();
    501   for (int i = 0; i < precomputed.length(); ++i) {
    502     const PrecomputedFixed current_test = precomputed[i];
    503     double v = current_test.v;
    504     int number_digits = current_test.number_digits;
    505     status = FastFixedDtoa(v, number_digits,
    506                            buffer, &length, &point);
    507     CHECK(status);
    508     CHECK_EQ(current_test.decimal_point, point);
    509     CHECK_GE(number_digits, length - point);
    510     CHECK_EQ(current_test.representation, buffer.start());
    511   }
    512 }
    513