test-fixed-dtoa.cc 17.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
// Copyright 2010 the V8 project authors. 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 <stdlib.h>

30
#include "src/v8.h"
31

32
#include "src/base/platform/platform.h"
33 34 35 36
#include "src/double.h"
#include "src/fixed-dtoa.h"
#include "test/cctest/cctest.h"
#include "test/cctest/gay-fixed.h"
37

38 39
namespace v8 {
namespace internal {
40 41 42 43 44 45 46 47 48 49

static const int kBufferSize = 500;

TEST(FastFixedVariousDoubles) {
  char buffer_container[kBufferSize];
  Vector<char> buffer(buffer_container, kBufferSize);
  int length;
  int point;

  CHECK(FastFixedDtoa(1.0, 1, buffer, &length, &point));
50
  CHECK_EQ(0, strcmp("1", buffer.start()));
51 52 53
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(1.0, 15, buffer, &length, &point));
54
  CHECK_EQ(0, strcmp("1", buffer.start()));
55 56 57
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(1.0, 0, buffer, &length, &point));
58
  CHECK_EQ(0, strcmp("1", buffer.start()));
59 60 61
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0xFFFFFFFF, 5, buffer, &length, &point));
62
  CHECK_EQ(0, strcmp("4294967295", buffer.start()));
63 64 65
  CHECK_EQ(10, point);

  CHECK(FastFixedDtoa(4294967296.0, 5, buffer, &length, &point));
66
  CHECK_EQ(0, strcmp("4294967296", buffer.start()));
67 68 69
  CHECK_EQ(10, point);

  CHECK(FastFixedDtoa(1e21, 5, buffer, &length, &point));
70
  CHECK_EQ(0, strcmp("1", buffer.start()));
71 72 73 74
  // CHECK_EQ(22, point);
  CHECK_EQ(22, point);

  CHECK(FastFixedDtoa(999999999999999868928.00, 2, buffer, &length, &point));
75
  CHECK_EQ(0, strcmp("999999999999999868928", buffer.start()));
76 77 78 79
  CHECK_EQ(21, point);

  CHECK(FastFixedDtoa(6.9999999999999989514240000e+21, 5, buffer,
                      &length, &point));
80
  CHECK_EQ(0, strcmp("6999999999999998951424", buffer.start()));
81 82 83
  CHECK_EQ(22, point);

  CHECK(FastFixedDtoa(1.5, 5, buffer, &length, &point));
84
  CHECK_EQ(0, strcmp("15", buffer.start()));
85 86 87
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(1.55, 5, buffer, &length, &point));
88
  CHECK_EQ(0, strcmp("155", buffer.start()));
89 90 91
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(1.55, 1, buffer, &length, &point));
92
  CHECK_EQ(0, strcmp("16", buffer.start()));
93 94 95
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(1.00000001, 15, buffer, &length, &point));
96
  CHECK_EQ(0, strcmp("100000001", buffer.start()));
97 98 99
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.1, 10, buffer, &length, &point));
100
  CHECK_EQ(0, strcmp("1", buffer.start()));
101 102 103
  CHECK_EQ(0, point);

  CHECK(FastFixedDtoa(0.01, 10, buffer, &length, &point));
104
  CHECK_EQ(0, strcmp("1", buffer.start()));
105 106 107
  CHECK_EQ(-1, point);

  CHECK(FastFixedDtoa(0.001, 10, buffer, &length, &point));
108
  CHECK_EQ(0, strcmp("1", buffer.start()));
109 110 111
  CHECK_EQ(-2, point);

  CHECK(FastFixedDtoa(0.0001, 10, buffer, &length, &point));
112
  CHECK_EQ(0, strcmp("1", buffer.start()));
113 114 115
  CHECK_EQ(-3, point);

  CHECK(FastFixedDtoa(0.00001, 10, buffer, &length, &point));
116
  CHECK_EQ(0, strcmp("1", buffer.start()));
117 118 119
  CHECK_EQ(-4, point);

  CHECK(FastFixedDtoa(0.000001, 10, buffer, &length, &point));
