Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(700)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: runtime/third_party/double-conversion/test/cctest/test-conversions.cc

Issue 8632010: double-conversion drop. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Created 9 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« runtime/third_party/double-conversion/src/SConscript ('K') | « runtime/third_party/double-conversion/test/cctest/test-bignum-dtoa.cc ('k') | runtime/third_party/double-conversion/test/cctest/test-diy-fp.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2010 the V8 project authors. All rights reserved.
2
3 #include <string.h>
4
5 #include "cctest.h"
6 #include "double.h"
7 #include "double-conversion.h"
8 #include "utils.h"
9
10 // DoubleToString is already tested in test-dtoa.cc.
11
12 using namespace double_conversion;
13
14
15 TEST(DoubleToShortest) {
16 const int kBufferSize = 128;
17 char buffer[kBufferSize];
18 StringBuilder builder(buffer, kBufferSize);
19 int flags = DoubleToStringConverter::UNIQUE_ZERO |
20 DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
21 DoubleToStringConverter dc(flags, NULL, NULL, 'e', -6, 21, 0, 0);
22
23 CHECK(dc.ToShortest(0.0, &builder));
24 CHECK_EQ("0", builder.Finalize());
25
26 builder.Reset();
27 CHECK(dc.ToShortest(12345.0, &builder));
28 CHECK_EQ("12345", builder.Finalize());
29
30 builder.Reset();
31 CHECK(dc.ToShortest(12345e23, &builder));
32 CHECK_EQ("1.2345e+27", builder.Finalize());
33
34 builder.Reset();
35 CHECK(dc.ToShortest(1e21, &builder));
36 CHECK_EQ("1e+21", builder.Finalize());
37
38 builder.Reset();
39 CHECK(dc.ToShortest(1e20, &builder));
40 CHECK_EQ("100000000000000000000", builder.Finalize());
41
42 builder.Reset();
43 CHECK(dc.ToShortest(111111111111111111111.0, &builder));
44 CHECK_EQ("111111111111111110000", builder.Finalize());
45
46 builder.Reset();
47 CHECK(dc.ToShortest(1111111111111111111111.0, &builder));
48 CHECK_EQ("1.1111111111111111e+21", builder.Finalize());
49
50 builder.Reset();
51 CHECK(dc.ToShortest(11111111111111111111111.0, &builder));
52 CHECK_EQ("1.1111111111111111e+22", builder.Finalize());
53
54 builder.Reset();
55 CHECK(dc.ToShortest(-0.00001, &builder));
56 CHECK_EQ("-0.00001", builder.Finalize());
57
58 builder.Reset();
59 CHECK(dc.ToShortest(-0.000001, &builder));
60 CHECK_EQ("-0.000001", builder.Finalize());
61
62 builder.Reset();
63 CHECK(dc.ToShortest(-0.0000001, &builder));
64 CHECK_EQ("-1e-7", builder.Finalize());
65
66 builder.Reset();
67 CHECK(dc.ToShortest(-0.0, &builder));
68 CHECK_EQ("0", builder.Finalize());
69
70 flags = DoubleToStringConverter::NO_FLAGS;
71 DoubleToStringConverter dc2(flags, NULL, NULL, 'e', -1, 1, 0, 0);
72 builder.Reset();
73 CHECK(dc2.ToShortest(0.1, &builder));
74 CHECK_EQ("0.1", builder.Finalize());
75
76 builder.Reset();
77 CHECK(dc2.ToShortest(0.01, &builder));
78 CHECK_EQ("1e-2", builder.Finalize());
79
80 builder.Reset();
81 CHECK(dc2.ToShortest(1.0, &builder));
82 CHECK_EQ("1", builder.Finalize());
83
84 builder.Reset();
85 CHECK(dc2.ToShortest(10.0, &builder));
86 CHECK_EQ("1e1", builder.Finalize());
87
88 builder.Reset();
89 CHECK(dc2.ToShortest(-0.0, &builder));
90 CHECK_EQ("-0", builder.Finalize());
91
92 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
93 DoubleToStringConverter::EMIT_TRAILING_ZERO_AFTER_POINT;
94 DoubleToStringConverter dc3(flags, NULL, NULL, 'E', -5, 5, 0, 0);
95
96 builder.Reset();
97 CHECK(dc3.ToShortest(0.1, &builder));
98 CHECK_EQ("0.1", builder.Finalize());
99
100 builder.Reset();
101 CHECK(dc3.ToShortest(1.0, &builder));
102 CHECK_EQ("1.0", builder.Finalize());
103
104 builder.Reset();
105 CHECK(dc3.ToShortest(10000.0, &builder));
106 CHECK_EQ("10000.0", builder.Finalize());
107
108 builder.Reset();
109 CHECK(dc3.ToShortest(100000.0, &builder));
110 CHECK_EQ("1E5", builder.Finalize());
111
112 // Test the examples in the comments of ToShortest.
113 flags = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
114 DoubleToStringConverter dc4(flags, NULL, NULL, 'e', -6, 21, 0, 0);
115
116 builder.Reset();
117 CHECK(dc4.ToShortest(0.000001, &builder));
118 CHECK_EQ("0.000001", builder.Finalize());
119
120 builder.Reset();
121 CHECK(dc4.ToShortest(0.0000001, &builder));
122 CHECK_EQ("1e-7", builder.Finalize());
123
124 builder.Reset();
125 CHECK(dc4.ToShortest(111111111111111111111.0, &builder));
126 CHECK_EQ("111111111111111110000", builder.Finalize());
127
128 builder.Reset();
129 CHECK(dc4.ToShortest(100000000000000000000.0, &builder));
130 CHECK_EQ("100000000000000000000", builder.Finalize());
131
132 builder.Reset();
133 CHECK(dc4.ToShortest(1111111111111111111111.0, &builder));
134 CHECK_EQ("1.1111111111111111e+21", builder.Finalize());
135
136 // Test special value handling.
137 DoubleToStringConverter dc5(flags, NULL, NULL, 'e', 0, 0, 0, 0);
138
139 builder.Reset();
140 CHECK(!dc5.ToShortest(Double::Infinity(), &builder));
141
142 builder.Reset();
143 CHECK(!dc5.ToShortest(-Double::Infinity(), &builder));
144
145 builder.Reset();
146 CHECK(!dc5.ToShortest(Double::NaN(), &builder));
147
148 builder.Reset();
149 CHECK(!dc5.ToShortest(-Double::NaN(), &builder));
150
151 DoubleToStringConverter dc6(flags, "Infinity", "NaN", 'e', 0, 0, 0, 0);
152
153 builder.Reset();
154 CHECK(dc6.ToShortest(Double::Infinity(), &builder));
155 CHECK_EQ("Infinity", builder.Finalize());
156
157 builder.Reset();
158 CHECK(dc6.ToShortest(-Double::Infinity(), &builder));
159 CHECK_EQ("-Infinity", builder.Finalize());
160
161 builder.Reset();
162 CHECK(dc6.ToShortest(Double::NaN(), &builder));
163 CHECK_EQ("NaN", builder.Finalize());
164
165 builder.Reset();
166 CHECK(dc6.ToShortest(-Double::NaN(), &builder));
167 CHECK_EQ("NaN", builder.Finalize());
168 }
169
170
171 TEST(DoubleToFixed) {
172 const int kBufferSize = 128;
173 char buffer[kBufferSize];
174 StringBuilder builder(buffer, kBufferSize);
175 int flags = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN |
176 DoubleToStringConverter::UNIQUE_ZERO;
177 DoubleToStringConverter dc(flags, "Infinity", "NaN", 'e',
178 0, 0, 0, 0); // Padding zeroes.
179
180 CHECK(dc.ToFixed(0.0, 0, &builder));
181 CHECK_EQ("0", builder.Finalize());
182
183 builder.Reset();
184 CHECK(dc.ToFixed(-0.0, 0, &builder));
185 CHECK_EQ("0", builder.Finalize());
186
187 builder.Reset();
188 CHECK(dc.ToFixed(-0.0, 1, &builder));
189 CHECK_EQ("0.0", builder.Finalize());
190
191 builder.Reset();
192 CHECK(dc.ToFixed(-0.0, 1, &builder));
193 CHECK_EQ("0.0", builder.Finalize());
194
195 ASSERT(DoubleToStringConverter::kMaxFixedDigitsBeforePoint == 60);
196 ASSERT(DoubleToStringConverter::kMaxFixedDigitsAfterPoint == 60);
197 builder.Reset();
198 CHECK(dc.ToFixed(
199 0.0, DoubleToStringConverter::kMaxFixedDigitsAfterPoint, &builder));
200 CHECK_EQ("0.000000000000000000000000000000000000000000000000000000000000",
201 builder.Finalize());
202
203 builder.Reset();
204 CHECK(dc.ToFixed(
205 9e59, DoubleToStringConverter::kMaxFixedDigitsAfterPoint, &builder));
206 CHECK_EQ("899999999999999918767229449717619953810131273674690656206848."
207 "000000000000000000000000000000000000000000000000000000000000",
208 builder.Finalize());
209
210 builder.Reset();
211 CHECK(dc.ToFixed(
212 -9e59, DoubleToStringConverter::kMaxFixedDigitsAfterPoint, &builder));
213 CHECK_EQ("-899999999999999918767229449717619953810131273674690656206848."
214 "000000000000000000000000000000000000000000000000000000000000",
215 builder.Finalize());
216
217 builder.Reset();
218 CHECK(!dc.ToFixed(
219 1e60, DoubleToStringConverter::kMaxFixedDigitsAfterPoint, &builder));
220 CHECK_EQ(0, builder.position());
221
222 builder.Reset();
223 CHECK(!dc.ToFixed(
224 9e59, DoubleToStringConverter::kMaxFixedDigitsAfterPoint + 1, &builder));
225 CHECK_EQ(0, builder.position());
226
227 builder.Reset();
228 CHECK(dc.ToFixed(3.0, 0, &builder));
229 CHECK_EQ("3", builder.Finalize());
230
231 builder.Reset();
232 CHECK(dc.ToFixed(3.23, 1, &builder));
233 CHECK_EQ("3.2", builder.Finalize());
234
235 builder.Reset();
236 CHECK(dc.ToFixed(3.23, 3, &builder));
237 CHECK_EQ("3.230", builder.Finalize());
238
239 builder.Reset();
240 CHECK(dc.ToFixed(0.0323, 2, &builder));
241 CHECK_EQ("0.03", builder.Finalize());
242
243 builder.Reset();
244 CHECK(dc.ToFixed(0.0373, 2, &builder));
245 CHECK_EQ("0.04", builder.Finalize());
246
247 builder.Reset();
248 CHECK(dc.ToFixed(0.0000373, 2, &builder));
249 CHECK_EQ("0.00", builder.Finalize());
250
251 builder.Reset();
252 CHECK(dc.ToFixed(1.5, 0, &builder));
253 CHECK_EQ("2", builder.Finalize());
254
255 builder.Reset();
256 CHECK(dc.ToFixed(2.5, 0, &builder));
257 CHECK_EQ("3", builder.Finalize());
258
259 builder.Reset();
260 CHECK(dc.ToFixed(3.5, 0, &builder));
261 CHECK_EQ("4", builder.Finalize());
262
263 builder.Reset();
264 CHECK(dc.ToFixed(0.15, 1, &builder));
265 CHECK_EQ("0.1", builder.Finalize());
266
267 builder.Reset();
268 CHECK(dc.ToFixed(0.25, 1, &builder));
269 CHECK_EQ("0.3", builder.Finalize());
270
271 builder.Reset();
272 CHECK(dc.ToFixed(0.35, 1, &builder));
273 CHECK_EQ("0.3", builder.Finalize());
274
275 builder.Reset();
276 CHECK(dc.ToFixed(0.45, 1, &builder));
277 CHECK_EQ("0.5", builder.Finalize());
278
279 builder.Reset();
280 CHECK(dc.ToFixed(0.55, 1, &builder));
281 CHECK_EQ("0.6", builder.Finalize());
282
283 // Test positive/negative zeroes.
284 int flags2 = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
285 DoubleToStringConverter dc2(flags2, "Infinity", "NaN", 'e',
286 0, 0, 0, 0); // Padding zeroes.
287 builder.Reset();
288 CHECK(dc2.ToFixed(0.0, 1, &builder));
289 CHECK_EQ("0.0", builder.Finalize());
290
291 builder.Reset();
292 CHECK(dc2.ToFixed(-0.0, 1, &builder));
293 CHECK_EQ("-0.0", builder.Finalize());
294
295 // Verify the trailing dot is emitted.
296 int flags3 = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN |
297 DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT;
298 DoubleToStringConverter dc3(flags3, "Infinity", "NaN", 'e',
299 0, 0, 0, 0); // Padding zeroes.
300 builder.Reset();
301 CHECK(dc3.ToFixed(0.0, 0, &builder));
302 CHECK_EQ("0.", builder.Finalize());
303
304 builder.Reset();
305 CHECK(dc3.ToFixed(-0.0, 0, &builder));
306 CHECK_EQ("-0.", builder.Finalize());
307
308 builder.Reset();
309 CHECK(dc3.ToFixed(1.0, 0, &builder));
310 CHECK_EQ("1.", builder.Finalize());
311
312 builder.Reset();
313 CHECK(dc3.ToFixed(-1.0, 0, &builder));
314 CHECK_EQ("-1.", builder.Finalize());
315
316 // Verify no trailing zero is emitted, even if the configuration is set.
317 // The given parameter takes precedence.
318 int flags4 = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN |
319 DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
320 DoubleToStringConverter::EMIT_TRAILING_ZERO_AFTER_POINT;
321 DoubleToStringConverter dc4(flags4, "Infinity", "NaN", 'e',
322 0, 0, 0, 0); // Padding zeroes.
323 builder.Reset();
324 CHECK(dc4.ToFixed(0.0, 0, &builder));
325 CHECK_EQ("0.0", builder.Finalize());
326
327 builder.Reset();
328 CHECK(dc4.ToFixed(-0.0, 0, &builder));
329 CHECK_EQ("-0.0", builder.Finalize());
330
331 builder.Reset();
332 CHECK(dc4.ToFixed(1.0, 0, &builder));
333 CHECK_EQ("1.0", builder.Finalize());
334
335 builder.Reset();
336 CHECK(dc4.ToFixed(-1.0, 0, &builder));
337 CHECK_EQ("-1.0", builder.Finalize());
338
339 // Test the examples in the comments of ToFixed.
340 flags = DoubleToStringConverter::NO_FLAGS;
341 DoubleToStringConverter dc5(flags, NULL, NULL, 'e', 0, 0, 0, 0);
342
343 builder.Reset();
344 CHECK(dc5.ToFixed(3.12, 1, &builder));
345 CHECK_EQ("3.1", builder.Finalize());
346
347 builder.Reset();
348 CHECK(dc5.ToFixed(3.1415, 3, &builder));
349 CHECK_EQ("3.142", builder.Finalize());
350
351 builder.Reset();
352 CHECK(dc5.ToFixed(1234.56789, 4, &builder));
353 CHECK_EQ("1234.5679", builder.Finalize());
354
355 builder.Reset();
356 CHECK(dc5.ToFixed(1.23, 5, &builder));
357 CHECK_EQ("1.23000", builder.Finalize());
358
359 builder.Reset();
360 CHECK(dc5.ToFixed(0.1, 4, &builder));
361 CHECK_EQ("0.1000", builder.Finalize());
362
363 builder.Reset();
364 CHECK(dc5.ToFixed(1e30, 2, &builder));
365 CHECK_EQ("1000000000000000019884624838656.00", builder.Finalize());
366
367 builder.Reset();
368 CHECK(dc5.ToFixed(0.1, 30, &builder));
369 CHECK_EQ("0.100000000000000005551115123126", builder.Finalize());
370
371 builder.Reset();
372 CHECK(dc5.ToFixed(0.1, 17, &builder));
373 CHECK_EQ("0.10000000000000001", builder.Finalize());
374
375 builder.Reset();
376 CHECK(dc5.ToFixed(123.45, 0, &builder));
377 CHECK_EQ("123", builder.Finalize());
378
379 builder.Reset();
380 CHECK(dc5.ToFixed(0.678, 0, &builder));
381 CHECK_EQ("1", builder.Finalize());
382
383 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT;
384 DoubleToStringConverter dc6(flags, NULL, NULL, 'e', 0, 0, 0, 0);
385
386 builder.Reset();
387 CHECK(dc6.ToFixed(123.45, 0, &builder));
388 CHECK_EQ("123.", builder.Finalize());
389
390 builder.Reset();
391 CHECK(dc6.ToFixed(0.678, 0, &builder));
392 CHECK_EQ("1.", builder.Finalize());
393
394 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
395 DoubleToStringConverter::EMIT_TRAILING_ZERO_AFTER_POINT;
396 DoubleToStringConverter dc7(flags, NULL, NULL, 'e', 0, 0, 0, 0);
397
398 builder.Reset();
399 CHECK(dc7.ToFixed(123.45, 0, &builder));
400 CHECK_EQ("123.0", builder.Finalize());
401
402 builder.Reset();
403 CHECK(dc7.ToFixed(0.678, 0, &builder));
404 CHECK_EQ("1.0", builder.Finalize());
405
406 // Test special value handling.
407 DoubleToStringConverter dc8(flags, NULL, NULL, 'e', 0, 0, 0, 0);
408
409 builder.Reset();
410 CHECK(!dc8.ToFixed(Double::Infinity(), 1, &builder));
411
412 builder.Reset();
413 CHECK(!dc8.ToFixed(-Double::Infinity(), 1, &builder));
414
415 builder.Reset();
416 CHECK(!dc8.ToFixed(Double::NaN(), 1, &builder));
417
418 builder.Reset();
419 CHECK(!dc8.ToFixed(-Double::NaN(), 1, &builder));
420
421 DoubleToStringConverter dc9(flags, "Infinity", "NaN", 'e', 0, 0, 0, 0);
422
423 builder.Reset();
424 CHECK(dc9.ToFixed(Double::Infinity(), 1, &builder));
425 CHECK_EQ("Infinity", builder.Finalize());
426
427 builder.Reset();
428 CHECK(dc9.ToFixed(-Double::Infinity(), 1, &builder));
429 CHECK_EQ("-Infinity", builder.Finalize());
430
431 builder.Reset();
432 CHECK(dc9.ToFixed(Double::NaN(), 1, &builder));
433 CHECK_EQ("NaN", builder.Finalize());
434
435 builder.Reset();
436 CHECK(dc9.ToFixed(-Double::NaN(), 1, &builder));
437 CHECK_EQ("NaN", builder.Finalize());
438 }
439
440
441 TEST(DoubleToExponential) {
442 const int kBufferSize = 256;
443 char buffer[kBufferSize];
444 int flags = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN |
445 DoubleToStringConverter::UNIQUE_ZERO;
446 StringBuilder builder(buffer, kBufferSize);
447 DoubleToStringConverter dc(flags, "Infinity", "NaN", 'e', 0, 0, 0, 0);
448
449 builder.Reset();
450 CHECK(dc.ToExponential(0.0, 5, &builder));
451 CHECK_EQ("0.00000e+0", builder.Finalize());
452
453 builder.Reset();
454 CHECK(dc.ToExponential(0.0, 0, &builder));
455 CHECK_EQ("0e+0", builder.Finalize());
456
457 builder.Reset();
458 CHECK(dc.ToExponential(0.0, 1, &builder));
459 CHECK_EQ("0.0e+0", builder.Finalize());
460
461 builder.Reset();
462 CHECK(dc.ToExponential(0.123456, 5, &builder));
463 CHECK_EQ("1.23456e-1", builder.Finalize());
464
465 builder.Reset();
466 CHECK(dc.ToExponential(1.2, 1, &builder));
467 CHECK_EQ("1.2e+0", builder.Finalize());
468
469 builder.Reset();
470 CHECK(dc.ToExponential(-0.0, 1, &builder));
471 CHECK_EQ("0.0e+0", builder.Finalize());
472
473 builder.Reset();
474 CHECK(dc.ToExponential(0.0, 2, &builder));
475 CHECK_EQ("0.00e+0", builder.Finalize());
476
477 builder.Reset();
478 CHECK(dc.ToExponential(-0.0, 2, &builder));
479 CHECK_EQ("0.00e+0", builder.Finalize());
480
481 ASSERT(DoubleToStringConverter::kMaxExponentialDigits == 120);
482 builder.Reset();
483 CHECK(dc.ToExponential(
484 0.0, DoubleToStringConverter::kMaxExponentialDigits, &builder));
485 CHECK_EQ("0.00000000000000000000000000000000000000000000000000000000000"
486 "0000000000000000000000000000000000000000000000000000000000000e+0",
487 builder.Finalize());
488
489 builder.Reset();
490 CHECK(dc.ToExponential(
491 9e59, DoubleToStringConverter::kMaxExponentialDigits, &builder));
492 CHECK_EQ("8.99999999999999918767229449717619953810131273674690656206848"
493 "0000000000000000000000000000000000000000000000000000000000000e+59",
494 builder.Finalize());
495
496 builder.Reset();
497 CHECK(dc.ToExponential(
498 -9e59, DoubleToStringConverter::kMaxExponentialDigits, &builder));
499 CHECK_EQ("-8.99999999999999918767229449717619953810131273674690656206848"
500 "0000000000000000000000000000000000000000000000000000000000000e+59",
501 builder.Finalize());
502
503 const double max_double = 1.7976931348623157e308;
504 builder.Reset();
505 CHECK(dc.ToExponential(
506 max_double, DoubleToStringConverter::kMaxExponentialDigits, &builder));
507 CHECK_EQ("1.79769313486231570814527423731704356798070567525844996598917"
508 "4768031572607800285387605895586327668781715404589535143824642e+308",
509 builder.Finalize());
510
511 builder.Reset();
512 CHECK(dc.ToExponential(0.000001, 2, &builder));
513 CHECK_EQ("1.00e-6", builder.Finalize());
514
515 builder.Reset();
516 CHECK(dc.ToExponential(0.0000001, 2, &builder));
517 CHECK_EQ("1.00e-7", builder.Finalize());
518
519 // Test the examples in the comments of ToExponential.
520 flags = DoubleToStringConverter::NO_FLAGS;
521 DoubleToStringConverter dc2(flags, "Infinity", "NaN", 'e', 0, 0, 0, 0);
522
523 builder.Reset();
524 CHECK(dc2.ToExponential(3.12, 1, &builder));
525 CHECK_EQ("3.1e0", builder.Finalize());
526
527 builder.Reset();
528 CHECK(dc2.ToExponential(5.0, 3, &builder));
529 CHECK_EQ("5.000e0", builder.Finalize());
530
531 builder.Reset();
532 CHECK(dc2.ToExponential(0.001, 2, &builder));
533 CHECK_EQ("1.00e-3", builder.Finalize());
534
535 builder.Reset();
536 CHECK(dc2.ToExponential(3.1415, -1, &builder));
537 CHECK_EQ("3.1415e0", builder.Finalize());
538
539 builder.Reset();
540 CHECK(dc2.ToExponential(3.1415, 4, &builder));
541 CHECK_EQ("3.1415e0", builder.Finalize());
542
543 builder.Reset();
544 CHECK(dc2.ToExponential(3.1415, 3, &builder));
545 CHECK_EQ("3.142e0", builder.Finalize());
546
547 builder.Reset();
548 CHECK(dc2.ToExponential(123456789000000, 3, &builder));
549 CHECK_EQ("1.235e14", builder.Finalize());
550
551 builder.Reset();
552 CHECK(dc2.ToExponential(1000000000000000019884624838656.0, -1, &builder));
553 CHECK_EQ("1e30", builder.Finalize());
554
555 builder.Reset();
556 CHECK(dc2.ToExponential(1000000000000000019884624838656.0, 32, &builder));
557 CHECK_EQ("1.00000000000000001988462483865600e30", builder.Finalize());
558
559 builder.Reset();
560 CHECK(dc2.ToExponential(1234, 0, &builder));
561 CHECK_EQ("1e3", builder.Finalize());
562
563 // Test special value handling.
564 DoubleToStringConverter dc3(flags, NULL, NULL, 'e', 0, 0, 0, 0);
565
566 builder.Reset();
567 CHECK(!dc3.ToExponential(Double::Infinity(), 1, &builder));
568
569 builder.Reset();
570 CHECK(!dc3.ToExponential(-Double::Infinity(), 1, &builder));
571
572 builder.Reset();
573 CHECK(!dc3.ToExponential(Double::NaN(), 1, &builder));
574
575 builder.Reset();
576 CHECK(!dc3.ToExponential(-Double::NaN(), 1, &builder));
577
578 DoubleToStringConverter dc4(flags, "Infinity", "NaN", 'e', 0, 0, 0, 0);
579
580 builder.Reset();
581 CHECK(dc4.ToExponential(Double::Infinity(), 1, &builder));
582 CHECK_EQ("Infinity", builder.Finalize());
583
584 builder.Reset();
585 CHECK(dc4.ToExponential(-Double::Infinity(), 1, &builder));
586 CHECK_EQ("-Infinity", builder.Finalize());
587
588 builder.Reset();
589 CHECK(dc4.ToExponential(Double::NaN(), 1, &builder));
590 CHECK_EQ("NaN", builder.Finalize());
591
592 builder.Reset();
593 CHECK(dc4.ToExponential(-Double::NaN(), 1, &builder));
594 CHECK_EQ("NaN", builder.Finalize());
595 }
596
597
598 TEST(DoubleToPrecision) {
599 const int kBufferSize = 256;
600 char buffer[kBufferSize];
601 int flags = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN |
602 DoubleToStringConverter::UNIQUE_ZERO;
603 StringBuilder builder(buffer, kBufferSize);
604 DoubleToStringConverter dc(flags, "Infinity", "NaN", 'e',
605 0, 0, // Padding zeroes for shortest mode.
606 6, 0); // Padding zeroes for precision mode.
607
608 ASSERT(DoubleToStringConverter::kMinPrecisionDigits == 1);
609 CHECK(dc.ToPrecision(0.0, 1, &builder));
610 CHECK_EQ("0", builder.Finalize());
611
612 builder.Reset();
613 CHECK(dc.ToPrecision(-0.0, 1, &builder));
614 CHECK_EQ("0", builder.Finalize());
615
616 builder.Reset();
617 CHECK(dc.ToPrecision(0.0, 2, &builder));
618 CHECK_EQ("0.0", builder.Finalize());
619
620 builder.Reset();
621 CHECK(dc.ToPrecision(-0.0, 2, &builder));
622 CHECK_EQ("0.0", builder.Finalize());
623
624 ASSERT(DoubleToStringConverter::kMaxPrecisionDigits == 120);
625 builder.Reset();
626 CHECK(dc.ToPrecision(
627 0.0, DoubleToStringConverter::kMaxPrecisionDigits, &builder));
628 CHECK_EQ("0.00000000000000000000000000000000000000000000000000000000000"
629 "000000000000000000000000000000000000000000000000000000000000",
630 builder.Finalize());
631
632 builder.Reset();
633 CHECK(dc.ToPrecision(
634 9e59, DoubleToStringConverter::kMaxPrecisionDigits, &builder));
635 CHECK_EQ("899999999999999918767229449717619953810131273674690656206848."
636 "000000000000000000000000000000000000000000000000000000000000",
637 builder.Finalize());
638
639 builder.Reset();
640 CHECK(dc.ToPrecision(
641 -9e59, DoubleToStringConverter::kMaxPrecisionDigits, &builder));
642 CHECK_EQ("-899999999999999918767229449717619953810131273674690656206848."
643 "000000000000000000000000000000000000000000000000000000000000",
644 builder.Finalize());
645
646 const double max_double = 1.7976931348623157e308;
647 builder.Reset();
648 CHECK(dc.ToPrecision(
649 max_double, DoubleToStringConverter::kMaxPrecisionDigits, &builder));
650 CHECK_EQ("1.79769313486231570814527423731704356798070567525844996598917"
651 "476803157260780028538760589558632766878171540458953514382464e+308",
652 builder.Finalize());
653
654 builder.Reset();
655 CHECK(dc.ToPrecision(0.000001, 2, &builder));
656 CHECK_EQ("0.0000010", builder.Finalize());
657
658 builder.Reset();
659 CHECK(dc.ToPrecision(0.0000001, 2, &builder));
660 CHECK_EQ("1.0e-7", builder.Finalize());
661
662 flags = DoubleToStringConverter::NO_FLAGS;
663 DoubleToStringConverter dc2(flags, NULL, NULL, 'e', 0, 0, 0, 1);
664 builder.Reset();
665 CHECK(dc2.ToPrecision(230.0, 2, &builder));
666 CHECK_EQ("230", builder.Finalize());
667
668 builder.Reset();
669 CHECK(dc2.ToPrecision(23.0, 2, &builder));
670 CHECK_EQ("23", builder.Finalize());
671
672 builder.Reset();
673 CHECK(dc2.ToPrecision(2.30, 2, &builder));
674 CHECK_EQ("2.3", builder.Finalize());
675
676 builder.Reset();
677 CHECK(dc2.ToPrecision(2300.0, 2, &builder));
678 CHECK_EQ("2.3e3", builder.Finalize());
679
680 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT;
681 DoubleToStringConverter dc3(flags, NULL, NULL, 'e', 0, 0, 0, 1);
682 builder.Reset();
683 CHECK(dc3.ToPrecision(230.0, 2, &builder));
684 CHECK_EQ("230.", builder.Finalize());
685
686 builder.Reset();
687 CHECK(dc3.ToPrecision(23.0, 2, &builder));
688 CHECK_EQ("23.", builder.Finalize());
689
690 builder.Reset();
691 CHECK(dc3.ToPrecision(2.30, 2, &builder));
692 CHECK_EQ("2.3", builder.Finalize());
693
694 builder.Reset();
695 CHECK(dc3.ToPrecision(2300.0, 2, &builder));
696 CHECK_EQ("2.3e3", builder.Finalize());
697
698 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
699 DoubleToStringConverter::EMIT_TRAILING_ZERO_AFTER_POINT;
700 DoubleToStringConverter dc4(flags, NULL, NULL, 'e', 0, 0, 0, 1);
701 builder.Reset();
702 CHECK(dc4.ToPrecision(230.0, 2, &builder));
703 CHECK_EQ("2.3e2", builder.Finalize());
704
705 builder.Reset();
706 CHECK(dc4.ToPrecision(23.0, 2, &builder));
707 CHECK_EQ("23.0", builder.Finalize());
708
709 builder.Reset();
710 CHECK(dc4.ToPrecision(2.30, 2, &builder));
711 CHECK_EQ("2.3", builder.Finalize());
712
713 builder.Reset();
714 CHECK(dc4.ToPrecision(2300.0, 2, &builder));
715 CHECK_EQ("2.3e3", builder.Finalize());
716
717 // Test the examples in the comments of ToPrecision.
718 flags = DoubleToStringConverter::NO_FLAGS;
719 DoubleToStringConverter dc5(flags, "Infinity", "NaN", 'e', 0, 0, 6, 1);
720 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT;
721 DoubleToStringConverter dc6(flags, "Infinity", "NaN", 'e', 0, 0, 6, 1);
722 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
723 DoubleToStringConverter::EMIT_TRAILING_ZERO_AFTER_POINT;
724 DoubleToStringConverter dc7(flags, "Infinity", "NaN", 'e', 0, 0, 6, 1);
725
726 builder.Reset();
727 CHECK(dc5.ToPrecision(0.0000012345, 2, &builder));
728 CHECK_EQ("0.0000012", builder.Finalize());
729
730 builder.Reset();
731 CHECK(dc5.ToPrecision(0.00000012345, 2, &builder));
732 CHECK_EQ("1.2e-7", builder.Finalize());
733
734 builder.Reset();
735 CHECK(dc5.ToPrecision(230.0, 2, &builder));
736 CHECK_EQ("230", builder.Finalize());
737
738 builder.Reset();
739 CHECK(dc6.ToPrecision(230.0, 2, &builder));
740 CHECK_EQ("230.", builder.Finalize());
741
742 builder.Reset();
743 CHECK(dc7.ToPrecision(230.0, 2, &builder));
744 CHECK_EQ("2.3e2", builder.Finalize());
745
746 flags = DoubleToStringConverter::NO_FLAGS;
747 DoubleToStringConverter dc8(flags, NULL, NULL, 'e', 0, 0, 6, 3);
748
749 builder.Reset();
750 CHECK(dc8.ToPrecision(123450.0, 6, &builder));
751 CHECK_EQ("123450", builder.Finalize());
752
753 builder.Reset();
754 CHECK(dc8.ToPrecision(123450.0, 5, &builder));
755 CHECK_EQ("123450", builder.Finalize());
756
757 builder.Reset();
758 CHECK(dc8.ToPrecision(123450.0, 4, &builder));
759 CHECK_EQ("123500", builder.Finalize());
760
761 builder.Reset();
762 CHECK(dc8.ToPrecision(123450.0, 3, &builder));
763 CHECK_EQ("123000", builder.Finalize());
764
765 builder.Reset();
766 CHECK(dc8.ToPrecision(123450.0, 2, &builder));
767 CHECK_EQ("1.2e5", builder.Finalize());
768
769 // Test special value handling.
770 builder.Reset();
771 CHECK(!dc8.ToPrecision(Double::Infinity(), 1, &builder));
772
773 builder.Reset();
774 CHECK(!dc8.ToPrecision(-Double::Infinity(), 1, &builder));
775
776 builder.Reset();
777 CHECK(!dc8.ToPrecision(Double::NaN(), 1, &builder));
778
779 builder.Reset();
780 CHECK(!dc8.ToPrecision(-Double::NaN(), 1, &builder));
781
782 builder.Reset();
783 CHECK(dc7.ToPrecision(Double::Infinity(), 1, &builder));
784 CHECK_EQ("Infinity", builder.Finalize());
785
786 builder.Reset();
787 CHECK(dc7.ToPrecision(-Double::Infinity(), 1, &builder));
788 CHECK_EQ("-Infinity", builder.Finalize());
789
790 builder.Reset();
791 CHECK(dc7.ToPrecision(Double::NaN(), 1, &builder));
792 CHECK_EQ("NaN", builder.Finalize());
793
794 builder.Reset();
795 CHECK(dc7.ToPrecision(-Double::NaN(), 1, &builder));
796 CHECK_EQ("NaN", builder.Finalize());
797 }
798
799
800 TEST(DoubleToStringJavaScript) {
801 const int kBufferSize = 128;
802 char buffer[kBufferSize];
803 StringBuilder builder(buffer, kBufferSize);
804 const DoubleToStringConverter& dc =
805 DoubleToStringConverter::EcmaScriptConverter();
806
807 builder.Reset();
808 CHECK(dc.ToShortest(Double::NaN(), &builder));
809 CHECK_EQ("NaN", builder.Finalize());
810
811 builder.Reset();
812 CHECK(dc.ToShortest(Double::Infinity(), &builder));
813 CHECK_EQ("Infinity", builder.Finalize());
814
815 builder.Reset();
816 CHECK(dc.ToShortest(-Double::Infinity(), &builder));
817 CHECK_EQ("-Infinity", builder.Finalize());
818
819 builder.Reset();
820 CHECK(dc.ToShortest(0.0, &builder));
821 CHECK_EQ("0", builder.Finalize());
822
823 builder.Reset();
824 CHECK(dc.ToShortest(9.0, &builder));
825 CHECK_EQ("9", builder.Finalize());
826
827 builder.Reset();
828 CHECK(dc.ToShortest(90.0, &builder));
829 CHECK_EQ("90", builder.Finalize());
830
831 builder.Reset();
832 CHECK(dc.ToShortest(90.12, &builder));
833 CHECK_EQ("90.12", builder.Finalize());
834
835 builder.Reset();
836 CHECK(dc.ToShortest(0.1, &builder));
837 CHECK_EQ("0.1", builder.Finalize());
838
839 builder.Reset();
840 CHECK(dc.ToShortest(0.01, &builder));
841 CHECK_EQ("0.01", builder.Finalize());
842
843 builder.Reset();
844 CHECK(dc.ToShortest(0.0123, &builder));
845 CHECK_EQ("0.0123", builder.Finalize());
846
847 builder.Reset();
848 CHECK(dc.ToShortest(111111111111111111111.0, &builder));
849 CHECK_EQ("111111111111111110000", builder.Finalize());
850
851 builder.Reset();
852 CHECK(dc.ToShortest(100000000000000000000.0, &builder));
853 CHECK_EQ("100000000000000000000", builder.Finalize());
854
855 builder.Reset();
856 CHECK(dc.ToShortest(1111111111111111111111.0, &builder));
857 CHECK_EQ("1.1111111111111111e+21", builder.Finalize());
858
859 builder.Reset();
860 CHECK(dc.ToShortest(11111111111111111111111.0, &builder));
861 CHECK_EQ("1.1111111111111111e+22", builder.Finalize());
862
863 builder.Reset();
864 CHECK(dc.ToShortest(0.00001, &builder));
865 CHECK_EQ("0.00001", builder.Finalize());
866
867 builder.Reset();
868 CHECK(dc.ToShortest(0.000001, &builder));
869 CHECK_EQ("0.000001", builder.Finalize());
870
871 builder.Reset();
872 CHECK(dc.ToShortest(0.0000001, &builder));
873 CHECK_EQ("1e-7", builder.Finalize());
874
875 builder.Reset();
876 CHECK(dc.ToShortest(0.00000012, &builder));
877 CHECK_EQ("1.2e-7", builder.Finalize());
878
879 builder.Reset();
880 CHECK(dc.ToShortest(0.000000123, &builder));
881 CHECK_EQ("1.23e-7", builder.Finalize());
882
883 builder.Reset();
884 CHECK(dc.ToShortest(0.00000001, &builder));
885 CHECK_EQ("1e-8", builder.Finalize());
886
887 builder.Reset();
888 CHECK(dc.ToShortest(0.000000012, &builder));
889 CHECK_EQ("1.2e-8", builder.Finalize());
890
891 builder.Reset();
892 CHECK(dc.ToShortest(0.000000012, &builder));
893 CHECK_EQ("1.2e-8", builder.Finalize());
894
895 builder.Reset();
896 CHECK(dc.ToShortest(0.0000000123, &builder));
897 CHECK_EQ("1.23e-8", builder.Finalize());
898
899 builder.Reset();
900 CHECK(dc.ToShortest(-0.0, &builder));
901 CHECK_EQ("0", builder.Finalize());
902
903 builder.Reset();
904 CHECK(dc.ToShortest(-9.0, &builder));
905 CHECK_EQ("-9", builder.Finalize());
906
907 builder.Reset();
908 CHECK(dc.ToShortest(-90.0, &builder));
909 CHECK_EQ("-90", builder.Finalize());
910
911 builder.Reset();
912 CHECK(dc.ToShortest(-90.12, &builder));
913 CHECK_EQ("-90.12", builder.Finalize());
914
915 builder.Reset();
916 CHECK(dc.ToShortest(-0.1, &builder));
917 CHECK_EQ("-0.1", builder.Finalize());
918
919 builder.Reset();
920 CHECK(dc.ToShortest(-0.01, &builder));
921 CHECK_EQ("-0.01", builder.Finalize());
922
923 builder.Reset();
924 CHECK(dc.ToShortest(-0.0123, &builder));
925 CHECK_EQ("-0.0123", builder.Finalize());
926
927 builder.Reset();
928 CHECK(dc.ToShortest(-111111111111111111111.0, &builder));
929 CHECK_EQ("-111111111111111110000", builder.Finalize());
930
931 builder.Reset();
932 CHECK(dc.ToShortest(-1111111111111111111111.0, &builder));
933 CHECK_EQ("-1.1111111111111111e+21", builder.Finalize());
934
935 builder.Reset();
936 CHECK(dc.ToShortest(-11111111111111111111111.0, &builder));
937 CHECK_EQ("-1.1111111111111111e+22", builder.Finalize());
938
939 builder.Reset();
940 CHECK(dc.ToShortest(-0.00001, &builder));
941 CHECK_EQ("-0.00001", builder.Finalize());
942
943 builder.Reset();
944 CHECK(dc.ToShortest(-0.000001, &builder));
945 CHECK_EQ("-0.000001", builder.Finalize());
946
947 builder.Reset();
948 CHECK(dc.ToShortest(-0.0000001, &builder));
949 CHECK_EQ("-1e-7", builder.Finalize());
950
951 builder.Reset();
952 CHECK(dc.ToShortest(-0.00000012, &builder));
953 CHECK_EQ("-1.2e-7", builder.Finalize());
954
955 builder.Reset();
956 CHECK(dc.ToShortest(-0.000000123, &builder));
957 CHECK_EQ("-1.23e-7", builder.Finalize());
958
959 builder.Reset();
960 CHECK(dc.ToShortest(-0.00000001, &builder));
961 CHECK_EQ("-1e-8", builder.Finalize());
962
963 builder.Reset();
964 CHECK(dc.ToShortest(-0.000000012, &builder));
965 CHECK_EQ("-1.2e-8", builder.Finalize());
966
967 builder.Reset();
968 CHECK(dc.ToShortest(-0.000000012, &builder));
969 CHECK_EQ("-1.2e-8", builder.Finalize());
970
971 builder.Reset();
972 CHECK(dc.ToShortest(-0.0000000123, &builder));
973 CHECK_EQ("-1.23e-8", builder.Finalize());
974
975 builder.Reset();
976 CHECK(dc.ToFixed(Double::NaN(), 2, &builder));
977 CHECK_EQ("NaN", builder.Finalize());
978
979 builder.Reset();
980 CHECK(dc.ToFixed(Double::Infinity(), 2, &builder));
981 CHECK_EQ("Infinity", builder.Finalize());
982
983 builder.Reset();
984 CHECK(dc.ToFixed(-Double::Infinity(), 2, &builder));
985 CHECK_EQ("-Infinity", builder.Finalize());
986
987 builder.Reset();
988 CHECK(dc.ToFixed(-0.1, 1, &builder));
989 CHECK_EQ("-0.1", builder.Finalize());
990
991 builder.Reset();
992 CHECK(dc.ToFixed(-0.1, 2, &builder));
993 CHECK_EQ("-0.10", builder.Finalize());
994
995 builder.Reset();
996 CHECK(dc.ToFixed(-0.1, 3, &builder));
997 CHECK_EQ("-0.100", builder.Finalize());
998
999 builder.Reset();
1000 CHECK(dc.ToFixed(-0.01, 2, &builder));
1001 CHECK_EQ("-0.01", builder.Finalize());
1002
1003 builder.Reset();
1004 CHECK(dc.ToFixed(-0.01, 3, &builder));
1005 CHECK_EQ("-0.010", builder.Finalize());
1006
1007 builder.Reset();
1008 CHECK(dc.ToFixed(-0.01, 4, &builder));
1009 CHECK_EQ("-0.0100", builder.Finalize());
1010
1011 builder.Reset();
1012 CHECK(dc.ToFixed(-0.001, 2, &builder));
1013 CHECK_EQ("-0.00", builder.Finalize());
1014
1015 builder.Reset();
1016 CHECK(dc.ToFixed(-0.001, 3, &builder));
1017 CHECK_EQ("-0.001", builder.Finalize());
1018
1019 builder.Reset();
1020 CHECK(dc.ToFixed(-0.001, 4, &builder));
1021 CHECK_EQ("-0.0010", builder.Finalize());
1022
1023 builder.Reset();
1024 CHECK(dc.ToFixed(-1.0, 4, &builder));
1025 CHECK_EQ("-1.0000", builder.Finalize());
1026
1027 builder.Reset();
1028 CHECK(dc.ToFixed(-1.0, 1, &builder));
1029 CHECK_EQ("-1.0", builder.Finalize());
1030
1031 builder.Reset();
1032 CHECK(dc.ToFixed(-1.0, 0, &builder));
1033 CHECK_EQ("-1", builder.Finalize());
1034
1035 builder.Reset();
1036 CHECK(dc.ToFixed(-12.0, 0, &builder));
1037 CHECK_EQ("-12", builder.Finalize());
1038
1039 builder.Reset();
1040 CHECK(dc.ToFixed(-1.1, 0, &builder));
1041 CHECK_EQ("-1", builder.Finalize());
1042
1043 builder.Reset();
1044 CHECK(dc.ToFixed(-12.1, 0, &builder));
1045 CHECK_EQ("-12", builder.Finalize());
1046
1047 builder.Reset();
1048 CHECK(dc.ToFixed(-1.12, 0, &builder));
1049 CHECK_EQ("-1", builder.Finalize());
1050
1051 builder.Reset();
1052 CHECK(dc.ToFixed(-12.12, 0, &builder));
1053 CHECK_EQ("-12", builder.Finalize());
1054
1055 builder.Reset();
1056 CHECK(dc.ToFixed(-0.0000006, 7, &builder));
1057 CHECK_EQ("-0.0000006", builder.Finalize());
1058
1059 builder.Reset();
1060 CHECK(dc.ToFixed(-0.00000006, 8, &builder));
1061 CHECK_EQ("-0.00000006", builder.Finalize());
1062
1063 builder.Reset();
1064 CHECK(dc.ToFixed(-0.00000006, 9, &builder));
1065 CHECK_EQ("-0.000000060", builder.Finalize());
1066
1067 builder.Reset();
1068 CHECK(dc.ToFixed(-0.00000006, 10, &builder));
1069 CHECK_EQ("-0.0000000600", builder.Finalize());
1070
1071 builder.Reset();
1072 CHECK(dc.ToFixed(-0, 0, &builder));
1073 CHECK_EQ("0", builder.Finalize());
1074
1075 builder.Reset();
1076 CHECK(dc.ToFixed(-0, 1, &builder));
1077 CHECK_EQ("0.0", builder.Finalize());
1078
1079 builder.Reset();
1080 CHECK(dc.ToFixed(-0, 2, &builder));
1081 CHECK_EQ("0.00", builder.Finalize());
1082
1083 builder.Reset();
1084 CHECK(dc.ToFixed(1000, 0, &builder));
1085 CHECK_EQ("1000", builder.Finalize());
1086
1087 builder.Reset();
1088 CHECK(dc.ToFixed(0.00001, 0, &builder));
1089 CHECK_EQ("0", builder.Finalize());
1090
1091 builder.Reset();
1092 CHECK(dc.ToFixed(0.00001, 5, &builder));
1093 CHECK_EQ("0.00001", builder.Finalize());
1094
1095 builder.Reset();
1096 CHECK(dc.ToFixed(0.0000000000000000001, 20, &builder));
1097 CHECK_EQ("0.00000000000000000010", builder.Finalize());
1098
1099 builder.Reset();
1100 CHECK(dc.ToFixed(0.00001, 17, &builder));
1101 CHECK_EQ("0.00001000000000000", builder.Finalize());
1102
1103 builder.Reset();
1104 CHECK(dc.ToFixed(1000000000000000128.0, 0, &builder));
1105 CHECK_EQ("1000000000000000128", builder.Finalize());
1106
1107 builder.Reset();
1108 CHECK(dc.ToFixed(1000000000000000128.0, 1, &builder));
1109 CHECK_EQ("1000000000000000128.0", builder.Finalize());
1110
1111 builder.Reset();
1112 CHECK(dc.ToFixed(1000000000000000128.0, 2, &builder));
1113 CHECK_EQ("1000000000000000128.00", builder.Finalize());
1114
1115 builder.Reset();
1116 CHECK(dc.ToFixed(1000000000000000128.0, 20, &builder));
1117 CHECK_EQ("1000000000000000128.00000000000000000000", builder.Finalize());
1118
1119 builder.Reset();
1120 CHECK(dc.ToFixed(0.0, 0, &builder));
1121 CHECK_EQ("0", builder.Finalize());
1122
1123 builder.Reset();
1124 CHECK(dc.ToFixed(-42.0, 3, &builder));
1125 CHECK_EQ("-42.000", builder.Finalize());
1126
1127 builder.Reset();
1128 CHECK(dc.ToFixed(-1000000000000000128.0, 0, &builder));
1129 CHECK_EQ("-1000000000000000128", builder.Finalize());
1130
1131 builder.Reset();
1132 CHECK(dc.ToFixed(-0.0000000000000000001, 20, &builder));
1133 CHECK_EQ("-0.00000000000000000010", builder.Finalize());
1134
1135 builder.Reset();
1136 CHECK(dc.ToFixed(0.123123123123123, 20, &builder));
1137 CHECK_EQ("0.12312312312312299889", builder.Finalize());
1138
1139 builder.Reset();
1140 CHECK(dc.ToFixed(0.5, 0, &builder));
1141 CHECK_EQ("1", builder.Finalize());
1142
1143 builder.Reset();
1144 CHECK(dc.ToFixed(-0.5, 0, &builder));
1145 CHECK_EQ("-1", builder.Finalize());
1146
1147 builder.Reset();
1148 CHECK(dc.ToFixed(1.25, 1, &builder));
1149 CHECK_EQ("1.3", builder.Finalize());
1150
1151 builder.Reset();
1152 CHECK(dc.ToFixed(234.20405, 4, &builder));
1153 CHECK_EQ("234.2040", builder.Finalize());
1154
1155 builder.Reset();
1156 CHECK(dc.ToFixed(234.2040506, 4, &builder));
1157 CHECK_EQ("234.2041", builder.Finalize());
1158
1159 builder.Reset();
1160 CHECK(dc.ToExponential(1.0, -1, &builder));
1161 CHECK_EQ("1e+0", builder.Finalize());
1162
1163 builder.Reset();
1164 CHECK(dc.ToExponential(11.0, -1, &builder));
1165 CHECK_EQ("1.1e+1", builder.Finalize());
1166
1167 builder.Reset();
1168 CHECK(dc.ToExponential(112.0, -1, &builder));
1169 CHECK_EQ("1.12e+2", builder.Finalize());
1170
1171 builder.Reset();
1172 CHECK(dc.ToExponential(1.0, 0, &builder));
1173 CHECK_EQ("1e+0", builder.Finalize());
1174
1175 builder.Reset();
1176 CHECK(dc.ToExponential(11.0, 0, &builder));
1177 CHECK_EQ("1e+1", builder.Finalize());
1178
1179 builder.Reset();
1180 CHECK(dc.ToExponential(112.0, 0, &builder));
1181 CHECK_EQ("1e+2", builder.Finalize());
1182
1183 builder.Reset();
1184 CHECK(dc.ToExponential(1.0, 1, &builder));
1185 CHECK_EQ("1.0e+0", builder.Finalize());
1186
1187 builder.Reset();
1188 CHECK(dc.ToExponential(11.0, 1, &builder));
1189 CHECK_EQ("1.1e+1", builder.Finalize());
1190
1191 builder.Reset();
1192 CHECK(dc.ToExponential(112.0, 1, &builder));
1193 CHECK_EQ("1.1e+2", builder.Finalize());
1194
1195 builder.Reset();
1196 CHECK(dc.ToExponential(1.0, 2, &builder));
1197 CHECK_EQ("1.00e+0", builder.Finalize());
1198
1199 builder.Reset();
1200 CHECK(dc.ToExponential(11.0, 2, &builder));
1201 CHECK_EQ("1.10e+1", builder.Finalize());
1202
1203 builder.Reset();
1204 CHECK(dc.ToExponential(112.0, 2, &builder));
1205 CHECK_EQ("1.12e+2", builder.Finalize());
1206
1207 builder.Reset();
1208 CHECK(dc.ToExponential(1.0, 3, &builder));
1209 CHECK_EQ("1.000e+0", builder.Finalize());
1210
1211 builder.Reset();
1212 CHECK(dc.ToExponential(11.0, 3, &builder));
1213 CHECK_EQ("1.100e+1", builder.Finalize());
1214
1215 builder.Reset();
1216 CHECK(dc.ToExponential(112.0, 3, &builder));
1217 CHECK_EQ("1.120e+2", builder.Finalize());
1218
1219 builder.Reset();
1220 CHECK(dc.ToExponential(0.1, -1, &builder));
1221 CHECK_EQ("1e-1", builder.Finalize());
1222
1223 builder.Reset();
1224 CHECK(dc.ToExponential(0.11, -1, &builder));
1225 CHECK_EQ("1.1e-1", builder.Finalize());
1226
1227 builder.Reset();
1228 CHECK(dc.ToExponential(0.112, -1, &builder));
1229 CHECK_EQ("1.12e-1", builder.Finalize());
1230
1231 builder.Reset();
1232 CHECK(dc.ToExponential(0.1, 0, &builder));
1233 CHECK_EQ("1e-1", builder.Finalize());
1234
1235 builder.Reset();
1236 CHECK(dc.ToExponential(0.11, 0, &builder));
1237 CHECK_EQ("1e-1", builder.Finalize());
1238
1239 builder.Reset();
1240 CHECK(dc.ToExponential(0.112, 0, &builder));
1241 CHECK_EQ("1e-1", builder.Finalize());
1242
1243 builder.Reset();
1244 CHECK(dc.ToExponential(0.1, 1, &builder));
1245 CHECK_EQ("1.0e-1", builder.Finalize());
1246
1247 builder.Reset();
1248 CHECK(dc.ToExponential(0.11, 1, &builder));
1249 CHECK_EQ("1.1e-1", builder.Finalize());
1250
1251 builder.Reset();
1252 CHECK(dc.ToExponential(0.112, 1, &builder));
1253 CHECK_EQ("1.1e-1", builder.Finalize());
1254
1255 builder.Reset();
1256 CHECK(dc.ToExponential(0.1, 2, &builder));
1257 CHECK_EQ("1.00e-1", builder.Finalize());
1258
1259 builder.Reset();
1260 CHECK(dc.ToExponential(0.11, 2, &builder));
1261 CHECK_EQ("1.10e-1", builder.Finalize());
1262
1263 builder.Reset();
1264 CHECK(dc.ToExponential(0.112, 2, &builder));
1265 CHECK_EQ("1.12e-1", builder.Finalize());
1266
1267 builder.Reset();
1268 CHECK(dc.ToExponential(0.1, 3, &builder));
1269 CHECK_EQ("1.000e-1", builder.Finalize());
1270
1271 builder.Reset();
1272 CHECK(dc.ToExponential(0.11, 3, &builder));
1273 CHECK_EQ("1.100e-1", builder.Finalize());
1274
1275 builder.Reset();
1276 CHECK(dc.ToExponential(0.112, 3, &builder));
1277 CHECK_EQ("1.120e-1", builder.Finalize());
1278
1279 builder.Reset();
1280 CHECK(dc.ToExponential(-1.0, -1, &builder));
1281 CHECK_EQ("-1e+0", builder.Finalize());
1282
1283 builder.Reset();
1284 CHECK(dc.ToExponential(-11.0, -1, &builder));
1285 CHECK_EQ("-1.1e+1", builder.Finalize());
1286
1287 builder.Reset();
1288 CHECK(dc.ToExponential(-112.0, -1, &builder));
1289 CHECK_EQ("-1.12e+2", builder.Finalize());
1290
1291 builder.Reset();
1292 CHECK(dc.ToExponential(-1.0, 0, &builder));
1293 CHECK_EQ("-1e+0", builder.Finalize());
1294
1295 builder.Reset();
1296 CHECK(dc.ToExponential(-11.0, 0, &builder));
1297 CHECK_EQ("-1e+1", builder.Finalize());
1298
1299 builder.Reset();
1300 CHECK(dc.ToExponential(-112.0, 0, &builder));
1301 CHECK_EQ("-1e+2", builder.Finalize());
1302
1303 builder.Reset();
1304 CHECK(dc.ToExponential(-1.0, 1, &builder));
1305 CHECK_EQ("-1.0e+0", builder.Finalize());
1306
1307 builder.Reset();
1308 CHECK(dc.ToExponential(-11.0, 1, &builder));
1309 CHECK_EQ("-1.1e+1", builder.Finalize());
1310
1311 builder.Reset();
1312 CHECK(dc.ToExponential(-112.0, 1, &builder));
1313 CHECK_EQ("-1.1e+2", builder.Finalize());
1314
1315 builder.Reset();
1316 CHECK(dc.ToExponential(-1.0, 2, &builder));
1317 CHECK_EQ("-1.00e+0", builder.Finalize());
1318
1319 builder.Reset();
1320 CHECK(dc.ToExponential(-11.0, 2, &builder));
1321 CHECK_EQ("-1.10e+1", builder.Finalize());
1322
1323 builder.Reset();
1324 CHECK(dc.ToExponential(-112.0, 2, &builder));
1325 CHECK_EQ("-1.12e+2", builder.Finalize());
1326
1327 builder.Reset();
1328 CHECK(dc.ToExponential(-1.0, 3, &builder));
1329 CHECK_EQ("-1.000e+0", builder.Finalize());
1330
1331 builder.Reset();
1332 CHECK(dc.ToExponential(-11.0, 3, &builder));
1333 CHECK_EQ("-1.100e+1", builder.Finalize());
1334
1335 builder.Reset();
1336 CHECK(dc.ToExponential(-112.0, 3, &builder));
1337 CHECK_EQ("-1.120e+2", builder.Finalize());
1338
1339 builder.Reset();
1340 CHECK(dc.ToExponential(-0.1, -1, &builder));
1341 CHECK_EQ("-1e-1", builder.Finalize());
1342
1343 builder.Reset();
1344 CHECK(dc.ToExponential(-0.11, -1, &builder));
1345 CHECK_EQ("-1.1e-1", builder.Finalize());
1346
1347 builder.Reset();
1348 CHECK(dc.ToExponential(-0.112, -1, &builder));
1349 CHECK_EQ("-1.12e-1", builder.Finalize());
1350
1351 builder.Reset();
1352 CHECK(dc.ToExponential(-0.1, 0, &builder));
1353 CHECK_EQ("-1e-1", builder.Finalize());
1354
1355 builder.Reset();
1356 CHECK(dc.ToExponential(-0.11, 0, &builder));
1357 CHECK_EQ("-1e-1", builder.Finalize());
1358
1359 builder.Reset();
1360 CHECK(dc.ToExponential(-0.112, 0, &builder));
1361 CHECK_EQ("-1e-1", builder.Finalize());
1362
1363 builder.Reset();
1364 CHECK(dc.ToExponential(-0.1, 1, &builder));
1365 CHECK_EQ("-1.0e-1", builder.Finalize());
1366
1367 builder.Reset();
1368 CHECK(dc.ToExponential(-0.11, 1, &builder));
1369 CHECK_EQ("-1.1e-1", builder.Finalize());
1370
1371 builder.Reset();
1372 CHECK(dc.ToExponential(-0.112, 1, &builder));
1373 CHECK_EQ("-1.1e-1", builder.Finalize());
1374
1375 builder.Reset();
1376 CHECK(dc.ToExponential(-0.1, 2, &builder));
1377 CHECK_EQ("-1.00e-1", builder.Finalize());
1378
1379 builder.Reset();
1380 CHECK(dc.ToExponential(-0.11, 2, &builder));
1381 CHECK_EQ("-1.10e-1", builder.Finalize());
1382
1383 builder.Reset();
1384 CHECK(dc.ToExponential(-0.112, 2, &builder));
1385 CHECK_EQ("-1.12e-1", builder.Finalize());
1386
1387 builder.Reset();
1388 CHECK(dc.ToExponential(-0.1, 3, &builder));
1389 CHECK_EQ("-1.000e-1", builder.Finalize());
1390
1391 builder.Reset();
1392 CHECK(dc.ToExponential(-0.11, 3, &builder));
1393 CHECK_EQ("-1.100e-1", builder.Finalize());
1394
1395 builder.Reset();
1396 CHECK(dc.ToExponential(-0.112, 3, &builder));
1397 CHECK_EQ("-1.120e-1", builder.Finalize());
1398
1399 builder.Reset();
1400 CHECK(dc.ToExponential(Double::NaN(), 2, &builder));
1401 CHECK_EQ("NaN", builder.Finalize());
1402
1403 builder.Reset();
1404 CHECK(dc.ToExponential(Double::Infinity(), 2, &builder));
1405 CHECK_EQ("Infinity", builder.Finalize());
1406
1407 builder.Reset();
1408 CHECK(dc.ToExponential(-Double::Infinity(), 2, &builder));
1409 CHECK_EQ("-Infinity", builder.Finalize());
1410
1411 builder.Reset();
1412 CHECK(dc.ToExponential(1.0, 0, &builder));
1413 CHECK_EQ("1e+0", builder.Finalize());
1414
1415 builder.Reset();
1416 CHECK(dc.ToExponential(0.0, -1, &builder));
1417 CHECK_EQ("0e+0", builder.Finalize());
1418
1419 builder.Reset();
1420 CHECK(dc.ToExponential(0.0, 2, &builder));
1421 CHECK_EQ("0.00e+0", builder.Finalize());
1422
1423 builder.Reset();
1424 CHECK(dc.ToExponential(11.2356, 0, &builder));
1425 CHECK_EQ("1e+1", builder.Finalize());
1426
1427 builder.Reset();
1428 CHECK(dc.ToExponential(11.2356, 4, &builder));
1429 CHECK_EQ("1.1236e+1", builder.Finalize());
1430
1431 builder.Reset();
1432 CHECK(dc.ToExponential(0.000112356, 4, &builder));
1433 CHECK_EQ("1.1236e-4", builder.Finalize());
1434
1435 builder.Reset();
1436 CHECK(dc.ToExponential(-0.000112356, 4, &builder));
1437 CHECK_EQ("-1.1236e-4", builder.Finalize());
1438
1439 builder.Reset();
1440 CHECK(dc.ToExponential(0.000112356, -1, &builder));
1441 CHECK_EQ("1.12356e-4", builder.Finalize());
1442
1443 builder.Reset();
1444 CHECK(dc.ToExponential(-0.000112356, -1, &builder));
1445 CHECK_EQ("-1.12356e-4", builder.Finalize());
1446
1447 builder.Reset();
1448 CHECK(dc.ToPrecision(Double::NaN(), 1, &builder));
1449 CHECK_EQ("NaN", builder.Finalize());
1450
1451 builder.Reset();
1452 CHECK(dc.ToPrecision(Double::Infinity(), 2, &builder));
1453 CHECK_EQ("Infinity", builder.Finalize());
1454
1455 builder.Reset();
1456 CHECK(dc.ToPrecision(-Double::Infinity(), 2, &builder));
1457 CHECK_EQ("-Infinity", builder.Finalize());
1458
1459 builder.Reset();
1460 CHECK(dc.ToPrecision(0.000555, 15, &builder));
1461 CHECK_EQ("0.000555000000000000", builder.Finalize());
1462
1463 builder.Reset();
1464 CHECK(dc.ToPrecision(0.000000555, 15, &builder));
1465 CHECK_EQ("5.55000000000000e-7", builder.Finalize());
1466
1467 builder.Reset();
1468 CHECK(dc.ToPrecision(-0.000000555, 15, &builder));
1469 CHECK_EQ("-5.55000000000000e-7", builder.Finalize());
1470
1471 builder.Reset();
1472 CHECK(dc.ToPrecision(123456789.0, 1, &builder));
1473 CHECK_EQ("1e+8", builder.Finalize());
1474
1475 builder.Reset();
1476 CHECK(dc.ToPrecision(123456789.0, 9, &builder));
1477 CHECK_EQ("123456789", builder.Finalize());
1478
1479 builder.Reset();
1480 CHECK(dc.ToPrecision(123456789.0, 8, &builder));
1481 CHECK_EQ("1.2345679e+8", builder.Finalize());
1482
1483 builder.Reset();
1484 CHECK(dc.ToPrecision(123456789.0, 7, &builder));
1485 CHECK_EQ("1.234568e+8", builder.Finalize());
1486
1487 builder.Reset();
1488 CHECK(dc.ToPrecision(-123456789.0, 7, &builder));
1489 CHECK_EQ("-1.234568e+8", builder.Finalize());
1490
1491 builder.Reset();
1492 CHECK(dc.ToPrecision(-.0000000012345, 2, &builder));
1493 CHECK_EQ("-1.2e-9", builder.Finalize());
1494
1495 builder.Reset();
1496 CHECK(dc.ToPrecision(-.000000012345, 2, &builder));
1497 CHECK_EQ("-1.2e-8", builder.Finalize());
1498
1499 builder.Reset();
1500 CHECK(dc.ToPrecision(-.00000012345, 2, &builder));
1501 CHECK_EQ("-1.2e-7", builder.Finalize());
1502
1503 builder.Reset();
1504 CHECK(dc.ToPrecision(-.0000012345, 2, &builder));
1505 CHECK_EQ("-0.0000012", builder.Finalize());
1506
1507 builder.Reset();
1508 CHECK(dc.ToPrecision(-.000012345, 2, &builder));
1509 CHECK_EQ("-0.000012", builder.Finalize());
1510
1511 builder.Reset();
1512 CHECK(dc.ToPrecision(-.00012345, 2, &builder));
1513 CHECK_EQ("-0.00012", builder.Finalize());
1514
1515 builder.Reset();
1516 CHECK(dc.ToPrecision(-.0012345, 2, &builder));
1517 CHECK_EQ("-0.0012", builder.Finalize());
1518
1519 builder.Reset();
1520 CHECK(dc.ToPrecision(-.012345, 2, &builder));
1521 CHECK_EQ("-0.012", builder.Finalize());
1522
1523 builder.Reset();
1524 CHECK(dc.ToPrecision(-.12345, 2, &builder));
1525 CHECK_EQ("-0.12", builder.Finalize());
1526
1527 builder.Reset();
1528 CHECK(dc.ToPrecision(-1.2345, 2, &builder));
1529 CHECK_EQ("-1.2", builder.Finalize());
1530
1531 builder.Reset();
1532 CHECK(dc.ToPrecision(-12.345, 2, &builder));
1533 CHECK_EQ("-12", builder.Finalize());
1534
1535 builder.Reset();
1536 CHECK(dc.ToPrecision(-123.45, 2, &builder));
1537 CHECK_EQ("-1.2e+2", builder.Finalize());
1538
1539 builder.Reset();
1540 CHECK(dc.ToPrecision(-1234.5, 2, &builder));
1541 CHECK_EQ("-1.2e+3", builder.Finalize());
1542
1543 builder.Reset();
1544 CHECK(dc.ToPrecision(-12345.0, 2, &builder));
1545 CHECK_EQ("-1.2e+4", builder.Finalize());
1546
1547 builder.Reset();
1548 CHECK(dc.ToPrecision(-12345.67, 4, &builder));
1549 CHECK_EQ("-1.235e+4", builder.Finalize());
1550
1551 builder.Reset();
1552 CHECK(dc.ToPrecision(-12344.67, 4, &builder));
1553 CHECK_EQ("-1.234e+4", builder.Finalize());
1554
1555 builder.Reset();
1556 CHECK(dc.ToPrecision(1.25, 2, &builder));
1557 CHECK_EQ("1.3", builder.Finalize());
1558
1559 builder.Reset();
1560 CHECK(dc.ToPrecision(1.35, 2, &builder));
1561 CHECK_EQ("1.4", builder.Finalize());
1562 }
1563
1564
1565 static double StrToD(const char* str, int flags, double empty_string_value,
1566 int* processed_characters_count, bool* processed_all) {
1567 StringToDoubleConverter converter(flags, empty_string_value, Double::NaN(),
1568 NULL, NULL);
1569 double result = converter.StringToDouble(str, strlen(str),
1570 processed_characters_count);
1571 *processed_all = ((strlen(str) == *processed_characters_count));
1572 return result;
1573 }
1574
1575
1576 TEST(StringToDoubleVarious) {
1577 int flags;
1578 int processed;
1579 bool all_used;
1580
1581 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
1582 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN |
1583 StringToDoubleConverter::ALLOW_TRAILING_SPACES;
1584
1585 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
1586 CHECK(all_used);
1587
1588 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
1589 CHECK(all_used);
1590
1591 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
1592 CHECK(all_used);
1593
1594 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
1595 CHECK(all_used);
1596
1597 CHECK_EQ(42.0, StrToD("42", flags, 0.0, &processed, &all_used));
1598 CHECK(all_used);
1599
1600 CHECK_EQ(42.0, StrToD(" + 42 ", flags, 0.0, &processed, &all_used));
1601 CHECK(all_used);
1602
1603 CHECK_EQ(-42.0, StrToD(" - 42 ", flags, 0.0, &processed, &all_used));
1604 CHECK(all_used);
1605
1606 CHECK_EQ(Double::NaN(), StrToD("x", flags, 1.0, &processed, &all_used));
1607 CHECK_EQ(0, processed);
1608
1609 CHECK_EQ(Double::NaN(), StrToD(" x", flags, 1.0, &processed, &all_used));
1610 CHECK_EQ(0, processed);
1611
1612 CHECK_EQ(Double::NaN(), StrToD("42x", flags, 0.0, &processed, &all_used));
1613 CHECK_EQ(0, processed);
1614
1615 CHECK_EQ(Double::NaN(), StrToD("42 x", flags, 0.0, &processed, &all_used));
1616 CHECK_EQ(0, processed);
1617
1618 CHECK_EQ(Double::NaN(), StrToD(" + 42 x", flags, 0.0, &processed, &all_used));
1619 CHECK_EQ(0, processed);
1620
1621 CHECK_EQ(Double::NaN(), StrToD(" - 42 x", flags, 0.0, &processed, &all_used));
1622 CHECK_EQ(0, processed);
1623
1624
1625 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
1626 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN |
1627 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
1628 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
1629
1630 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
1631 CHECK(all_used);
1632
1633 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
1634 CHECK(all_used);
1635
1636 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
1637 CHECK(all_used);
1638
1639 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
1640 CHECK(all_used);
1641
1642 CHECK_EQ(42.0, StrToD("42", flags, 0.0, &processed, &all_used));
1643 CHECK(all_used);
1644
1645 CHECK_EQ(42.0, StrToD(" + 42 ", flags, 0.0, &processed, &all_used));
1646 CHECK(all_used);
1647
1648 CHECK_EQ(-42.0, StrToD(" - 42 ", flags, 0.0, &processed, &all_used));
1649 CHECK(all_used);
1650
1651 CHECK_EQ(Double::NaN(), StrToD("x", flags, 1.0, &processed, &all_used));
1652 CHECK_EQ(0, processed);
1653
1654 CHECK_EQ(Double::NaN(), StrToD(" x", flags, 1.0, &processed, &all_used));
1655 CHECK_EQ(0, processed);
1656
1657 CHECK_EQ(42.0, StrToD("42x", flags, 0.0, &processed, &all_used));
1658 CHECK_EQ(2, processed);
1659
1660 CHECK_EQ(42.0, StrToD("42 x", flags, 0.0, &processed, &all_used));
1661 CHECK_EQ(3, processed);
1662
1663 CHECK_EQ(42.0, StrToD(" + 42 x", flags, 0.0, &processed, &all_used));
1664 CHECK_EQ(6, processed);
1665
1666 CHECK_EQ(-42.0, StrToD(" - 42 x", flags, 0.0, &processed, &all_used));
1667 CHECK_EQ(6, processed);
1668
1669
1670 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
1671 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN |
1672 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
1673
1674 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
1675 CHECK(all_used);
1676
1677 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
1678 CHECK(all_used);
1679
1680 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
1681 CHECK(all_used);
1682
1683 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
1684 CHECK(all_used);
1685
1686 CHECK_EQ(42.0, StrToD("42", flags, 0.0, &processed, &all_used));
1687 CHECK(all_used);
1688
1689 CHECK_EQ(42.0, StrToD(" + 42 ", flags, 0.0, &processed, &all_used));
1690 CHECK_EQ(5, processed);
1691
1692 CHECK_EQ(-42.0, StrToD(" - 42 ", flags, 0.0, &processed, &all_used));
1693 CHECK_EQ(5, processed);
1694
1695 CHECK_EQ(Double::NaN(), StrToD("x", flags, 1.0, &processed, &all_used));
1696 CHECK_EQ(0, processed);
1697
1698 CHECK_EQ(Double::NaN(), StrToD(" x", flags, 1.0, &processed, &all_used));
1699 CHECK_EQ(0, processed);
1700
1701 CHECK_EQ(42.0, StrToD("42x", flags, 0.0, &processed, &all_used));
1702 CHECK_EQ(2, processed);
1703
1704 CHECK_EQ(42.0, StrToD("42 x", flags, 0.0, &processed, &all_used));
1705 CHECK_EQ(2, processed);
1706
1707 CHECK_EQ(42.0, StrToD(" + 42 x", flags, 0.0, &processed, &all_used));
1708 CHECK_EQ(5, processed);
1709
1710 CHECK_EQ(-42.0, StrToD(" - 42 x", flags, 0.0, &processed, &all_used));
1711 CHECK_EQ(5, processed);
1712
1713 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
1714 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
1715
1716 CHECK_EQ(42.0, StrToD(" +42 ", flags, 0.0, &processed, &all_used));
1717 CHECK_EQ(4, processed);
1718
1719 CHECK_EQ(-42.0, StrToD(" -42 ", flags, 0.0, &processed, &all_used));
1720 CHECK_EQ(4, processed);
1721
1722 CHECK_EQ(Double::NaN(), StrToD(" + 42 ", flags, 0.0, &processed, &all_used));
1723 CHECK_EQ(0, processed);
1724
1725 CHECK_EQ(Double::NaN(), StrToD(" - 42 ", flags, 0.0, &processed, &all_used));
1726 CHECK_EQ(0, processed);
1727
1728
1729 flags = StringToDoubleConverter::NO_FLAGS;
1730
1731 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
1732 CHECK(all_used);
1733
1734 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
1735 CHECK(all_used);
1736
1737 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 0.0, &processed, &all_used));
1738 CHECK_EQ(0, processed);
1739
1740 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 1.0, &processed, &all_used));
1741 CHECK_EQ(0, processed);
1742
1743 CHECK_EQ(42.0, StrToD("42", flags, 0.0, &processed, &all_used));
1744 CHECK(all_used);
1745
1746 CHECK_EQ(Double::NaN(), StrToD(" + 42 ", flags, 0.0, &processed, &all_used));
1747 CHECK_EQ(0, processed);
1748
1749 CHECK_EQ(Double::NaN(), StrToD(" - 42 ", flags, 0.0, &processed, &all_used));
1750 CHECK_EQ(0, processed);
1751
1752 CHECK_EQ(Double::NaN(), StrToD("x", flags, 1.0, &processed, &all_used));
1753 CHECK_EQ(0, processed);
1754
1755 CHECK_EQ(Double::NaN(), StrToD(" x", flags, 1.0, &processed, &all_used));
1756 CHECK_EQ(0, processed);
1757
1758 CHECK_EQ(Double::NaN(), StrToD("42x", flags, 0.0, &processed, &all_used));
1759 CHECK_EQ(0, processed);
1760
1761 CHECK_EQ(Double::NaN(), StrToD("42 x", flags, 0.0, &processed, &all_used));
1762 CHECK_EQ(0, processed);
1763
1764 CHECK_EQ(Double::NaN(), StrToD(" + 42 x", flags, 0.0, &processed, &all_used));
1765 CHECK_EQ(0, processed);
1766
1767 CHECK_EQ(Double::NaN(), StrToD(" - 42 x", flags, 0.0, &processed, &all_used));
1768 CHECK_EQ(0, processed);
1769
1770
1771 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES;
1772
1773 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
1774 CHECK(all_used);
1775
1776 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
1777 CHECK(all_used);
1778
1779 CHECK_EQ(42.0, StrToD(" 42", flags, 0.0, &processed, &all_used));
1780 CHECK(all_used);
1781
1782 CHECK_EQ(Double::NaN(), StrToD("42 ", flags, 0.0, &processed, &all_used));
1783 CHECK_EQ(0, processed);
1784
1785
1786 flags = StringToDoubleConverter::ALLOW_TRAILING_SPACES;
1787
1788 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
1789 CHECK(all_used);
1790
1791 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
1792 CHECK(all_used);
1793
1794 CHECK_EQ(42.0, StrToD("42 ", flags, 0.0, &processed, &all_used));
1795 CHECK(all_used);
1796
1797 CHECK_EQ(Double::NaN(), StrToD(" 42", flags, 0.0, &processed, &all_used));
1798 CHECK_EQ(0, processed);
1799 }
1800
1801
1802 TEST(StringToDoubleEmptyString) {
1803 int flags;
1804 int processed;
1805 bool all_used;
1806
1807 flags = StringToDoubleConverter::NO_FLAGS;
1808 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
1809 CHECK(all_used);
1810
1811 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
1812 CHECK(all_used);
1813
1814 CHECK_EQ(Double::NaN(), StrToD("", flags, Double::NaN(),
1815 &processed, &all_used));
1816 CHECK(all_used);
1817
1818 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 0.0, &processed, &all_used));
1819 CHECK_EQ(0, processed);
1820
1821 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 1.0, &processed, &all_used));
1822 CHECK_EQ(0, processed);
1823
1824 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
1825 &processed, &all_used));
1826 CHECK_EQ(0, processed);
1827
1828 flags = StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
1829 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
1830 CHECK(all_used);
1831
1832 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
1833 CHECK(all_used);
1834
1835 CHECK_EQ(Double::NaN(), StrToD("", flags, Double::NaN(),
1836 &processed, &all_used));
1837 CHECK(all_used);
1838
1839 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 0.0, &processed, &all_used));
1840 CHECK_EQ(0, processed);
1841
1842 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 1.0, &processed, &all_used));
1843 CHECK_EQ(0, processed);
1844
1845 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
1846 &processed, &all_used));
1847 CHECK_EQ(0, processed);
1848
1849 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES;
1850 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
1851 CHECK(all_used);
1852
1853 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
1854 CHECK(all_used);
1855
1856 CHECK_EQ(Double::NaN(), StrToD("", flags, Double::NaN(),
1857 &processed, &all_used));
1858 CHECK(all_used);
1859
1860 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
1861 CHECK(all_used);
1862
1863 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
1864 CHECK(all_used);
1865
1866 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
1867 &processed, &all_used));
1868 CHECK(all_used);
1869
1870 flags = StringToDoubleConverter::ALLOW_TRAILING_SPACES;
1871 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
1872 CHECK(all_used);
1873
1874 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
1875 CHECK(all_used);
1876
1877 CHECK_EQ(Double::NaN(), StrToD("", flags, Double::NaN(),
1878 &processed, &all_used));
1879 CHECK(all_used);
1880
1881 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
1882 CHECK(all_used);
1883
1884 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
1885 CHECK(all_used);
1886
1887 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
1888 &processed, &all_used));
1889 CHECK(all_used);
1890
1891 flags = StringToDoubleConverter::ALLOW_TRAILING_JUNK;
1892 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
1893 CHECK(all_used);
1894
1895 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
1896 CHECK(all_used);
1897
1898 CHECK_EQ(Double::NaN(), StrToD("", flags, Double::NaN(),
1899 &processed, &all_used));
1900 CHECK(all_used);
1901
1902 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 0.0, &processed, &all_used));
1903 CHECK_EQ(0, processed);
1904
1905 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 1.0, &processed, &all_used));
1906 CHECK_EQ(0, processed);
1907
1908 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
1909 &processed, &all_used));
1910 CHECK_EQ(0, processed);
1911
1912 CHECK_EQ(Double::NaN(), StrToD("x", flags, 0.0, &processed, &all_used));
1913 CHECK_EQ(0, processed);
1914
1915 CHECK_EQ(Double::NaN(), StrToD(" x", flags, 0.0, &processed, &all_used));
1916 CHECK_EQ(0, processed);
1917 }
1918
1919
1920 TEST(StringToDoubleHexString) {
1921 int flags;
1922 int processed;
1923 bool all_used;
1924
1925 flags = StringToDoubleConverter::ALLOW_HEX |
1926 StringToDoubleConverter::ALLOW_LEADING_SPACES |
1927 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
1928 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
1929
1930 CHECK_EQ(18.0, StrToD("0x12", flags, 0.0, &processed, &all_used));
1931 CHECK(all_used);
1932
1933 CHECK_EQ(0.0, StrToD("0x0", flags, 1.0, &processed, &all_used));
1934 CHECK(all_used);
1935
1936 CHECK_EQ(static_cast<double>(0x123456789),
1937 StrToD("0x123456789", flags, Double::NaN(), &processed, &all_used));
1938 CHECK(all_used);
1939
1940 CHECK_EQ(18.0, StrToD(" 0x12 ", flags, 0.0, &processed, &all_used));
1941 CHECK(all_used);
1942
1943 CHECK_EQ(0.0, StrToD(" 0x0 ", flags, 1.0, &processed, &all_used));
1944 CHECK(all_used);
1945
1946 CHECK_EQ(static_cast<double>(0x123456789),
1947 StrToD(" 0x123456789 ", flags, Double::NaN(),
1948 &processed, &all_used));
1949 CHECK(all_used);
1950
1951 CHECK_EQ(static_cast<double>(0xabcdef),
1952 StrToD("0xabcdef", flags, 0.0, &processed, &all_used));
1953 CHECK(all_used);
1954
1955 CHECK_EQ(static_cast<double>(0xabcdef),
1956 StrToD("0xABCDEF", flags, 0.0, &processed, &all_used));
1957 CHECK(all_used);
1958
1959 CHECK_EQ(static_cast<double>(0xabcdef),
1960 StrToD(" 0xabcdef ", flags, 0.0, &processed, &all_used));
1961 CHECK(all_used);
1962
1963 CHECK_EQ(static_cast<double>(0xabcdef),
1964 StrToD(" 0xABCDEF ", flags, 0.0, &processed, &all_used));
1965 CHECK(all_used);
1966
1967 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
1968 &processed, &all_used));
1969 CHECK(all_used);
1970
1971 CHECK_EQ(Double::NaN(), StrToD("0x", flags, 0.0,
1972 &processed, &all_used));
1973 CHECK_EQ(0, processed);
1974
1975 CHECK_EQ(Double::NaN(), StrToD(" 0x ", flags, 0.0,
1976 &processed, &all_used));
1977 CHECK_EQ(0, processed);
1978
1979 CHECK_EQ(Double::NaN(), StrToD(" 0x 3", flags, 0.0,
1980 &processed, &all_used));
1981 CHECK_EQ(0, processed);
1982
1983 CHECK_EQ(Double::NaN(), StrToD("0x3g", flags, 0.0,
1984 &processed, &all_used));
1985 CHECK_EQ(0, processed);
1986
1987 CHECK_EQ(Double::NaN(), StrToD("0x3.23", flags, 0.0,
1988 &processed, &all_used));
1989 CHECK_EQ(0, processed);
1990
1991 CHECK_EQ(Double::NaN(), StrToD("x3", flags, 0.0,
1992 &processed, &all_used));
1993 CHECK_EQ(0, processed);
1994
1995 CHECK_EQ(Double::NaN(), StrToD("0x3 foo", flags, 0.0,
1996 &processed, &all_used));
1997 CHECK_EQ(0, processed);
1998
1999 CHECK_EQ(Double::NaN(), StrToD(" 0x3 foo", flags, 0.0,
2000 &processed, &all_used));
2001 CHECK_EQ(0, processed);
2002
2003 CHECK_EQ(Double::NaN(), StrToD("+ 0x3 foo", flags, 0.0,
2004 &processed, &all_used));
2005 CHECK_EQ(0, processed);
2006
2007 CHECK_EQ(Double::NaN(), StrToD("+", flags, 0.0, &processed, &all_used));
2008 CHECK_EQ(0, processed);
2009
2010 CHECK_EQ(Double::NaN(), StrToD("-", flags, 0.0, &processed, &all_used));
2011 CHECK_EQ(0, processed);
2012
2013 CHECK_EQ(-5.0, StrToD("-0x5", flags, 0.0, &processed, &all_used));
2014 CHECK(all_used);
2015
2016 CHECK_EQ(-5.0, StrToD(" - 0x5 ", flags, 0.0, &processed, &all_used));
2017 CHECK(all_used);
2018
2019 CHECK_EQ(5.0, StrToD(" + 0x5 ", flags, 0.0, &processed, &all_used));
2020 CHECK(all_used);
2021
2022 CHECK_EQ(Double::NaN(), StrToD("- -0x5", flags, 0.0, &processed, &all_used));
2023 CHECK_EQ(0, processed);
2024
2025 CHECK_EQ(Double::NaN(), StrToD("- +0x5", flags, 0.0, &processed, &all_used));
2026 CHECK_EQ(0, processed);
2027
2028 CHECK_EQ(Double::NaN(), StrToD("+ +0x5", flags, 0.0, &processed, &all_used));
2029 CHECK_EQ(0, processed);
2030
2031 flags = StringToDoubleConverter::ALLOW_HEX;
2032
2033 CHECK_EQ(18.0, StrToD("0x12", flags, 0.0, &processed, &all_used));
2034 CHECK(all_used);
2035
2036 CHECK_EQ(0.0, StrToD("0x0", flags, 1.0, &processed, &all_used));
2037 CHECK(all_used);
2038
2039 CHECK_EQ(static_cast<double>(0x123456789),
2040 StrToD("0x123456789", flags, Double::NaN(), &processed, &all_used));
2041 CHECK(all_used);
2042
2043 CHECK_EQ(Double::NaN(), StrToD(" 0x12 ", flags, 0.0, &processed, &all_used));
2044 CHECK_EQ(0, processed);
2045
2046 CHECK_EQ(Double::NaN(), StrToD(" 0x0 ", flags, 1.0, &processed, &all_used));
2047 CHECK_EQ(0, processed);
2048
2049 CHECK_EQ(Double::NaN(), StrToD(" 0x123456789 ", flags, Double::NaN(),
2050 &processed, &all_used));
2051 CHECK_EQ(0, processed);
2052
2053 CHECK_EQ(static_cast<double>(0xabcdef),
2054 StrToD("0xabcdef", flags, 0.0, &processed, &all_used));
2055 CHECK(all_used);
2056
2057 CHECK_EQ(static_cast<double>(0xabcdef),
2058 StrToD("0xABCDEF", flags, 0.0, &processed, &all_used));
2059 CHECK(all_used);
2060
2061 CHECK_EQ(Double::NaN(),
2062 StrToD(" 0xabcdef ", flags, 0.0, &processed, &all_used));
2063 CHECK_EQ(0, processed);
2064
2065 CHECK_EQ(Double::NaN(),
2066 StrToD(" 0xABCDEF ", flags, 0.0, &processed, &all_used));
2067 CHECK_EQ(0, processed);
2068
2069 CHECK_EQ(Double::NaN(),
2070 StrToD(" ", flags, 0.0, &processed, &all_used));
2071 CHECK_EQ(0, processed);
2072
2073 CHECK_EQ(Double::NaN(), StrToD("0x", flags, 0.0,
2074 &processed, &all_used));
2075 CHECK_EQ(0, processed);
2076
2077 CHECK_EQ(Double::NaN(), StrToD(" 0x ", flags, 0.0,
2078 &processed, &all_used));
2079 CHECK_EQ(0, processed);
2080
2081 CHECK_EQ(Double::NaN(), StrToD(" 0x 3", flags, 0.0,
2082 &processed, &all_used));
2083 CHECK_EQ(0, processed);
2084
2085 CHECK_EQ(Double::NaN(), StrToD("0x3g", flags, 0.0,
2086 &processed, &all_used));
2087 CHECK_EQ(0, processed);
2088
2089 CHECK_EQ(Double::NaN(), StrToD("0x3.23", flags, 0.0,
2090 &processed, &all_used));
2091 CHECK_EQ(0, processed);
2092
2093 CHECK_EQ(Double::NaN(), StrToD("x3", flags, 0.0,
2094 &processed, &all_used));
2095 CHECK_EQ(0, processed);
2096
2097 CHECK_EQ(Double::NaN(), StrToD("+ 0x3 foo", flags, 0.0,
2098 &processed, &all_used));
2099 CHECK_EQ(0, processed);
2100
2101 CHECK_EQ(Double::NaN(), StrToD("+", flags, 0.0, &processed, &all_used));
2102 CHECK_EQ(0, processed);
2103
2104 CHECK_EQ(Double::NaN(), StrToD("-", flags, 0.0, &processed, &all_used));
2105 CHECK_EQ(0, processed);
2106
2107 CHECK_EQ(-5.0, StrToD("-0x5", flags, 0.0, &processed, &all_used));
2108 CHECK(all_used);
2109
2110 CHECK_EQ(Double::NaN(), StrToD(" - 0x5 ", flags, 0.0, &processed, &all_used));
2111 CHECK_EQ(0, processed);
2112
2113 CHECK_EQ(Double::NaN(), StrToD(" + 0x5 ", flags, 0.0, &processed, &all_used));
2114 CHECK_EQ(0, processed);
2115
2116 CHECK_EQ(Double::NaN(), StrToD("- -0x5", flags, 0.0, &processed, &all_used));
2117 CHECK_EQ(0, processed);
2118
2119 CHECK_EQ(Double::NaN(), StrToD("- +0x5", flags, 0.0, &processed, &all_used));
2120 CHECK_EQ(0, processed);
2121
2122 CHECK_EQ(Double::NaN(), StrToD("+ +0x5", flags, 0.0, &processed, &all_used));
2123 CHECK_EQ(0, processed);
2124
2125 flags = StringToDoubleConverter::ALLOW_TRAILING_JUNK |
2126 StringToDoubleConverter::ALLOW_HEX;
2127
2128 CHECK_EQ(18.0, StrToD("0x12", flags, 0.0, &processed, &all_used));
2129 CHECK(all_used);
2130
2131 CHECK_EQ(0.0, StrToD("0x0", flags, 1.0, &processed, &all_used));
2132 CHECK(all_used);
2133
2134 CHECK_EQ(static_cast<double>(0x123456789),
2135 StrToD("0x123456789", flags, Double::NaN(), &processed, &all_used));
2136 CHECK(all_used);
2137
2138 CHECK_EQ(Double::NaN(), StrToD(" 0x12 ", flags, 0.0, &processed, &all_used));
2139 CHECK_EQ(0, processed);
2140
2141 CHECK_EQ(Double::NaN(), StrToD(" 0x0 ", flags, 1.0, &processed, &all_used));
2142 CHECK_EQ(0, processed);
2143
2144 CHECK_EQ(18.0, StrToD("0x12 ", flags, 0.0, &processed, &all_used));
2145 CHECK_EQ(4, processed);
2146
2147 CHECK_EQ(0.0, StrToD("0x0 ", flags, 1.0, &processed, &all_used));
2148 CHECK_EQ(3, processed);
2149
2150 CHECK_EQ(Double::NaN(),
2151 StrToD(" 0x123456789 ", flags, Double::NaN(),
2152 &processed, &all_used));
2153 CHECK_EQ(0, processed);
2154
2155 CHECK_EQ(static_cast<double>(0xabcdef),
2156 StrToD("0xabcdef", flags, 0.0, &processed, &all_used));
2157 CHECK(all_used);
2158
2159 CHECK_EQ(static_cast<double>(0xabcdef),
2160 StrToD("0xABCDEF", flags, 0.0, &processed, &all_used));
2161 CHECK(all_used);
2162
2163 CHECK_EQ(Double::NaN(),
2164 StrToD(" 0xabcdef ", flags, 0.0, &processed, &all_used));
2165 CHECK_EQ(0, processed);
2166
2167 CHECK_EQ(Double::NaN(),
2168 StrToD(" 0xABCDEF ", flags, 0.0, &processed, &all_used));
2169 CHECK_EQ(0, processed);
2170
2171 CHECK_EQ(static_cast<double>(0xabcdef),
2172 StrToD("0xabcdef ", flags, 0.0, &processed, &all_used));
2173 CHECK_EQ(8, processed);
2174
2175 CHECK_EQ(static_cast<double>(0xabcdef),
2176 StrToD("0xABCDEF ", flags, 0.0, &processed, &all_used));
2177 CHECK_EQ(8, processed);
2178
2179 CHECK_EQ(Double::NaN(),
2180 StrToD(" 0xabcdef", flags, 0.0, &processed, &all_used));
2181 CHECK_EQ(0, processed);
2182
2183 CHECK_EQ(Double::NaN(),
2184 StrToD(" 0xABCDEF", flags, 0.0, &processed, &all_used));
2185 CHECK_EQ(0, processed);
2186
2187 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 0.0, &processed, &all_used));
2188 CHECK_EQ(0, processed);
2189
2190 CHECK_EQ(Double::NaN(), StrToD("0x", flags, 0.0,
2191 &processed, &all_used));
2192 CHECK_EQ(0, processed);
2193
2194 CHECK_EQ(Double::NaN(), StrToD(" 0x ", flags, 0.0,
2195 &processed, &all_used));
2196 CHECK_EQ(0, processed);
2197
2198 CHECK_EQ(Double::NaN(), StrToD(" 0x 3", flags, 0.0,
2199 &processed, &all_used));
2200 CHECK_EQ(0, processed);
2201
2202 CHECK_EQ(3.0, StrToD("0x3g", flags, 0.0, &processed, &all_used));
2203 CHECK_EQ(3, processed);
2204
2205 CHECK_EQ(3.0, StrToD("0x3.234", flags, 0.0, &processed, &all_used));
2206 CHECK_EQ(3, processed);
2207
2208 CHECK_EQ(Double::NaN(), StrToD(" 0x3g", flags, 0.0, &processed, &all_used));
2209 CHECK_EQ(0, processed);
2210
2211 CHECK_EQ(Double::NaN(),
2212 StrToD(" 0x3.234", flags, 0.0, &processed, &all_used));
2213 CHECK_EQ(0, processed);
2214
2215 CHECK_EQ(Double::NaN(), StrToD("x3", flags, 0.0,
2216 &processed, &all_used));
2217 CHECK_EQ(0, processed);
2218
2219 CHECK_EQ(Double::NaN(), StrToD("+ 0x3 foo", flags, 0.0,
2220 &processed, &all_used));
2221 CHECK_EQ(0, processed);
2222
2223 CHECK_EQ(Double::NaN(), StrToD("+", flags, 0.0, &processed, &all_used));
2224 CHECK_EQ(0, processed);
2225
2226 CHECK_EQ(Double::NaN(), StrToD("-", flags, 0.0, &processed, &all_used));
2227 CHECK_EQ(0, processed);
2228
2229 CHECK_EQ(-5.0, StrToD("-0x5", flags, 0.0, &processed, &all_used));
2230 CHECK(all_used);
2231
2232 CHECK_EQ(Double::NaN(), StrToD(" - 0x5 ", flags, 0.0, &processed, &all_used));
2233 CHECK_EQ(0, processed);
2234
2235 CHECK_EQ(Double::NaN(), StrToD(" + 0x5 ", flags, 0.0, &processed, &all_used));
2236 CHECK_EQ(0, processed);
2237
2238 CHECK_EQ(Double::NaN(), StrToD("- -0x5", flags, 0.0, &processed, &all_used));
2239 CHECK_EQ(0, processed);
2240
2241 CHECK_EQ(Double::NaN(), StrToD("- +0x5", flags, 0.0, &processed, &all_used));
2242 CHECK_EQ(0, processed);
2243
2244 CHECK_EQ(Double::NaN(), StrToD("+ +0x5", flags, 0.0, &processed, &all_used));
2245 CHECK_EQ(0, processed);
2246
2247 flags = StringToDoubleConverter::ALLOW_TRAILING_JUNK |
2248 StringToDoubleConverter::ALLOW_LEADING_SPACES |
2249 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
2250 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN |
2251 StringToDoubleConverter::ALLOW_HEX;
2252
2253 CHECK_EQ(18.0, StrToD("0x12", flags, 0.0, &processed, &all_used));
2254 CHECK(all_used);
2255
2256 CHECK_EQ(0.0, StrToD("0x0", flags, 1.0, &processed, &all_used));
2257 CHECK(all_used);
2258
2259 CHECK_EQ(static_cast<double>(0x123456789),
2260 StrToD("0x123456789", flags, Double::NaN(), &processed, &all_used));
2261 CHECK(all_used);
2262
2263 CHECK_EQ(18.0, StrToD(" 0x12 ", flags, 0.0, &processed, &all_used));
2264 CHECK(all_used);
2265
2266 CHECK_EQ(0.0, StrToD(" 0x0 ", flags, 1.0, &processed, &all_used));
2267 CHECK(all_used);
2268
2269 CHECK_EQ(static_cast<double>(0x123456789),
2270 StrToD(" 0x123456789 ", flags, Double::NaN(),
2271 &processed, &all_used));
2272 CHECK(all_used);
2273
2274 CHECK_EQ(static_cast<double>(0xabcdef),
2275 StrToD("0xabcdef", flags, 0.0, &processed, &all_used));
2276 CHECK(all_used);
2277
2278 CHECK_EQ(static_cast<double>(0xabcdef),
2279 StrToD("0xABCDEF", flags, 0.0, &processed, &all_used));
2280 CHECK(all_used);
2281
2282 CHECK_EQ(static_cast<double>(0xabcdef),
2283 StrToD(" 0xabcdef ", flags, 0.0, &processed, &all_used));
2284 CHECK(all_used);
2285
2286 CHECK_EQ(static_cast<double>(0xabcdef),
2287 StrToD(" 0xABCDEF ", flags, 0.0, &processed, &all_used));
2288 CHECK(all_used);
2289
2290 CHECK_EQ(static_cast<double>(0xabc),
2291 StrToD(" 0xabc def ", flags, 0.0, &processed, &all_used));
2292 CHECK_EQ(7, processed);
2293
2294 CHECK_EQ(static_cast<double>(0xabc),
2295 StrToD(" 0xABC DEF ", flags, 0.0, &processed, &all_used));
2296 CHECK_EQ(7, processed);
2297
2298 CHECK_EQ(static_cast<double>(0x12),
2299 StrToD(" 0x12 ", flags, 0.0, &processed, &all_used));
2300 CHECK(all_used);
2301
2302 CHECK_EQ(0.0, StrToD(" 0x0 ", flags, 1.0, &processed, &all_used));
2303 CHECK(all_used);
2304
2305 CHECK_EQ(static_cast<double>(0x123456789),
2306 StrToD(" 0x123456789 ", flags, Double::NaN(),
2307 &processed, &all_used));
2308 CHECK(all_used);
2309
2310 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
2311 &processed, &all_used));
2312 CHECK(all_used);
2313
2314 CHECK_EQ(Double::NaN(), StrToD("0x", flags, 0.0,
2315 &processed, &all_used));
2316 CHECK_EQ(0, processed);
2317
2318 CHECK_EQ(Double::NaN(), StrToD(" 0x ", flags, 0.0,
2319 &processed, &all_used));
2320 CHECK_EQ(0, processed);
2321
2322 CHECK_EQ(Double::NaN(), StrToD(" 0x 3", flags, 0.0,
2323 &processed, &all_used));
2324 CHECK_EQ(0, processed);
2325
2326 CHECK_EQ((double)0x3, StrToD("0x3g", flags, 0.0, &processed, &all_used));
2327 CHECK_EQ(3, processed);
2328
2329 CHECK_EQ((double)0x3, StrToD("0x3.234", flags, 0.0, &processed, &all_used));
2330 CHECK_EQ(3, processed);
2331
2332 CHECK_EQ(Double::NaN(), StrToD("x3", flags, 0.0,
2333 &processed, &all_used));
2334 CHECK_EQ(0, processed);
2335 }
2336
2337
2338 TEST(StringToDoubleOctalString) {
2339 int flags;
2340 int processed;
2341 bool all_used;
2342
2343 flags = StringToDoubleConverter::ALLOW_OCTALS |
2344 StringToDoubleConverter::ALLOW_LEADING_SPACES |
2345 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
2346 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
2347
2348 CHECK_EQ(10.0, StrToD("012", flags, 0.0, &processed, &all_used));
2349 CHECK(all_used);
2350
2351 CHECK_EQ(0.0, StrToD("00", flags, 1.0, &processed, &all_used));
2352 CHECK(all_used);
2353
2354 CHECK_EQ(10.0, StrToD("012", flags, 1.0, &processed, &all_used));
2355 CHECK(all_used);
2356
2357 CHECK_EQ(123456789.0,
2358 StrToD("0123456789", flags, Double::NaN(), &processed, &all_used));
2359 CHECK(all_used);
2360
2361 CHECK_EQ(342391.0,
2362 StrToD("01234567", flags, Double::NaN(), &processed, &all_used));
2363 CHECK(all_used);
2364
2365 CHECK_EQ(342391.0,
2366 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
2367 CHECK(all_used);
2368
2369 CHECK_EQ(-342391.0,
2370 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
2371 CHECK(all_used);
2372
2373 CHECK_EQ(10.0, StrToD(" 012", flags, 0.0, &processed, &all_used));
2374 CHECK(all_used);
2375
2376 CHECK_EQ(0.0, StrToD(" 00", flags, 1.0, &processed, &all_used));
2377 CHECK(all_used);
2378
2379 CHECK_EQ(10.0, StrToD(" 012", flags, 1.0, &processed, &all_used));
2380 CHECK(all_used);
2381
2382 CHECK_EQ(123456789.0,
2383 StrToD(" 0123456789", flags, Double::NaN(), &processed, &all_used));
2384 CHECK(all_used);
2385
2386 CHECK_EQ(342391.0,
2387 StrToD(" 01234567", flags, Double::NaN(), &processed, &all_used));
2388 CHECK(all_used);
2389
2390 CHECK_EQ(342391.0,
2391 StrToD(" + 01234567", flags, Double::NaN(), &processed, &all_used));
2392 CHECK(all_used);
2393
2394 CHECK_EQ(-342391.0,
2395 StrToD(" - 01234567", flags, Double::NaN(), &processed, &all_used));
2396 CHECK(all_used);
2397
2398 CHECK_EQ(10.0, StrToD(" 012 ", flags, 0.0, &processed, &all_used));
2399 CHECK(all_used);
2400
2401 CHECK_EQ(0.0, StrToD(" 00 ", flags, 1.0, &processed, &all_used));
2402 CHECK(all_used);
2403
2404 CHECK_EQ(10.0, StrToD(" 012 ", flags, 1.0, &processed, &all_used));
2405 CHECK(all_used);
2406
2407 CHECK_EQ(123456789.0,
2408 StrToD(" 0123456789 ", flags, Double::NaN(), &processed, &all_used));
2409 CHECK(all_used);
2410
2411 CHECK_EQ(342391.0,
2412 StrToD(" 01234567 ", flags, Double::NaN(), &processed, &all_used));
2413 CHECK(all_used);
2414
2415 CHECK_EQ(342391.0,
2416 StrToD(" + 01234567 ", flags, Double::NaN(), &processed, &all_used));
2417 CHECK(all_used);
2418
2419 CHECK_EQ(-342391.0,
2420 StrToD(" - 01234567 ", flags, Double::NaN(), &processed, &all_used));
2421 CHECK(all_used);
2422
2423 CHECK_EQ(10.0, StrToD("012 ", flags, 0.0, &processed, &all_used));
2424 CHECK(all_used);
2425
2426 CHECK_EQ(0.0, StrToD("00 ", flags, 1.0, &processed, &all_used));
2427 CHECK(all_used);
2428
2429 CHECK_EQ(10.0, StrToD("012 ", flags, 1.0, &processed, &all_used));
2430 CHECK(all_used);
2431
2432 CHECK_EQ(123456789.0,
2433 StrToD("0123456789 ", flags, Double::NaN(), &processed, &all_used));
2434 CHECK(all_used);
2435
2436 CHECK_EQ(342391.0,
2437 StrToD("01234567 ", flags, Double::NaN(), &processed, &all_used));
2438 CHECK(all_used);
2439
2440 CHECK_EQ(342391.0,
2441 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
2442 CHECK(all_used);
2443
2444 CHECK_EQ(-342391.0,
2445 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
2446 CHECK(all_used);
2447
2448 CHECK_EQ(Double::NaN(),
2449 StrToD("01234567e0", flags, Double::NaN(), &processed, &all_used));
2450 CHECK_EQ(0, processed);
2451
2452
2453 flags = StringToDoubleConverter::ALLOW_OCTALS;
2454 CHECK_EQ(10.0, StrToD("012", flags, 0.0, &processed, &all_used));
2455 CHECK(all_used);
2456
2457 CHECK_EQ(0.0, StrToD("00", flags, 1.0, &processed, &all_used));
2458 CHECK(all_used);
2459
2460 CHECK_EQ(10.0, StrToD("012", flags, 1.0, &processed, &all_used));
2461 CHECK(all_used);
2462
2463 CHECK_EQ(123456789.0,
2464 StrToD("0123456789", flags, Double::NaN(), &processed, &all_used));
2465 CHECK(all_used);
2466
2467 CHECK_EQ(342391.0,
2468 StrToD("01234567", flags, Double::NaN(), &processed, &all_used));
2469 CHECK(all_used);
2470
2471 CHECK_EQ(342391.0,
2472 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
2473 CHECK(all_used);
2474
2475 CHECK_EQ(-342391.0,
2476 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
2477 CHECK(all_used);
2478
2479 CHECK_EQ(Double::NaN(), StrToD(" 012", flags, 0.0, &processed, &all_used));
2480 CHECK_EQ(0, processed);
2481
2482 CHECK_EQ(Double::NaN(), StrToD(" 00", flags, 1.0, &processed, &all_used));
2483 CHECK_EQ(0, processed);
2484
2485 CHECK_EQ(Double::NaN(), StrToD(" 012", flags, 1.0, &processed, &all_used));
2486 CHECK_EQ(0, processed);
2487
2488 CHECK_EQ(Double::NaN(),
2489 StrToD(" 0123456789", flags, Double::NaN(), &processed, &all_used));
2490 CHECK_EQ(0, processed);
2491
2492 CHECK_EQ(Double::NaN(),
2493 StrToD(" 01234567", flags, Double::NaN(), &processed, &all_used));
2494 CHECK_EQ(0, processed);
2495
2496 CHECK_EQ(Double::NaN(),
2497 StrToD(" + 01234567", flags, Double::NaN(), &processed, &all_used));
2498 CHECK_EQ(0, processed);
2499
2500 CHECK_EQ(Double::NaN(),
2501 StrToD(" - 01234567", flags, Double::NaN(), &processed, &all_used));
2502 CHECK_EQ(0, processed);
2503
2504 CHECK_EQ(Double::NaN(), StrToD(" 012 ", flags, 0.0, &processed, &all_used));
2505 CHECK_EQ(0, processed);
2506
2507 CHECK_EQ(Double::NaN(), StrToD(" 00 ", flags, 1.0, &processed, &all_used));
2508 CHECK_EQ(0, processed);
2509
2510 CHECK_EQ(Double::NaN(), StrToD(" 012 ", flags, 1.0, &processed, &all_used));
2511 CHECK_EQ(0, processed);
2512
2513 CHECK_EQ(Double::NaN(),
2514 StrToD(" 0123456789 ", flags, Double::NaN(), &processed, &all_used));
2515 CHECK_EQ(0, processed);
2516
2517 CHECK_EQ(Double::NaN(),
2518 StrToD(" 01234567 ", flags, Double::NaN(), &processed, &all_used));
2519 CHECK_EQ(0, processed);
2520
2521 CHECK_EQ(Double::NaN(),
2522 StrToD(" + 01234567 ", flags, Double::NaN(), &processed, &all_used));
2523 CHECK_EQ(0, processed);
2524
2525 CHECK_EQ(Double::NaN(),
2526 StrToD(" - 01234567 ", flags, Double::NaN(), &processed, &all_used));
2527 CHECK_EQ(0, processed);
2528
2529 CHECK_EQ(Double::NaN(), StrToD("012 ", flags, 0.0, &processed, &all_used));
2530 CHECK_EQ(0, processed);
2531
2532 CHECK_EQ(Double::NaN(), StrToD("00 ", flags, 1.0, &processed, &all_used));
2533 CHECK_EQ(0, processed);
2534
2535 CHECK_EQ(Double::NaN(), StrToD("012 ", flags, 1.0, &processed, &all_used));
2536 CHECK_EQ(0, processed);
2537
2538 CHECK_EQ(Double::NaN(),
2539 StrToD("0123456789 ", flags, Double::NaN(), &processed, &all_used));
2540 CHECK_EQ(0, processed);
2541
2542 CHECK_EQ(Double::NaN(),
2543 StrToD("01234567 ", flags, Double::NaN(), &processed, &all_used));
2544 CHECK_EQ(0, processed);
2545
2546 CHECK_EQ(342391.0,
2547 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
2548 CHECK(all_used);
2549
2550 CHECK_EQ(-342391.0,
2551 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
2552 CHECK(all_used);
2553
2554 CHECK_EQ(Double::NaN(),
2555 StrToD("01234567e0", flags, Double::NaN(), &processed, &all_used));
2556 CHECK_EQ(0, processed);
2557
2558
2559 flags = StringToDoubleConverter::ALLOW_OCTALS |
2560 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
2561 CHECK_EQ(10.0, StrToD("012", flags, 0.0, &processed, &all_used));
2562 CHECK(all_used);
2563
2564 CHECK_EQ(0.0, StrToD("00", flags, 1.0, &processed, &all_used));
2565 CHECK(all_used);
2566
2567 CHECK_EQ(10.0, StrToD("012", flags, 1.0, &processed, &all_used));
2568 CHECK(all_used);
2569
2570 CHECK_EQ(123456789.0,
2571 StrToD("0123456789", flags, Double::NaN(), &processed, &all_used));
2572 CHECK(all_used);
2573
2574 CHECK_EQ(342391.0,
2575 StrToD("01234567", flags, Double::NaN(), &processed, &all_used));
2576 CHECK(all_used);
2577
2578 CHECK_EQ(342391.0,
2579 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
2580 CHECK(all_used);
2581
2582 CHECK_EQ(-342391.0,
2583 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
2584 CHECK(all_used);
2585
2586 CHECK_EQ(Double::NaN(), StrToD(" 012", flags, 0.0, &processed, &all_used));
2587 CHECK_EQ(0, processed);
2588
2589 CHECK_EQ(Double::NaN(), StrToD(" 00", flags, 1.0, &processed, &all_used));
2590 CHECK_EQ(0, processed);
2591
2592 CHECK_EQ(Double::NaN(), StrToD(" 012", flags, 1.0, &processed, &all_used));
2593 CHECK_EQ(0, processed);
2594
2595 CHECK_EQ(Double::NaN(),
2596 StrToD(" 0123456789", flags, Double::NaN(), &processed, &all_used));
2597 CHECK_EQ(0, processed);
2598
2599 CHECK_EQ(Double::NaN(),
2600 StrToD(" 01234567", flags, Double::NaN(), &processed, &all_used));
2601 CHECK_EQ(0, processed);
2602
2603 CHECK_EQ(Double::NaN(),
2604 StrToD(" + 01234567", flags, Double::NaN(), &processed, &all_used));
2605 CHECK_EQ(0, processed);
2606
2607 CHECK_EQ(Double::NaN(),
2608 StrToD(" - 01234567", flags, Double::NaN(), &processed, &all_used));
2609 CHECK_EQ(0, processed);
2610
2611 CHECK_EQ(Double::NaN(), StrToD(" 012 ", flags, 0.0, &processed, &all_used));
2612 CHECK_EQ(0, processed);
2613
2614 CHECK_EQ(Double::NaN(), StrToD(" 00 ", flags, 1.0, &processed, &all_used));
2615 CHECK_EQ(0, processed);
2616
2617 CHECK_EQ(Double::NaN(), StrToD(" 012 ", flags, 1.0, &processed, &all_used));
2618 CHECK_EQ(0, processed);
2619
2620 CHECK_EQ(Double::NaN(),
2621 StrToD(" 0123456789 ", flags, Double::NaN(), &processed, &all_used));
2622 CHECK_EQ(0, processed);
2623
2624 CHECK_EQ(Double::NaN(),
2625 StrToD(" 01234567 ", flags, Double::NaN(), &processed, &all_used));
2626 CHECK_EQ(0, processed);
2627
2628 CHECK_EQ(Double::NaN(),
2629 StrToD(" + 01234567 ", flags, Double::NaN(), &processed, &all_used));
2630 CHECK_EQ(0, processed);
2631
2632 CHECK_EQ(Double::NaN(),
2633 StrToD(" - 01234567 ", flags, Double::NaN(), &processed, &all_used));
2634 CHECK_EQ(0, processed);
2635
2636 CHECK_EQ(10.0, StrToD("012 ", flags, 0.0, &processed, &all_used));
2637 CHECK_EQ(3, processed);
2638
2639 CHECK_EQ(0.0, StrToD("00 ", flags, 1.0, &processed, &all_used));
2640 CHECK_EQ(2, processed);
2641
2642 CHECK_EQ(123456789.0,
2643 StrToD("0123456789 ", flags, Double::NaN(), &processed, &all_used));
2644 CHECK_EQ(10, processed);
2645
2646 CHECK_EQ(342391.0,
2647 StrToD("01234567 ", flags, Double::NaN(), &processed, &all_used));
2648 CHECK_EQ(8, processed);
2649
2650 CHECK_EQ(342391.0,
2651 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
2652 CHECK(all_used);
2653
2654 CHECK_EQ(-342391.0,
2655 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
2656 CHECK(all_used);
2657
2658 CHECK_EQ(10.0, StrToD("012foo ", flags, 0.0, &processed, &all_used));
2659 CHECK_EQ(3, processed);
2660
2661 CHECK_EQ(0.0, StrToD("00foo ", flags, 1.0, &processed, &all_used));
2662 CHECK_EQ(2, processed);
2663
2664 CHECK_EQ(123456789.0,
2665 StrToD("0123456789foo ", flags, Double::NaN(),
2666 &processed, &all_used));
2667 CHECK_EQ(10, processed);
2668
2669 CHECK_EQ(342391.0,
2670 StrToD("01234567foo ", flags, Double::NaN(), &processed, &all_used));
2671 CHECK_EQ(8, processed);
2672
2673 CHECK_EQ(342391.0,
2674 StrToD("+01234567foo", flags, Double::NaN(), &processed, &all_used));
2675 CHECK_EQ(9, processed);
2676
2677 CHECK_EQ(-342391.0,
2678 StrToD("-01234567foo", flags, Double::NaN(), &processed, &all_used));
2679 CHECK_EQ(9, processed);
2680
2681 CHECK_EQ(10.0, StrToD("012 foo ", flags, 0.0, &processed, &all_used));
2682 CHECK_EQ(3, processed);
2683
2684 CHECK_EQ(0.0, StrToD("00 foo ", flags, 1.0, &processed, &all_used));
2685 CHECK_EQ(2, processed);
2686
2687 CHECK_EQ(123456789.0,
2688 StrToD("0123456789 foo ", flags, Double::NaN(),
2689 &processed, &all_used));
2690 CHECK_EQ(10, processed);
2691
2692 CHECK_EQ(342391.0,
2693 StrToD("01234567 foo ", flags, Double::NaN(),
2694 &processed, &all_used));
2695 CHECK_EQ(8, processed);
2696
2697 CHECK_EQ(342391.0,
2698 StrToD("+01234567 foo", flags, Double::NaN(),
2699 &processed, &all_used));
2700 CHECK_EQ(9, processed);
2701
2702 CHECK_EQ(-342391.0,
2703 StrToD("-01234567 foo", flags, Double::NaN(), &processed,
2704 &all_used));
2705 CHECK_EQ(9, processed);
2706
2707 CHECK_EQ(342391.0,
2708 StrToD("01234567e0", flags, Double::NaN(), &processed, &all_used));
2709 CHECK_EQ(8, processed);
2710
2711 CHECK_EQ(342391.0,
2712 StrToD("01234567e", flags, Double::NaN(), &processed, &all_used));
2713 CHECK_EQ(8, processed);
2714
2715 flags = StringToDoubleConverter::ALLOW_OCTALS |
2716 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
2717 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
2718 CHECK_EQ(10.0, StrToD("012", flags, 0.0, &processed, &all_used));
2719 CHECK(all_used);
2720
2721 CHECK_EQ(0.0, StrToD("00", flags, 1.0, &processed, &all_used));
2722 CHECK(all_used);
2723
2724 CHECK_EQ(10.0, StrToD("012", flags, 1.0, &processed, &all_used));
2725 CHECK(all_used);
2726
2727 CHECK_EQ(123456789.0,
2728 StrToD("0123456789", flags, Double::NaN(), &processed, &all_used));
2729 CHECK(all_used);
2730
2731 CHECK_EQ(342391.0,
2732 StrToD("01234567", flags, Double::NaN(), &processed, &all_used));
2733 CHECK(all_used);
2734
2735 CHECK_EQ(342391.0,
2736 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
2737 CHECK(all_used);
2738
2739 CHECK_EQ(-342391.0,
2740 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
2741 CHECK(all_used);
2742
2743 CHECK_EQ(Double::NaN(), StrToD(" 012", flags, 0.0, &processed, &all_used));
2744 CHECK_EQ(0, processed);
2745
2746 CHECK_EQ(Double::NaN(), StrToD(" 00", flags, 1.0, &processed, &all_used));
2747 CHECK_EQ(0, processed);
2748
2749 CHECK_EQ(Double::NaN(), StrToD(" 012", flags, 1.0, &processed, &all_used));
2750 CHECK_EQ(0, processed);
2751
2752 CHECK_EQ(Double::NaN(),
2753 StrToD(" 0123456789", flags, Double::NaN(), &processed, &all_used));
2754 CHECK_EQ(0, processed);
2755
2756 CHECK_EQ(Double::NaN(),
2757 StrToD(" 01234567", flags, Double::NaN(), &processed, &all_used));
2758 CHECK_EQ(0, processed);
2759
2760 CHECK_EQ(Double::NaN(),
2761 StrToD(" + 01234567", flags, Double::NaN(), &processed, &all_used));
2762 CHECK_EQ(0, processed);
2763
2764 CHECK_EQ(Double::NaN(),
2765 StrToD(" - 01234567", flags, Double::NaN(), &processed, &all_used));
2766 CHECK_EQ(0, processed);
2767
2768 CHECK_EQ(Double::NaN(), StrToD(" 012 ", flags, 0.0, &processed, &all_used));
2769 CHECK_EQ(0, processed);
2770
2771 CHECK_EQ(Double::NaN(), StrToD(" 00 ", flags, 1.0, &processed, &all_used));
2772 CHECK_EQ(0, processed);
2773
2774 CHECK_EQ(Double::NaN(), StrToD(" 012 ", flags, 1.0, &processed, &all_used));
2775 CHECK_EQ(0, processed);
2776
2777 CHECK_EQ(Double::NaN(),
2778 StrToD(" 0123456789 ", flags, Double::NaN(), &processed, &all_used));
2779 CHECK_EQ(0, processed);
2780
2781 CHECK_EQ(Double::NaN(),
2782 StrToD(" 01234567 ", flags, Double::NaN(), &processed, &all_used));
2783 CHECK_EQ(0, processed);
2784
2785 CHECK_EQ(Double::NaN(),
2786 StrToD(" + 01234567 ", flags, Double::NaN(), &processed, &all_used));
2787 CHECK_EQ(0, processed);
2788
2789 CHECK_EQ(Double::NaN(),
2790 StrToD(" - 01234567 ", flags, Double::NaN(), &processed, &all_used));
2791 CHECK_EQ(0, processed);
2792
2793 CHECK_EQ(10.0, StrToD("012 ", flags, 0.0, &processed, &all_used));
2794 CHECK(all_used);
2795
2796 CHECK_EQ(0.0, StrToD("00 ", flags, 1.0, &processed, &all_used));
2797 CHECK(all_used);
2798
2799 CHECK_EQ(123456789.0,
2800 StrToD("0123456789 ", flags, Double::NaN(), &processed, &all_used));
2801 CHECK(all_used);
2802
2803 CHECK_EQ(342391.0,
2804 StrToD("01234567 ", flags, Double::NaN(), &processed, &all_used));
2805 CHECK(all_used);
2806
2807 CHECK_EQ(342391.0,
2808 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
2809 CHECK(all_used);
2810
2811 CHECK_EQ(-342391.0,
2812 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
2813 CHECK(all_used);
2814
2815 CHECK_EQ(10.0, StrToD("012foo ", flags, 0.0, &processed, &all_used));
2816 CHECK_EQ(3, processed);
2817
2818 CHECK_EQ(0.0, StrToD("00foo ", flags, 1.0, &processed, &all_used));
2819 CHECK_EQ(2, processed);
2820
2821 CHECK_EQ(123456789.0,
2822 StrToD("0123456789foo ", flags, Double::NaN(),
2823 &processed, &all_used));
2824 CHECK_EQ(10, processed);
2825
2826 CHECK_EQ(342391.0,
2827 StrToD("01234567foo ", flags, Double::NaN(), &processed, &all_used));
2828 CHECK_EQ(8, processed);
2829
2830 CHECK_EQ(342391.0,
2831 StrToD("+01234567foo", flags, Double::NaN(), &processed, &all_used));
2832 CHECK_EQ(9, processed);
2833
2834 CHECK_EQ(-342391.0,
2835 StrToD("-01234567foo", flags, Double::NaN(), &processed, &all_used));
2836 CHECK_EQ(9, processed);
2837
2838 CHECK_EQ(10.0, StrToD("012 foo ", flags, 0.0, &processed, &all_used));
2839 CHECK_EQ(4, processed);
2840
2841 CHECK_EQ(0.0, StrToD("00 foo ", flags, 1.0, &processed, &all_used));
2842 CHECK_EQ(3, processed);
2843
2844 CHECK_EQ(123456789.0,
2845 StrToD("0123456789 foo ", flags, Double::NaN(),
2846 &processed, &all_used));
2847 CHECK_EQ(11, processed);
2848
2849 CHECK_EQ(342391.0,
2850 StrToD("01234567 foo ", flags, Double::NaN(),
2851 &processed, &all_used));
2852 CHECK_EQ(9, processed);
2853
2854 CHECK_EQ(342391.0,
2855 StrToD("+01234567 foo", flags, Double::NaN(),
2856 &processed, &all_used));
2857 CHECK_EQ(10, processed);
2858
2859 CHECK_EQ(-342391.0,
2860 StrToD("-01234567 foo", flags, Double::NaN(),
2861 &processed, &all_used));
2862 CHECK_EQ(10, processed);
2863 }
2864
2865
2866 TEST(StringToDoubleSpecialValues) {
2867 int processed;
2868 int flags = StringToDoubleConverter::NO_FLAGS;
2869
2870 {
2871 // Use 1.0 as junk_string_value.
2872 StringToDoubleConverter converter(flags, 0.0, 1.0, "infinity", "NaN");
2873
2874 CHECK_EQ(Double::NaN(), converter.StringToDouble("+NaN", 4, &processed));
2875 CHECK_EQ(4, processed);
2876
2877 CHECK_EQ(-Double::Infinity(),
2878 converter.StringToDouble("-infinity", 9, &processed));
2879 CHECK_EQ(9, processed);
2880
2881 CHECK_EQ(1.0, converter.StringToDouble("Infinity", 8, &processed));
2882 CHECK_EQ(0, processed);
2883
2884 CHECK_EQ(1.0, converter.StringToDouble("++NaN", 5, &processed));
2885 CHECK_EQ(0, processed);
2886 }
2887
2888 {
2889 // Use 1.0 as junk_string_value.
2890 StringToDoubleConverter converter(flags, 0.0, 1.0, "+infinity", "1NaN");
2891
2892 // The '+' is consumed before trying to match the infinity string.
2893 CHECK_EQ(1.0, converter.StringToDouble("+infinity", 9, &processed));
2894 CHECK_EQ(0, processed);
2895
2896 // The match for "1NaN" triggers, and doesn't let the 1234.0 complete.
2897 CHECK_EQ(1.0, converter.StringToDouble("1234.0", 6, &processed));
2898 CHECK_EQ(0, processed);
2899 }
2900 }
2901
2902
2903 TEST(StringToDoubleCommentExamples) {
2904 // Make sure the examples in the comments are correct.
2905 int flags;
2906 int processed;
2907 bool all_used;
2908
2909 flags = StringToDoubleConverter::ALLOW_HEX;
2910
2911 CHECK_EQ(4660.0, StrToD("0x1234", flags, 0.0, &processed, &all_used));
2912 CHECK(all_used);
2913
2914 CHECK_EQ(Double::NaN(),
2915 StrToD("0x1234.56", flags, 0.0, &processed, &all_used));
2916 CHECK_EQ(0, processed);
2917
2918 flags |= StringToDoubleConverter::ALLOW_TRAILING_JUNK;
2919 CHECK_EQ(4660.0,
2920 StrToD("0x1234.56", flags, 0.0, &processed, &all_used));
2921 CHECK_EQ(6, processed);
2922
2923 flags = StringToDoubleConverter::ALLOW_OCTALS;
2924 CHECK_EQ(668.0, StrToD("01234", flags, 0.0, &processed, &all_used));
2925 CHECK(all_used);
2926
2927 CHECK_EQ(12349.0, StrToD("012349", flags, 0.0, &processed, &all_used));
2928 CHECK(all_used);
2929
2930 CHECK_EQ(Double::NaN(),
2931 StrToD("01234.56", flags, 0.0, &processed, &all_used));
2932 CHECK_EQ(processed, 0);
2933
2934 flags |= StringToDoubleConverter::ALLOW_TRAILING_JUNK;
2935 CHECK_EQ(668.0,
2936 StrToD("01234.56", flags, 0.0, &processed, &all_used));
2937 CHECK_EQ(processed, 5);
2938
2939 flags = StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
2940 CHECK_EQ(-123.2, StrToD("- 123.2", flags, 0.0, &processed, &all_used));
2941 CHECK(all_used);
2942
2943 flags = StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
2944 CHECK_EQ(123.2, StrToD("+ 123.2", flags, 0.0, &processed, &all_used));
2945 CHECK(all_used);
2946
2947 flags = StringToDoubleConverter::ALLOW_HEX |
2948 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
2949
2950 CHECK_EQ(4660.0, StrToD("0x1234", flags, 0.0, &processed, &all_used));
2951 CHECK(all_used);
2952
2953 CHECK_EQ(4660.0, StrToD("0x1234K", flags, 0.0, &processed, &all_used));
2954 CHECK_EQ(processed, 6);
2955
2956 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
2957 CHECK(all_used);
2958
2959 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 0.0, &processed, &all_used));
2960 CHECK_EQ(processed, 0);
2961
2962 CHECK_EQ(Double::NaN(), StrToD(" 1", flags, 0.0, &processed, &all_used));
2963 CHECK_EQ(processed, 0);
2964
2965 CHECK_EQ(Double::NaN(), StrToD("0x", flags, 0.0, &processed, &all_used));
2966 CHECK_EQ(processed, 0);
2967
2968 CHECK_EQ(-123.45, StrToD("-123.45", flags, 0.0, &processed, &all_used));
2969 CHECK(all_used);
2970
2971 CHECK_EQ(Double::NaN(),
2972 StrToD("--123.45", flags, 0.0, &processed, &all_used));
2973 CHECK_EQ(processed, 0);
2974
2975 CHECK_EQ(123e45, StrToD("123e45", flags, 0.0, &processed, &all_used));
2976 CHECK(all_used);
2977
2978 CHECK_EQ(123e45, StrToD("123E45", flags, 0.0, &processed, &all_used));
2979 CHECK(all_used);
2980
2981 CHECK_EQ(123e45, StrToD("123e+45", flags, 0.0, &processed, &all_used));
2982 CHECK(all_used);
2983
2984 CHECK_EQ(123e-45, StrToD("123e-45", flags, 0.0, &processed, &all_used));
2985 CHECK(all_used);
2986
2987 CHECK_EQ(123.0, StrToD("123e", flags, 0.0, &processed, &all_used));
2988 CHECK(all_used);
2989
2990 CHECK_EQ(123.0, StrToD("123e-", flags, 0.0, &processed, &all_used));
2991 CHECK(all_used);
2992
2993 {
2994 StringToDoubleConverter converter(flags, 0.0, 1.0, "infinity", "NaN");
2995 CHECK_EQ(Double::NaN(), converter.StringToDouble("+NaN", 4, &processed));
2996 CHECK_EQ(4, processed);
2997
2998 CHECK_EQ(-Double::Infinity(),
2999 converter.StringToDouble("-infinity", 9, &processed));
3000 CHECK_EQ(9, processed);
3001
3002 CHECK_EQ(1.0, converter.StringToDouble("Infinity", 9, &processed));
3003 CHECK_EQ(0, processed);
3004 }
3005
3006 flags = StringToDoubleConverter::ALLOW_OCTALS |
3007 StringToDoubleConverter::ALLOW_LEADING_SPACES;
3008
3009 CHECK_EQ(Double::NaN(), StrToD("0x1234", flags, 0.0, &processed, &all_used));
3010 CHECK_EQ(0, processed);
3011
3012 CHECK_EQ(668.0, StrToD("01234", flags, 0.0, &processed, &all_used));
3013 CHECK(all_used);
3014
3015 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
3016 CHECK(all_used);
3017
3018 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
3019 CHECK(all_used);
3020
3021 CHECK_EQ(1.0, StrToD(" 1", flags, 0.0, &processed, &all_used));
3022 CHECK(all_used);
3023
3024 CHECK_EQ(Double::NaN(), StrToD("0x", flags, 0.0, &processed, &all_used));
3025 CHECK_EQ(0, processed);
3026
3027 CHECK_EQ(Double::NaN(), StrToD("0123e45", flags, 0.0, &processed, &all_used));
3028 CHECK_EQ(0, processed);
3029
3030 CHECK_EQ(1239e45, StrToD("01239e45", flags, 0.0, &processed, &all_used));
3031 CHECK(all_used);
3032
3033 CHECK_EQ(Double::NaN(),
3034 StrToD("-infinity", flags, 0.0, &processed, &all_used));
3035 CHECK_EQ(0, processed);
3036
3037 CHECK_EQ(Double::NaN(), StrToD("NaN", flags, 0.0, &processed, &all_used));
3038 CHECK_EQ(0, processed);
3039 }
OLDNEW
« runtime/third_party/double-conversion/src/SConscript ('K') | « runtime/third_party/double-conversion/test/cctest/test-bignum-dtoa.cc ('k') | runtime/third_party/double-conversion/test/cctest/test-diy-fp.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698