120
  CHECK_EQ(0, strcmp("1", buffer.start()));
121 122 123
  CHECK_EQ(-5, point);

  CHECK(FastFixedDtoa(0.0000001, 10, buffer, &length, &point));
124
  CHECK_EQ(0, strcmp("1", buffer.start()));
125 126 127
  CHECK_EQ(-6, point);

  CHECK(FastFixedDtoa(0.00000001, 10, buffer, &length, &point));
128
  CHECK_EQ(0, strcmp("1", buffer.start()));
129 130 131
  CHECK_EQ(-7, point);

  CHECK(FastFixedDtoa(0.000000001, 10, buffer, &length, &point));
132
  CHECK_EQ(0, strcmp("1", buffer.start()));
133 134 135
  CHECK_EQ(-8, point);

  CHECK(FastFixedDtoa(0.0000000001, 15, buffer, &length, &point));
136
  CHECK_EQ(0, strcmp("1", buffer.start()));
137 138 139
  CHECK_EQ(-9, point);

  CHECK(FastFixedDtoa(0.00000000001, 15, buffer, &length, &point));
140
  CHECK_EQ(0, strcmp("1", buffer.start()));
141 142 143
  CHECK_EQ(-10, point);

  CHECK(FastFixedDtoa(0.000000000001, 15, buffer, &length, &point));
144
  CHECK_EQ(0, strcmp("1", buffer.start()));
145 146 147
  CHECK_EQ(-11, point);

  CHECK(FastFixedDtoa(0.0000000000001, 15, buffer, &length, &point));
148
  CHECK_EQ(0, strcmp("1", buffer.start()));
149 150 151
  CHECK_EQ(-12, point);

  CHECK(FastFixedDtoa(0.00000000000001, 15, buffer, &length, &point));
152
  CHECK_EQ(0, strcmp("1", buffer.start()));
153 154 155
  CHECK_EQ(-13, point);

  CHECK(FastFixedDtoa(0.000000000000001, 20, buffer, &length, &point));
156
  CHECK_EQ(0, strcmp("1", buffer.start()));
157 158 159
  CHECK_EQ(-14, point);

  CHECK(FastFixedDtoa(0.0000000000000001, 20, buffer, &length, &point));
160
  CHECK_EQ(0, strcmp("1", buffer.start()));
161 162 163
  CHECK_EQ(-15, point);

  CHECK(FastFixedDtoa(0.00000000000000001, 20, buffer, &length, &point));
164
  CHECK_EQ(0, strcmp("1", buffer.start()));
165 166 167
  CHECK_EQ(-16, point);

  CHECK(FastFixedDtoa(0.000000000000000001, 20, buffer, &length, &point));
168
  CHECK_EQ(0, strcmp("1", buffer.start()));
169 170 171
  CHECK_EQ(-17, point);

  CHECK(FastFixedDtoa(0.0000000000000000001, 20, buffer, &length, &point));
172
  CHECK_EQ(0, strcmp("1", buffer.start()));
173 174 175
  CHECK_EQ(-18, point);

  CHECK(FastFixedDtoa(0.00000000000000000001, 20, buffer, &length, &point));
176
  CHECK_EQ(0, strcmp("1", buffer.start()));
177 178 179
  CHECK_EQ(-19, point);

  CHECK(FastFixedDtoa(0.10000000004, 10, buffer, &length, &point));
180
  CHECK_EQ(0, strcmp("1", buffer.start()));
181 182 183
  CHECK_EQ(0, point);

  CHECK(FastFixedDtoa(0.01000000004, 10, buffer, &length, &point));
184
  CHECK_EQ(0, strcmp("1", buffer.start()));
185 186 187
  CHECK_EQ(-1, point);

  CHECK(FastFixedDtoa(0.00100000004, 10, buffer, &length, &point));
188
  CHECK_EQ(0, strcmp("1", buffer.start()));
189 190 191
  CHECK_EQ(-2, point);

  CHECK(FastFixedDtoa(0.00010000004, 10, buffer, &length, &point));
192
  CHECK_EQ(0, strcmp("1", buffer.start()));
193 194 195
  CHECK_EQ(-3, point);

  CHECK(FastFixedDtoa(0.00001000004, 10, buffer, &length, &point));
196
  CHECK_EQ(0, strcmp("1", buffer.start()));
197 198 199
  CHECK_EQ(-4, point);

  CHECK(FastFixedDtoa(0.00000100004, 10, buffer, &length, &point));
200
  CHECK_EQ(0, strcmp("1", buffer.start()));
201 202 203
  CHECK_EQ(-5, point);

  CHECK(FastFixedDtoa(0.00000010004, 10, buffer, &length, &point));
204
  CHECK_EQ(0, strcmp("1", buffer.start()));
205 206 207
  CHECK_EQ(-6, point);

  CHECK(FastFixedDtoa(0.00000001004, 10, buffer, &length, &point));
208
  CHECK_EQ(0, strcmp("1", buffer.start()));
209 210 211
  CHECK_EQ(-7, point);

  CHECK(FastFixedDtoa(0.00000000104, 10, buffer, &length, &point));
212
  CHECK_EQ(0, strcmp("1", buffer.start()));
213 214 215
  CHECK_EQ(-8, point);

  CHECK(FastFixedDtoa(0.0000000001000004, 15, buffer, &length, &point));
216
  CHECK_EQ(0, strcmp("1", buffer.start()));
217 218 219
  CHECK_EQ(-9, point);

  CHECK(FastFixedDtoa(0.0000000000100004, 15, buffer, &length, &point));
220
  CHECK_EQ(0, strcmp("1", buffer.start()));
221 222 223
  CHECK_EQ(-10, point);

  CHECK(FastFixedDtoa(0.0000000000010004, 15, buffer, &length, &point));
224
  CHECK_EQ(0, strcmp("1", buffer.start()));
225 226 227
  CHECK_EQ(-11, point);

  CHECK(FastFixedDtoa(0.0000000000001004, 15, buffer, &length, &point));
228
  CHECK_EQ(0, strcmp("1", buffer.start()));
229 230 231
  CHECK_EQ(-12, point);

  CHECK(FastFixedDtoa(0.0000000000000104, 15, buffer, &length, &point));
232
  CHECK_EQ(0, strcmp("1", buffer.start()));
233 234 235
  CHECK_EQ(-13, point);

  CHECK(FastFixedDtoa(0.000000000000001000004, 20, buffer, &length, &point));
236
  CHECK_EQ(0, strcmp("1", buffer.start()));
237 238 239
  CHECK_EQ(-14, point);

  CHECK(FastFixedDtoa(0.000000000000000100004, 20, buffer, &length, &point));
240
  CHECK_EQ(0, strcmp("1", buffer.start()));
241 242 243
  CHECK_EQ(-15, point);

  CHECK(FastFixedDtoa(0.000000000000000010004, 20, buffer, &length, &point));
244
  CHECK_EQ(0, strcmp("1", buffer.start()));
245 246 247
  CHECK_EQ(-16, point);

  CHECK(FastFixedDtoa(0.000000000000000001004, 20, buffer, &length, &point));
248
  CHECK_EQ(0, strcmp("1", buffer.start()));
249 250 251
  CHECK_EQ(-17, point);

  CHECK(FastFixedDtoa(0.000000000000000000104, 20, buffer, &length, &point));
252
  CHECK_EQ(0, strcmp("1", buffer.start()));
253 254 255
  CHECK_EQ(-18, point);

  CHECK(FastFixedDtoa(0.000000000000000000014, 20, buffer, &length, &point));
256
  CHECK_EQ(0, strcmp("1", buffer.start()));
257 258 259
  CHECK_EQ(-19, point);

  CHECK(FastFixedDtoa(0.10000000006, 10, buffer, &length, &point));
260
  CHECK_EQ(0, strcmp("1000000001", buffer.start()));
261 262 263
  CHECK_EQ(0, point);

  CHECK(FastFixedDtoa(0.01000000006, 10, buffer, &length, &point));
264
  CHECK_EQ(0, strcmp("100000001", buffer.start()));
265 266 267
  CHECK_EQ(-1, point);

  CHECK(FastFixedDtoa(0.00100000006, 10, buffer, &length, &point));
268
  CHECK_EQ(0, strcmp("10000001", buffer.start()));
269 270 271
  CHECK_EQ(-2, point);

  CHECK(FastFixedDtoa(0.00010000006, 10, buffer, &length, &point));
272
  CHECK_EQ(0, strcmp("1000001", buffer.start()));
273 274 275
  CHECK_EQ(-3, point);

  CHECK(FastFixedDtoa(0.00001000006, 10, buffer, &length, &point));
276
  CHECK_EQ(0, strcmp("100001", buffer.start()));
277 278 279
  CHECK_EQ(-4, point);

  CHECK(FastFixedDtoa(0.00000100006, 10, buffer, &length, &point));
280
  CHECK_EQ(0, strcmp("10001", buffer.start()));
281 282 283
  CHECK_EQ(-5, point);

  CHECK(FastFixedDtoa(0.00000010006, 10, buffer, &length, &point));
284
  CHECK_EQ(0, strcmp("1001", buffer.start()));
285 286 287
  CHECK_EQ(-6, point);

  CHECK(FastFixedDtoa(0.00000001006, 10, buffer, &length, &point));
288
  CHECK_EQ(0, strcmp("101", buffer.start()));
289 290 291
  CHECK_EQ(-7, point);

  CHECK(FastFixedDtoa(0.00000000106, 10, buffer, &length, &point));
292
  CHECK_EQ(0, strcmp("11", buffer.start()));
293 294 295
  CHECK_EQ(-8, point);

  CHECK(FastFixedDtoa(0.0000000001000006, 15, buffer, &length, &point));
296
  CHECK_EQ(0, strcmp("100001", buffer.start()));
297 298 299
  CHECK_EQ(-9, point);

  CHECK(FastFixedDtoa(0.0000000000100006, 15, buffer, &length, &point));
300
  CHECK_EQ(0, strcmp("10001", buffer.start()));
301 302 303
  CHECK_EQ(-10, point);

  CHECK(FastFixedDtoa(0.0000000000010006, 15, buffer, &length, &point));
304
  CHECK_EQ(0, strcmp("1001", buffer.start()));
305 306 307
  CHECK_EQ(-11, point);

  CHECK(FastFixedDtoa(0.0000000000001006, 15, buffer, &length, &point));
308
  CHECK_EQ(0, strcmp("101", buffer.start()));
309 310 311
  CHECK_EQ(-12, point);

  CHECK(FastFixedDtoa(0.0000000000000106, 15, buffer, &length, &point));
312
  CHECK_EQ(0, strcmp("11", buffer.start()));
313 314 315
  CHECK_EQ(-13, point);

  CHECK(FastFixedDtoa(0.000000000000001000006, 20, buffer, &length, &point));
316
  CHECK_EQ(0, strcmp("100001", buffer.start()));
317 318 319
  CHECK_EQ(-14, point);

  CHECK(FastFixedDtoa(0.000000000000000100006, 20, buffer, &length, &point));
320
  CHECK_EQ(0, strcmp("10001", buffer.start()));
321 322 323
  CHECK_EQ(-15, point);

  CHECK(FastFixedDtoa(0.000000000000000010006, 20, buffer, &length, &point));
324
  CHECK_EQ(0, strcmp("1001", buffer.start()));
325 326 327
  CHECK_EQ(-16, point);

  CHECK(FastFixedDtoa(0.000000000000000001006, 20, buffer, &length, &point));
328
  CHECK_EQ(0, strcmp("101", buffer.start()));
329 330 331
  CHECK_EQ(-17, point);

  CHECK(FastFixedDtoa(0.000000000000000000106, 20, buffer, &length, &point));
332
  CHECK_EQ(0, strcmp("11", buffer.start()));
333 334 335
  CHECK_EQ(-18, point);

  CHECK(FastFixedDtoa(0.000000000000000000016, 20, buffer, &length, &point));
336
  CHECK_EQ(0, strcmp("2", buffer.start()));
337 338 339
  CHECK_EQ(-19, point);

  CHECK(FastFixedDtoa(0.6, 0, buffer, &length, &point));
340
  CHECK_EQ(0, strcmp("1", buffer.start()));
341 342 343
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.96, 1, buffer, &length, &point));
344
  CHECK_EQ(0, strcmp("1", buffer.start()));
345 346 347
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.996, 2, buffer, &length, &point));
348
  CHECK_EQ(0, strcmp("1", buffer.start()));
349 350 351
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.9996, 3, buffer, &length, &point));
352
  CHECK_EQ(0, strcmp("1", buffer.start()));
353 354 355
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.99996, 4, buffer, &length, &point));
356
  CHECK_EQ(0, strcmp("1", buffer.start()));
357 358 359
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.999996, 5, buffer, &length, &point));
360
  CHECK_EQ(0, strcmp("1", buffer.start()));
361 362 363
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.9999996, 6, buffer, &length, &point));
364
  CHECK_EQ(0, strcmp("1", buffer.start()));
365 366 367
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.99999996, 7, buffer, &length, &point));
368
  CHECK_EQ(0, strcmp("1", buffer.start()));
369 370 371
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.999999996, 8, buffer, &length, &point));
372
  CHECK_EQ(0, strcmp("1", buffer.start()));
373 374 375
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.9999999996, 9, buffer, &length, &point));
376
  CHECK_EQ(0, strcmp("1", buffer.start()));
377 378 379
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.99999999996, 10, buffer, &length, &point));
380
  CHECK_EQ(0, strcmp("1", buffer.start()));
381 382 383
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.999999999996, 11, buffer, &length, &point));
384
  CHECK_EQ(0, strcmp("1", buffer.start()));
385 386 387
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.9999999999996, 12, buffer, &length, &point));
388
  CHECK_EQ(0, strcmp("1", buffer.start()));
389 390 391
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.99999999999996, 13, buffer, &length, &point));
392
  CHECK_EQ(0, strcmp("1", buffer.start()));
393 394 395
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.999999999999996, 14, buffer, &length, &point));
396
  CHECK_EQ(0, strcmp("1", buffer.start()));
397 398 399
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.9999999999999996, 15, buffer, &length, &point));
400
  CHECK_EQ(0, strcmp("1", buffer.start()));
401 402 403
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(0.00999999999999996, 16, buffer, &length, &point));
404
  CHECK_EQ(0, strcmp("1", buffer.start()));
405 406 407
  CHECK_EQ(-1, point);

  CHECK(FastFixedDtoa(0.000999999999999996, 17, buffer, &length, &point));
408
  CHECK_EQ(0, strcmp("1", buffer.start()));
409 410 411
  CHECK_EQ(-2, point);

  CHECK(FastFixedDtoa(0.0000999999999999996, 18, buffer, &length, &point));
412
  CHECK_EQ(0, strcmp("1", buffer.start()));
413 414 415
  CHECK_EQ(-3, point);

  CHECK(FastFixedDtoa(0.00000999999999999996, 19, buffer, &length, &point));
416
  CHECK_EQ(0, strcmp("1", buffer.start()));
417 418 419
  CHECK_EQ(-4, point);

  CHECK(FastFixedDtoa(0.000000999999999999996, 20, buffer, &length, &point));
420
  CHECK_EQ(0, strcmp("1", buffer.start()));
421 422 423
  CHECK_EQ(-5, point);

  CHECK(FastFixedDtoa(323423.234234, 10, buffer, &length, &point));
424
  CHECK_EQ(0, strcmp("323423234234", buffer.start()));
425 426 427
  CHECK_EQ(6, point);

  CHECK(FastFixedDtoa(12345678.901234, 4, buffer, &length, &point));
428
  CHECK_EQ(0, strcmp("123456789012", buffer.start()));
429 430 431
  CHECK_EQ(8, point);

  CHECK(FastFixedDtoa(98765.432109, 5, buffer, &length, &point));
432
  CHECK_EQ(0, strcmp("9876543211", buffer.start()));
433 434 435
  CHECK_EQ(5, point);

  CHECK(FastFixedDtoa(42, 20, buffer, &length, &point));
436
  CHECK_EQ(0, strcmp("42", buffer.start()));
437 438 439
  CHECK_EQ(2, point);

  CHECK(FastFixedDtoa(0.5, 0, buffer, &length, &point));
440
  CHECK_EQ(0, strcmp("1", buffer.start()));
441 442 443
  CHECK_EQ(1, point);

  CHECK(FastFixedDtoa(1e-23, 10, buffer, &length, &point));
444
  CHECK_EQ(0, strcmp("", buffer.start()));
445 446 447
  CHECK_EQ(-10, point);

  CHECK(FastFixedDtoa(1e-123, 2, buffer, &length, &point));
448
  CHECK_EQ(0, strcmp("", buffer.start()));
449 450 451
  CHECK_EQ(-2, point);

  CHECK(FastFixedDtoa(1e-123, 0, buffer, &length, &point));
452
  CHECK_EQ(0, strcmp("", buffer.start()));
453 454 455
  CHECK_EQ(0, point);

  CHECK(FastFixedDtoa(1e-23, 20, buffer, &length, &point));
456
  CHECK_EQ(0, strcmp("", buffer.start()));
457 458 459
  CHECK_EQ(-20, point);

  CHECK(FastFixedDtoa(1e-21, 20, buffer, &length, &point));
460
  CHECK_EQ(0, strcmp("", buffer.start()));
461 462 463
  CHECK_EQ(-20, point);

  CHECK(FastFixedDtoa(1e-22, 20, buffer, &length, &point));
464
  CHECK_EQ(0, strcmp("", buffer.start()));
465 466 467
  CHECK_EQ(-20, point);

  CHECK(FastFixedDtoa(6e-21, 20, buffer, &length, &point));
468
  CHECK_EQ(0, strcmp("1", buffer.start()));
469 470 471 472
  CHECK_EQ(-19, point);

  CHECK(FastFixedDtoa(9.1193616301674545152000000e+19, 0,
                      buffer, &length, &point));
473
  CHECK_EQ(0, strcmp("91193616301674545152", buffer.start()));
474 475 476 477
  CHECK_EQ(20, point);

  CHECK(FastFixedDtoa(4.8184662102767651659096515e-04, 19,
                      buffer, &length, &point));
478
  CHECK_EQ(0, strcmp("4818466210276765", buffer.start()));
479 480 481 482
  CHECK_EQ(-3, point);

  CHECK(FastFixedDtoa(1.9023164229540652612705182e-23, 8,
                      buffer, &length, &point));
483
  CHECK_EQ(0, strcmp("", buffer.start()));
484 485 486 487
  CHECK_EQ(-8, point);

  CHECK(FastFixedDtoa(1000000000000000128.0, 0,
                      buffer, &length, &point));
488
  CHECK_EQ(0, strcmp("1000000000000000128", buffer.start()));
489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
  CHECK_EQ(19, point);
}


TEST(FastFixedDtoaGayFixed) {
  char buffer_container[kBufferSize];
  Vector<char> buffer(buffer_container, kBufferSize);
  bool status;
  int length;
  int point;

  Vector<const PrecomputedFixed> precomputed =
      PrecomputedFixedRepresentations();
  for (int i = 0; i < precomputed.length(); ++i) {
    const PrecomputedFixed current_test = precomputed[i];
    double v = current_test.v;
    int number_digits = current_test.number_digits;
    status = FastFixedDtoa(v, number_digits,
                           buffer, &length, &point);
    CHECK(status);
    CHECK_EQ(current_test.decimal_point, point);
    CHECK_GE(number_digits, length - point);
511
    CHECK_EQ(0, strcmp(current_test.representation, buffer.start()));
512 513
  }
}
514 515 516

}  // namespace internal
}  // namespace v8