1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28 #include <string.h>
29
30 #include "cctest.h"
31 #include "double-conversion/double-conversion.h"
32 #include "double-conversion/ieee.h"
33 #include "double-conversion/utils.h"
34
35 // DoubleToString is already tested in test-dtoa.cc.
36
37 using namespace double_conversion;
38
39
TEST(DoubleToShortest)40 TEST(DoubleToShortest) {
41 const int kBufferSize = 128;
42 char buffer[kBufferSize];
43 StringBuilder builder(buffer, kBufferSize);
44 int flags = DoubleToStringConverter::UNIQUE_ZERO |
45 DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
46 DoubleToStringConverter dc(flags, NULL, NULL, 'e', -6, 21, 0, 0);
47
48 CHECK(dc.ToShortest(0.0, &builder));
49 CHECK_EQ("0", builder.Finalize());
50
51 builder.Reset();
52 CHECK(dc.ToShortest(12345.0, &builder));
53 CHECK_EQ("12345", builder.Finalize());
54
55 builder.Reset();
56 CHECK(dc.ToShortest(12345e23, &builder));
57 CHECK_EQ("1.2345e+27", builder.Finalize());
58
59 builder.Reset();
60 CHECK(dc.ToShortest(1e21, &builder));
61 CHECK_EQ("1e+21", builder.Finalize());
62
63 builder.Reset();
64 CHECK(dc.ToShortest(1e-23, &builder));
65 CHECK_EQ("1e-23", builder.Finalize());
66
67 builder.Reset();
68 CHECK(dc.ToShortest(1e20, &builder));
69 CHECK_EQ("100000000000000000000", builder.Finalize());
70
71 builder.Reset();
72 CHECK(dc.ToShortest(111111111111111111111.0, &builder));
73 CHECK_EQ("111111111111111110000", builder.Finalize());
74
75 builder.Reset();
76 CHECK(dc.ToShortest(1111111111111111111111.0, &builder));
77 CHECK_EQ("1.1111111111111111e+21", builder.Finalize());
78
79 builder.Reset();
80 CHECK(dc.ToShortest(11111111111111111111111.0, &builder));
81 CHECK_EQ("1.1111111111111111e+22", builder.Finalize());
82
83 builder.Reset();
84 CHECK(dc.ToShortest(-0.00001, &builder));
85 CHECK_EQ("-0.00001", builder.Finalize());
86
87 builder.Reset();
88 CHECK(dc.ToShortest(-0.000001, &builder));
89 CHECK_EQ("-0.000001", builder.Finalize());
90
91 builder.Reset();
92 CHECK(dc.ToShortest(-0.0000001, &builder));
93 CHECK_EQ("-1e-7", builder.Finalize());
94
95 builder.Reset();
96 CHECK(dc.ToShortest(-0.0, &builder));
97 CHECK_EQ("0", builder.Finalize());
98
99 // Test min_exponent_width
100 flags = DoubleToStringConverter::UNIQUE_ZERO |
101 DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
102 DoubleToStringConverter dcExpWidth2(flags, NULL, NULL, 'e', -4, 6, 0, 0, 2);
103
104 builder.Reset();
105 CHECK(dcExpWidth2.ToShortest(11111111111.0, &builder));
106 CHECK_EQ("1.1111111111e+10", builder.Finalize());
107
108 builder.Reset();
109 CHECK(dcExpWidth2.ToShortest(1111111111.0, &builder));
110 CHECK_EQ("1.111111111e+09", builder.Finalize());
111
112 builder.Reset();
113 CHECK(dcExpWidth2.ToShortest(1111111.0, &builder));
114 CHECK_EQ("1.111111e+06", builder.Finalize());
115
116 builder.Reset();
117 CHECK(dcExpWidth2.ToShortest(111111.0, &builder));
118 CHECK_EQ("111111", builder.Finalize());
119
120 builder.Reset();
121 CHECK(dcExpWidth2.ToShortest(10000000000.0, &builder));
122 CHECK_EQ("1e+10", builder.Finalize());
123
124 builder.Reset();
125 CHECK(dcExpWidth2.ToShortest(1000000000.0, &builder));
126 CHECK_EQ("1e+09", builder.Finalize());
127
128 DoubleToStringConverter dcExpWidth0(flags, NULL, NULL, 'e', -4, 6, 0, 0, 0);
129
130 builder.Reset();
131 CHECK(dcExpWidth0.ToShortest(11111111111.0, &builder));
132 CHECK_EQ("1.1111111111e+10", builder.Finalize());
133
134 builder.Reset();
135 CHECK(dcExpWidth0.ToShortest(1111111111.0, &builder));
136 CHECK_EQ("1.111111111e+9", builder.Finalize());
137
138 builder.Reset();
139 CHECK(dcExpWidth0.ToShortest(1111111.0, &builder));
140 CHECK_EQ("1.111111e+6", builder.Finalize());
141
142 builder.Reset();
143 CHECK(dcExpWidth0.ToShortest(111111.0, &builder));
144 CHECK_EQ("111111", builder.Finalize());
145
146 builder.Reset();
147 CHECK(dcExpWidth0.ToShortest(10000000000.0, &builder));
148 CHECK_EQ("1e+10", builder.Finalize());
149
150 builder.Reset();
151 CHECK(dcExpWidth0.ToShortest(1000000000.0, &builder));
152 CHECK_EQ("1e+9", builder.Finalize());
153
154 // Set min_exponent_width to 100 is equal to 5,
155 // as kMaxExponentLength is defined to 5 in double-to-string.cc
156 DoubleToStringConverter dcExpWidth100(flags, NULL, NULL, 'e', -4, 6, 0, 0, 100);
157
158 builder.Reset();
159 CHECK(dcExpWidth100.ToShortest(11111111111.0, &builder));
160 CHECK_EQ("1.1111111111e+00010", builder.Finalize());
161
162 builder.Reset();
163 CHECK(dcExpWidth100.ToShortest(1111111111.0, &builder));
164 CHECK_EQ("1.111111111e+00009", builder.Finalize());
165
166 builder.Reset();
167 CHECK(dcExpWidth100.ToShortest(1111111.0, &builder));
168 CHECK_EQ("1.111111e+00006", builder.Finalize());
169
170 builder.Reset();
171 CHECK(dcExpWidth100.ToShortest(111111.0, &builder));
172 CHECK_EQ("111111", builder.Finalize());
173
174 builder.Reset();
175 CHECK(dcExpWidth100.ToShortest(10000000000.0, &builder));
176 CHECK_EQ("1e+00010", builder.Finalize());
177
178 builder.Reset();
179 CHECK(dcExpWidth100.ToShortest(1000000000.0, &builder));
180 CHECK_EQ("1e+00009", builder.Finalize());
181 // End of min_exponent_width testing
182
183 flags = DoubleToStringConverter::NO_FLAGS;
184 DoubleToStringConverter dc2(flags, NULL, NULL, 'e', -1, 1, 0, 0);
185 builder.Reset();
186 CHECK(dc2.ToShortest(0.1, &builder));
187 CHECK_EQ("0.1", builder.Finalize());
188
189 builder.Reset();
190 CHECK(dc2.ToShortest(0.01, &builder));
191 CHECK_EQ("1e-2", builder.Finalize());
192
193 builder.Reset();
194 CHECK(dc2.ToShortest(1.0, &builder));
195 CHECK_EQ("1", builder.Finalize());
196
197 builder.Reset();
198 CHECK(dc2.ToShortest(10.0, &builder));
199 CHECK_EQ("1e1", builder.Finalize());
200
201 builder.Reset();
202 CHECK(dc2.ToShortest(-0.0, &builder));
203 CHECK_EQ("-0", builder.Finalize());
204
205 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
206 DoubleToStringConverter::EMIT_TRAILING_ZERO_AFTER_POINT;
207 DoubleToStringConverter dc3(flags, NULL, NULL, 'E', -5, 5, 0, 0);
208
209 builder.Reset();
210 CHECK(dc3.ToShortest(0.1, &builder));
211 CHECK_EQ("0.1", builder.Finalize());
212
213 builder.Reset();
214 CHECK(dc3.ToShortest(1.0, &builder));
215 CHECK_EQ("1.0", builder.Finalize());
216
217 builder.Reset();
218 CHECK(dc3.ToShortest(10000.0, &builder));
219 CHECK_EQ("10000.0", builder.Finalize());
220
221 builder.Reset();
222 CHECK(dc3.ToShortest(100000.0, &builder));
223 CHECK_EQ("1E5", builder.Finalize());
224
225 // Test the examples in the comments of ToShortest.
226 flags = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
227 DoubleToStringConverter dc4(flags, NULL, NULL, 'e', -6, 21, 0, 0);
228
229 builder.Reset();
230 CHECK(dc4.ToShortest(0.000001, &builder));
231 CHECK_EQ("0.000001", builder.Finalize());
232
233 builder.Reset();
234 CHECK(dc4.ToShortest(0.0000001, &builder));
235 CHECK_EQ("1e-7", builder.Finalize());
236
237 builder.Reset();
238 CHECK(dc4.ToShortest(111111111111111111111.0, &builder));
239 CHECK_EQ("111111111111111110000", builder.Finalize());
240
241 builder.Reset();
242 CHECK(dc4.ToShortest(100000000000000000000.0, &builder));
243 CHECK_EQ("100000000000000000000", builder.Finalize());
244
245 builder.Reset();
246 CHECK(dc4.ToShortest(1111111111111111111111.0, &builder));
247 CHECK_EQ("1.1111111111111111e+21", builder.Finalize());
248
249 // Test special value handling.
250 DoubleToStringConverter dc5(flags, NULL, NULL, 'e', 0, 0, 0, 0);
251
252 builder.Reset();
253 CHECK(!dc5.ToShortest(Double::Infinity(), &builder));
254
255 builder.Reset();
256 CHECK(!dc5.ToShortest(-Double::Infinity(), &builder));
257
258 builder.Reset();
259 CHECK(!dc5.ToShortest(Double::NaN(), &builder));
260
261 builder.Reset();
262 CHECK(!dc5.ToShortest(-Double::NaN(), &builder));
263
264 DoubleToStringConverter dc6(flags, "Infinity", "NaN", 'e', 0, 0, 0, 0);
265
266 builder.Reset();
267 CHECK(dc6.ToShortest(Double::Infinity(), &builder));
268 CHECK_EQ("Infinity", builder.Finalize());
269
270 builder.Reset();
271 CHECK(dc6.ToShortest(-Double::Infinity(), &builder));
272 CHECK_EQ("-Infinity", builder.Finalize());
273
274 builder.Reset();
275 CHECK(dc6.ToShortest(Double::NaN(), &builder));
276 CHECK_EQ("NaN", builder.Finalize());
277
278 builder.Reset();
279 CHECK(dc6.ToShortest(-Double::NaN(), &builder));
280 CHECK_EQ("NaN", builder.Finalize());
281 }
282
283
TEST(DoubleToShortestSingle)284 TEST(DoubleToShortestSingle) {
285 const int kBufferSize = 128;
286 char buffer[kBufferSize];
287 StringBuilder builder(buffer, kBufferSize);
288 int flags = DoubleToStringConverter::UNIQUE_ZERO |
289 DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
290 DoubleToStringConverter dc(flags, NULL, NULL, 'e', -6, 21, 0, 0);
291
292 CHECK(dc.ToShortestSingle(0.0f, &builder));
293 CHECK_EQ("0", builder.Finalize());
294
295 builder.Reset();
296 CHECK(dc.ToShortestSingle(12345.0f, &builder));
297 CHECK_EQ("12345", builder.Finalize());
298
299 builder.Reset();
300 CHECK(dc.ToShortestSingle(12345e23f, &builder));
301 CHECK_EQ("1.2345e+27", builder.Finalize());
302
303 builder.Reset();
304 CHECK(dc.ToShortestSingle(1e21f, &builder));
305 CHECK_EQ("1e+21", builder.Finalize());
306
307 builder.Reset();
308 CHECK(dc.ToShortestSingle(1e20f, &builder));
309 CHECK_EQ("100000000000000000000", builder.Finalize());
310
311 builder.Reset();
312 CHECK(dc.ToShortestSingle(111111111111111111111.0f, &builder));
313 CHECK_EQ("111111110000000000000", builder.Finalize());
314
315 builder.Reset();
316 CHECK(dc.ToShortestSingle(1111111111111111111111.0f, &builder));
317 CHECK_EQ("1.11111114e+21", builder.Finalize());
318
319 builder.Reset();
320 CHECK(dc.ToShortestSingle(11111111111111111111111.0f, &builder));
321 CHECK_EQ("1.1111111e+22", builder.Finalize());
322
323 builder.Reset();
324 CHECK(dc.ToShortestSingle(-0.00001f, &builder));
325 CHECK_EQ("-0.00001", builder.Finalize());
326
327 builder.Reset();
328 CHECK(dc.ToShortestSingle(-0.000001f, &builder));
329 CHECK_EQ("-0.000001", builder.Finalize());
330
331 builder.Reset();
332 CHECK(dc.ToShortestSingle(-0.0000001f, &builder));
333 CHECK_EQ("-1e-7", builder.Finalize());
334
335 builder.Reset();
336 CHECK(dc.ToShortestSingle(-0.0f, &builder));
337 CHECK_EQ("0", builder.Finalize());
338
339 flags = DoubleToStringConverter::NO_FLAGS;
340 DoubleToStringConverter dc2(flags, NULL, NULL, 'e', -1, 1, 0, 0);
341 builder.Reset();
342 CHECK(dc2.ToShortestSingle(0.1f, &builder));
343 CHECK_EQ("0.1", builder.Finalize());
344
345 builder.Reset();
346 CHECK(dc2.ToShortestSingle(0.01f, &builder));
347 CHECK_EQ("1e-2", builder.Finalize());
348
349 builder.Reset();
350 CHECK(dc2.ToShortestSingle(1.0f, &builder));
351 CHECK_EQ("1", builder.Finalize());
352
353 builder.Reset();
354 CHECK(dc2.ToShortestSingle(10.0f, &builder));
355 CHECK_EQ("1e1", builder.Finalize());
356
357 builder.Reset();
358 CHECK(dc2.ToShortestSingle(-0.0f, &builder));
359 CHECK_EQ("-0", builder.Finalize());
360
361 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
362 DoubleToStringConverter::EMIT_TRAILING_ZERO_AFTER_POINT;
363 DoubleToStringConverter dc3(flags, NULL, NULL, 'E', -5, 5, 0, 0);
364
365 builder.Reset();
366 CHECK(dc3.ToShortestSingle(0.1f, &builder));
367 CHECK_EQ("0.1", builder.Finalize());
368
369 builder.Reset();
370 CHECK(dc3.ToShortestSingle(1.0f, &builder));
371 CHECK_EQ("1.0", builder.Finalize());
372
373 builder.Reset();
374 CHECK(dc3.ToShortestSingle(10000.0f, &builder));
375 CHECK_EQ("10000.0", builder.Finalize());
376
377 builder.Reset();
378 CHECK(dc3.ToShortestSingle(100000.0f, &builder));
379 CHECK_EQ("1E5", builder.Finalize());
380
381 // Test the examples in the comments of ToShortestSingle.
382 flags = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
383 DoubleToStringConverter dc4(flags, NULL, NULL, 'e', -6, 21, 0, 0);
384
385 builder.Reset();
386 CHECK(dc4.ToShortestSingle(0.000001f, &builder));
387 CHECK_EQ("0.000001", builder.Finalize());
388
389 builder.Reset();
390 CHECK(dc4.ToShortestSingle(0.0000001f, &builder));
391 CHECK_EQ("1e-7", builder.Finalize());
392
393 builder.Reset();
394 CHECK(dc4.ToShortestSingle(111111111111111111111.0f, &builder));
395 CHECK_EQ("111111110000000000000", builder.Finalize());
396
397 builder.Reset();
398 CHECK(dc4.ToShortestSingle(100000000000000000000.0f, &builder));
399 CHECK_EQ("100000000000000000000", builder.Finalize());
400
401 builder.Reset();
402 CHECK(dc4.ToShortestSingle(1111111111111111111111.0f, &builder));
403 CHECK_EQ("1.11111114e+21", builder.Finalize());
404
405 // Test special value handling.
406 DoubleToStringConverter dc5(flags, NULL, NULL, 'e', 0, 0, 0, 0);
407
408 builder.Reset();
409 CHECK(!dc5.ToShortestSingle(Single::Infinity(), &builder));
410
411 builder.Reset();
412 CHECK(!dc5.ToShortestSingle(-Single::Infinity(), &builder));
413
414 builder.Reset();
415 CHECK(!dc5.ToShortestSingle(Single::NaN(), &builder));
416
417 builder.Reset();
418 CHECK(!dc5.ToShortestSingle(-Single::NaN(), &builder));
419
420 DoubleToStringConverter dc6(flags, "Infinity", "NaN", 'e', 0, 0, 0, 0);
421
422 builder.Reset();
423 CHECK(dc6.ToShortestSingle(Single::Infinity(), &builder));
424 CHECK_EQ("Infinity", builder.Finalize());
425
426 builder.Reset();
427 CHECK(dc6.ToShortestSingle(-Single::Infinity(), &builder));
428 CHECK_EQ("-Infinity", builder.Finalize());
429
430 builder.Reset();
431 CHECK(dc6.ToShortestSingle(Single::NaN(), &builder));
432 CHECK_EQ("NaN", builder.Finalize());
433
434 builder.Reset();
435 CHECK(dc6.ToShortestSingle(-Single::NaN(), &builder));
436 CHECK_EQ("NaN", builder.Finalize());
437 }
438
439
TEST(DoubleToFixed)440 TEST(DoubleToFixed) {
441 const int kBufferSize = 168;
442 char buffer[kBufferSize];
443 StringBuilder builder(buffer, kBufferSize);
444 int flags = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN |
445 DoubleToStringConverter::UNIQUE_ZERO;
446 DoubleToStringConverter dc(flags, "Infinity", "NaN", 'e',
447 0, 0, 0, 0); // Padding zeroes.
448
449 CHECK(dc.ToFixed(0.0, 0, &builder));
450 CHECK_EQ("0", builder.Finalize());
451
452 builder.Reset();
453 CHECK(dc.ToFixed(-0.0, 0, &builder));
454 CHECK_EQ("0", builder.Finalize());
455
456 builder.Reset();
457 CHECK(dc.ToFixed(-0.0, 1, &builder));
458 CHECK_EQ("0.0", builder.Finalize());
459
460 builder.Reset();
461 CHECK(dc.ToFixed(-0.0, 1, &builder));
462 CHECK_EQ("0.0", builder.Finalize());
463
464 DOUBLE_CONVERSION_ASSERT(DoubleToStringConverter::kMaxFixedDigitsBeforePoint == 60);
465 DOUBLE_CONVERSION_ASSERT(DoubleToStringConverter::kMaxFixedDigitsAfterPoint == 100);
466
467 // Most of the 100 digit tests were copied from
468 // https://searchfox.org/mozilla-central/source/js/src/tests/non262/Number/toFixed-values.js.
469
470 builder.Reset();
471 CHECK(dc.ToFixed(
472 0.0, DoubleToStringConverter::kMaxFixedDigitsAfterPoint, &builder));
473 CHECK_EQ("0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
474 builder.Finalize());
475
476 builder.Reset();
477 CHECK(dc.ToFixed(
478 9e59, DoubleToStringConverter::kMaxFixedDigitsAfterPoint, &builder));
479 CHECK_EQ("899999999999999918767229449717619953810131273674690656206848."
480 "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
481 builder.Finalize());
482
483 builder.Reset();
484 CHECK(dc.ToFixed(
485 -9e59, DoubleToStringConverter::kMaxFixedDigitsAfterPoint, &builder));
486 CHECK_EQ("-899999999999999918767229449717619953810131273674690656206848."
487 "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
488 builder.Finalize());
489
490 builder.Reset();
491 CHECK(dc.ToFixed(
492 1e-100, DoubleToStringConverter::kMaxFixedDigitsAfterPoint, &builder));
493 CHECK_EQ("0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001",
494 builder.Finalize());
495
496 builder.Reset();
497 CHECK(dc.ToFixed(0.3000000000000000444089209850062616169452667236328125,
498 DoubleToStringConverter::kMaxFixedDigitsAfterPoint,
499 &builder));
500 CHECK_EQ("0.3000000000000000444089209850062616169452667236328125000000000000000000000000000000000000000000000000",
501 builder.Finalize());
502
503 builder.Reset();
504 CHECK(dc.ToFixed(1.5e-100,
505 DoubleToStringConverter::kMaxFixedDigitsAfterPoint,
506 &builder));
507 CHECK_EQ("0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002",
508 builder.Finalize());
509
510 builder.Reset();
511 CHECK(dc.ToFixed(1.15e-99, // In reality: 1.14999999999999992147301128036734...
512 DoubleToStringConverter::kMaxFixedDigitsAfterPoint,
513 &builder));
514 CHECK_EQ("0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011",
515 builder.Finalize());
516
517 builder.Reset();
518 CHECK(dc.ToFixed(3.141592653589793,
519 DoubleToStringConverter::kMaxFixedDigitsAfterPoint,
520 &builder));
521 CHECK_EQ("3.1415926535897931159979634685441851615905761718750000000000000000000000000000000000000000000000000000",
522 builder.Finalize());
523
524 builder.Reset();
525 CHECK(dc.ToFixed(1.0,
526 DoubleToStringConverter::kMaxFixedDigitsAfterPoint,
527 &builder));
528 CHECK_EQ("1.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
529 builder.Finalize());
530
531 builder.Reset();
532 CHECK(dc.ToFixed(-123456.78,
533 DoubleToStringConverter::kMaxFixedDigitsAfterPoint,
534 &builder));
535 CHECK_EQ("-123456.7799999999988358467817306518554687500000000000000000000000000000000000000000000000000000000000000000",
536 builder.Finalize());
537
538 builder.Reset();
539 CHECK(dc.ToFixed(123456.78,
540 DoubleToStringConverter::kMaxFixedDigitsAfterPoint,
541 &builder));
542 CHECK_EQ("123456.7799999999988358467817306518554687500000000000000000000000000000000000000000000000000000000000000000",
543 builder.Finalize());
544
545 builder.Reset();
546 CHECK(dc.ToFixed(100000000000000000000.0,
547 DoubleToStringConverter::kMaxFixedDigitsAfterPoint,
548 &builder));
549 CHECK_EQ("100000000000000000000.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
550 builder.Finalize());
551
552 builder.Reset();
553 CHECK(dc.ToFixed(-100000000000000000000.0,
554 DoubleToStringConverter::kMaxFixedDigitsAfterPoint,
555 &builder));
556 CHECK_EQ("-100000000000000000000.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
557 builder.Finalize());
558
559 builder.Reset();
560 CHECK(!dc.ToFixed(
561 1e60, DoubleToStringConverter::kMaxFixedDigitsAfterPoint, &builder));
562 CHECK_EQ(0, builder.position());
563
564 builder.Reset();
565 CHECK(!dc.ToFixed(
566 9e59, DoubleToStringConverter::kMaxFixedDigitsAfterPoint + 1, &builder));
567 CHECK_EQ(0, builder.position());
568
569 builder.Reset();
570 CHECK(dc.ToFixed(3.0, 0, &builder));
571 CHECK_EQ("3", builder.Finalize());
572
573 builder.Reset();
574 CHECK(dc.ToFixed(3.23, 1, &builder));
575 CHECK_EQ("3.2", builder.Finalize());
576
577 builder.Reset();
578 CHECK(dc.ToFixed(3.23, 3, &builder));
579 CHECK_EQ("3.230", builder.Finalize());
580
581 builder.Reset();
582 CHECK(dc.ToFixed(0.0323, 2, &builder));
583 CHECK_EQ("0.03", builder.Finalize());
584
585 builder.Reset();
586 CHECK(dc.ToFixed(0.0373, 2, &builder));
587 CHECK_EQ("0.04", builder.Finalize());
588
589 builder.Reset();
590 CHECK(dc.ToFixed(0.0000373, 2, &builder));
591 CHECK_EQ("0.00", builder.Finalize());
592
593 builder.Reset();
594 CHECK(dc.ToFixed(1.5, 0, &builder));
595 CHECK_EQ("2", builder.Finalize());
596
597 builder.Reset();
598 CHECK(dc.ToFixed(2.5, 0, &builder));
599 CHECK_EQ("3", builder.Finalize());
600
601 builder.Reset();
602 CHECK(dc.ToFixed(3.5, 0, &builder));
603 CHECK_EQ("4", builder.Finalize());
604
605 builder.Reset();
606 CHECK(dc.ToFixed(0.15, 1, &builder));
607 CHECK_EQ("0.1", builder.Finalize());
608
609 builder.Reset();
610 CHECK(dc.ToFixed(0.25, 1, &builder));
611 CHECK_EQ("0.3", builder.Finalize());
612
613 builder.Reset();
614 CHECK(dc.ToFixed(0.35, 1, &builder));
615 CHECK_EQ("0.3", builder.Finalize());
616
617 builder.Reset();
618 CHECK(dc.ToFixed(0.45, 1, &builder));
619 CHECK_EQ("0.5", builder.Finalize());
620
621 builder.Reset();
622 CHECK(dc.ToFixed(0.55, 1, &builder));
623 CHECK_EQ("0.6", builder.Finalize());
624
625 // Test positive/negative zeroes.
626 int flags2 = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
627 DoubleToStringConverter dc2(flags2, "Infinity", "NaN", 'e',
628 0, 0, 0, 0); // Padding zeroes.
629 builder.Reset();
630 CHECK(dc2.ToFixed(0.0, 1, &builder));
631 CHECK_EQ("0.0", builder.Finalize());
632
633 builder.Reset();
634 CHECK(dc2.ToFixed(-0.0, 1, &builder));
635 CHECK_EQ("-0.0", builder.Finalize());
636
637 // Verify the trailing dot is emitted.
638 int flags3 = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN |
639 DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT;
640 DoubleToStringConverter dc3(flags3, "Infinity", "NaN", 'e',
641 0, 0, 0, 0); // Padding zeroes.
642 builder.Reset();
643 CHECK(dc3.ToFixed(0.0, 0, &builder));
644 CHECK_EQ("0.", builder.Finalize());
645
646 builder.Reset();
647 CHECK(dc3.ToFixed(-0.0, 0, &builder));
648 CHECK_EQ("-0.", builder.Finalize());
649
650 builder.Reset();
651 CHECK(dc3.ToFixed(1.0, 0, &builder));
652 CHECK_EQ("1.", builder.Finalize());
653
654 builder.Reset();
655 CHECK(dc3.ToFixed(-1.0, 0, &builder));
656 CHECK_EQ("-1.", builder.Finalize());
657
658 // Verify no trailing zero is emitted, even if the configuration is set.
659 // The given parameter takes precedence.
660 int flags4 = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN |
661 DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
662 DoubleToStringConverter::EMIT_TRAILING_ZERO_AFTER_POINT;
663 DoubleToStringConverter dc4(flags4, "Infinity", "NaN", 'e',
664 0, 0, 0, 0); // Padding zeroes.
665 builder.Reset();
666 CHECK(dc4.ToFixed(0.0, 0, &builder));
667 CHECK_EQ("0.0", builder.Finalize());
668
669 builder.Reset();
670 CHECK(dc4.ToFixed(-0.0, 0, &builder));
671 CHECK_EQ("-0.0", builder.Finalize());
672
673 builder.Reset();
674 CHECK(dc4.ToFixed(1.0, 0, &builder));
675 CHECK_EQ("1.0", builder.Finalize());
676
677 builder.Reset();
678 CHECK(dc4.ToFixed(-1.0, 0, &builder));
679 CHECK_EQ("-1.0", builder.Finalize());
680
681 // Test the examples in the comments of ToFixed.
682 flags = DoubleToStringConverter::NO_FLAGS;
683 DoubleToStringConverter dc5(flags, NULL, NULL, 'e', 0, 0, 0, 0);
684
685 builder.Reset();
686 CHECK(dc5.ToFixed(3.12, 1, &builder));
687 CHECK_EQ("3.1", builder.Finalize());
688
689 builder.Reset();
690 CHECK(dc5.ToFixed(3.1415, 3, &builder));
691 CHECK_EQ("3.142", builder.Finalize());
692
693 builder.Reset();
694 CHECK(dc5.ToFixed(1234.56789, 4, &builder));
695 CHECK_EQ("1234.5679", builder.Finalize());
696
697 builder.Reset();
698 CHECK(dc5.ToFixed(1.23, 5, &builder));
699 CHECK_EQ("1.23000", builder.Finalize());
700
701 builder.Reset();
702 CHECK(dc5.ToFixed(0.1, 4, &builder));
703 CHECK_EQ("0.1000", builder.Finalize());
704
705 builder.Reset();
706 CHECK(dc5.ToFixed(1e30, 2, &builder));
707 CHECK_EQ("1000000000000000019884624838656.00", builder.Finalize());
708
709 builder.Reset();
710 CHECK(dc5.ToFixed(0.1, 30, &builder));
711 CHECK_EQ("0.100000000000000005551115123126", builder.Finalize());
712
713 builder.Reset();
714 CHECK(dc5.ToFixed(0.1, 100, &builder));
715 CHECK_EQ("0.1000000000000000055511151231257827021181583404541015625000000000000000000000000000000000000000000000", builder.Finalize());
716
717 builder.Reset();
718 CHECK(dc5.ToFixed(0.1, 17, &builder));
719 CHECK_EQ("0.10000000000000001", builder.Finalize());
720
721 builder.Reset();
722 CHECK(dc5.ToFixed(123.45, 0, &builder));
723 CHECK_EQ("123", builder.Finalize());
724
725 builder.Reset();
726 CHECK(dc5.ToFixed(0.678, 0, &builder));
727 CHECK_EQ("1", builder.Finalize());
728
729 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT;
730 DoubleToStringConverter dc6(flags, NULL, NULL, 'e', 0, 0, 0, 0);
731
732 builder.Reset();
733 CHECK(dc6.ToFixed(123.45, 0, &builder));
734 CHECK_EQ("123.", builder.Finalize());
735
736 builder.Reset();
737 CHECK(dc6.ToFixed(0.678, 0, &builder));
738 CHECK_EQ("1.", builder.Finalize());
739
740 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
741 DoubleToStringConverter::EMIT_TRAILING_ZERO_AFTER_POINT;
742 DoubleToStringConverter dc7(flags, NULL, NULL, 'e', 0, 0, 0, 0);
743
744 builder.Reset();
745 CHECK(dc7.ToFixed(123.45, 0, &builder));
746 CHECK_EQ("123.0", builder.Finalize());
747
748 builder.Reset();
749 CHECK(dc7.ToFixed(0.678, 0, &builder));
750 CHECK_EQ("1.0", builder.Finalize());
751
752 // Test special value handling.
753 DoubleToStringConverter dc8(flags, NULL, NULL, 'e', 0, 0, 0, 0);
754
755 builder.Reset();
756 CHECK(!dc8.ToFixed(Double::Infinity(), 1, &builder));
757
758 builder.Reset();
759 CHECK(!dc8.ToFixed(-Double::Infinity(), 1, &builder));
760
761 builder.Reset();
762 CHECK(!dc8.ToFixed(Double::NaN(), 1, &builder));
763
764 builder.Reset();
765 CHECK(!dc8.ToFixed(-Double::NaN(), 1, &builder));
766
767 DoubleToStringConverter dc9(flags, "Infinity", "NaN", 'e', 0, 0, 0, 0);
768
769 builder.Reset();
770 CHECK(dc9.ToFixed(Double::Infinity(), 1, &builder));
771 CHECK_EQ("Infinity", builder.Finalize());
772
773 builder.Reset();
774 CHECK(dc9.ToFixed(-Double::Infinity(), 1, &builder));
775 CHECK_EQ("-Infinity", builder.Finalize());
776
777 builder.Reset();
778 CHECK(dc9.ToFixed(Double::NaN(), 1, &builder));
779 CHECK_EQ("NaN", builder.Finalize());
780
781 builder.Reset();
782 CHECK(dc9.ToFixed(-Double::NaN(), 1, &builder));
783 CHECK_EQ("NaN", builder.Finalize());
784 }
785
786
TEST(DoubleToExponential)787 TEST(DoubleToExponential) {
788 const int kBufferSize = 256;
789 char buffer[kBufferSize];
790 int flags = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN |
791 DoubleToStringConverter::UNIQUE_ZERO;
792 StringBuilder builder(buffer, kBufferSize);
793 DoubleToStringConverter dc(flags, "Infinity", "NaN", 'e', 0, 0, 0, 0);
794
795 builder.Reset();
796 CHECK(dc.ToExponential(0.0, 5, &builder));
797 CHECK_EQ("0.00000e+0", builder.Finalize());
798
799 builder.Reset();
800 CHECK(dc.ToExponential(0.0, 0, &builder));
801 CHECK_EQ("0e+0", builder.Finalize());
802
803 builder.Reset();
804 CHECK(dc.ToExponential(0.0, 1, &builder));
805 CHECK_EQ("0.0e+0", builder.Finalize());
806
807 builder.Reset();
808 CHECK(dc.ToExponential(0.123456, 5, &builder));
809 CHECK_EQ("1.23456e-1", builder.Finalize());
810
811 builder.Reset();
812 CHECK(dc.ToExponential(1.2, 1, &builder));
813 CHECK_EQ("1.2e+0", builder.Finalize());
814
815 builder.Reset();
816 CHECK(dc.ToExponential(-0.0, 1, &builder));
817 CHECK_EQ("0.0e+0", builder.Finalize());
818
819 builder.Reset();
820 CHECK(dc.ToExponential(0.0, 2, &builder));
821 CHECK_EQ("0.00e+0", builder.Finalize());
822
823 builder.Reset();
824 CHECK(dc.ToExponential(-0.0, 2, &builder));
825 CHECK_EQ("0.00e+0", builder.Finalize());
826
827 DOUBLE_CONVERSION_ASSERT(DoubleToStringConverter::kMaxExponentialDigits == 120);
828 builder.Reset();
829 CHECK(dc.ToExponential(
830 0.0, DoubleToStringConverter::kMaxExponentialDigits, &builder));
831 CHECK_EQ("0.00000000000000000000000000000000000000000000000000000000000"
832 "0000000000000000000000000000000000000000000000000000000000000e+0",
833 builder.Finalize());
834
835 builder.Reset();
836 CHECK(dc.ToExponential(
837 9e59, DoubleToStringConverter::kMaxExponentialDigits, &builder));
838 CHECK_EQ("8.99999999999999918767229449717619953810131273674690656206848"
839 "0000000000000000000000000000000000000000000000000000000000000e+59",
840 builder.Finalize());
841
842 builder.Reset();
843 CHECK(dc.ToExponential(
844 -9e59, DoubleToStringConverter::kMaxExponentialDigits, &builder));
845 CHECK_EQ("-8.99999999999999918767229449717619953810131273674690656206848"
846 "0000000000000000000000000000000000000000000000000000000000000e+59",
847 builder.Finalize());
848
849 const double max_double = 1.7976931348623157e308;
850 builder.Reset();
851 CHECK(dc.ToExponential(
852 max_double, DoubleToStringConverter::kMaxExponentialDigits, &builder));
853 CHECK_EQ("1.79769313486231570814527423731704356798070567525844996598917"
854 "4768031572607800285387605895586327668781715404589535143824642e+308",
855 builder.Finalize());
856
857 builder.Reset();
858 CHECK(dc.ToExponential(0.000001, 2, &builder));
859 CHECK_EQ("1.00e-6", builder.Finalize());
860
861 builder.Reset();
862 CHECK(dc.ToExponential(0.0000001, 2, &builder));
863 CHECK_EQ("1.00e-7", builder.Finalize());
864
865 // Test the examples in the comments of ToExponential.
866 flags = DoubleToStringConverter::NO_FLAGS;
867 DoubleToStringConverter dc2(flags, "Infinity", "NaN", 'e', 0, 0, 0, 0);
868
869 builder.Reset();
870 CHECK(dc2.ToExponential(3.12, 1, &builder));
871 CHECK_EQ("3.1e0", builder.Finalize());
872
873 builder.Reset();
874 CHECK(dc2.ToExponential(5.0, 3, &builder));
875 CHECK_EQ("5.000e0", builder.Finalize());
876
877 builder.Reset();
878 CHECK(dc2.ToExponential(0.001, 2, &builder));
879 CHECK_EQ("1.00e-3", builder.Finalize());
880
881 builder.Reset();
882 CHECK(dc2.ToExponential(3.1415, -1, &builder));
883 CHECK_EQ("3.1415e0", builder.Finalize());
884
885 builder.Reset();
886 CHECK(dc2.ToExponential(3.1415, 4, &builder));
887 CHECK_EQ("3.1415e0", builder.Finalize());
888
889 builder.Reset();
890 CHECK(dc2.ToExponential(3.1415, 3, &builder));
891 CHECK_EQ("3.142e0", builder.Finalize());
892
893 builder.Reset();
894 CHECK(dc2.ToExponential(123456789000000, 3, &builder));
895 CHECK_EQ("1.235e14", builder.Finalize());
896
897 builder.Reset();
898 CHECK(dc2.ToExponential(1000000000000000019884624838656.0, -1, &builder));
899 CHECK_EQ("1e30", builder.Finalize());
900
901 builder.Reset();
902 CHECK(dc2.ToExponential(1000000000000000019884624838656.0, 32, &builder));
903 CHECK_EQ("1.00000000000000001988462483865600e30", builder.Finalize());
904
905 builder.Reset();
906 CHECK(dc2.ToExponential(1234, 0, &builder));
907 CHECK_EQ("1e3", builder.Finalize());
908
909 // Test special value handling.
910 DoubleToStringConverter dc3(flags, NULL, NULL, 'e', 0, 0, 0, 0);
911
912 builder.Reset();
913 CHECK(!dc3.ToExponential(Double::Infinity(), 1, &builder));
914
915 builder.Reset();
916 CHECK(!dc3.ToExponential(-Double::Infinity(), 1, &builder));
917
918 builder.Reset();
919 CHECK(!dc3.ToExponential(Double::NaN(), 1, &builder));
920
921 builder.Reset();
922 CHECK(!dc3.ToExponential(-Double::NaN(), 1, &builder));
923
924 DoubleToStringConverter dc4(flags, "Infinity", "NaN", 'e', 0, 0, 0, 0);
925
926 builder.Reset();
927 CHECK(dc4.ToExponential(Double::Infinity(), 1, &builder));
928 CHECK_EQ("Infinity", builder.Finalize());
929
930 builder.Reset();
931 CHECK(dc4.ToExponential(-Double::Infinity(), 1, &builder));
932 CHECK_EQ("-Infinity", builder.Finalize());
933
934 builder.Reset();
935 CHECK(dc4.ToExponential(Double::NaN(), 1, &builder));
936 CHECK_EQ("NaN", builder.Finalize());
937
938 builder.Reset();
939 CHECK(dc4.ToExponential(-Double::NaN(), 1, &builder));
940 CHECK_EQ("NaN", builder.Finalize());
941
942 // Test min_exponent_width
943 DoubleToStringConverter dc5(flags, NULL, NULL, 'e', 0, 0, 0, 0, 2);
944
945 builder.Reset();
946 CHECK(dc5.ToExponential(11111111111.0, 6, &builder));
947 CHECK_EQ("1.111111e10", builder.Finalize());
948
949 builder.Reset();
950 CHECK(dc5.ToExponential(1111111111.0, 6, &builder));
951 CHECK_EQ("1.111111e09", builder.Finalize());
952
953 builder.Reset();
954 CHECK(dc5.ToExponential(1111111.0, 6, &builder));
955 CHECK_EQ("1.111111e06", builder.Finalize());
956
957 builder.Reset();
958 CHECK(dc5.ToExponential(10000000000.0, 6, &builder));
959 CHECK_EQ("1.000000e10", builder.Finalize());
960
961 builder.Reset();
962 CHECK(dc5.ToExponential(1000000000.0, 6, &builder));
963 CHECK_EQ("1.000000e09", builder.Finalize());
964
965 builder.Reset();
966 CHECK(dc5.ToExponential(1.0, 6, &builder));
967 CHECK_EQ("1.000000e00", builder.Finalize());
968 }
969
970
TEST(DoubleToPrecision)971 TEST(DoubleToPrecision) {
972 const int kBufferSize = 256;
973 char buffer[kBufferSize];
974 int flags = DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN |
975 DoubleToStringConverter::UNIQUE_ZERO;
976 StringBuilder builder(buffer, kBufferSize);
977 DoubleToStringConverter dc(flags, "Infinity", "NaN", 'e',
978 0, 0, // Padding zeroes for shortest mode.
979 6, 0); // Padding zeroes for precision mode.
980
981 DOUBLE_CONVERSION_ASSERT(DoubleToStringConverter::kMinPrecisionDigits == 1);
982 CHECK(dc.ToPrecision(0.0, 1, &builder));
983 CHECK_EQ("0", builder.Finalize());
984
985 builder.Reset();
986 CHECK(dc.ToPrecision(-0.0, 1, &builder));
987 CHECK_EQ("0", builder.Finalize());
988
989 builder.Reset();
990 CHECK(dc.ToPrecision(0.0, 2, &builder));
991 CHECK_EQ("0.0", builder.Finalize());
992
993 builder.Reset();
994 CHECK(dc.ToPrecision(-0.0, 2, &builder));
995 CHECK_EQ("0.0", builder.Finalize());
996
997 DOUBLE_CONVERSION_ASSERT(DoubleToStringConverter::kMaxPrecisionDigits == 120);
998 builder.Reset();
999 CHECK(dc.ToPrecision(
1000 0.0, DoubleToStringConverter::kMaxPrecisionDigits, &builder));
1001 CHECK_EQ("0.00000000000000000000000000000000000000000000000000000000000"
1002 "000000000000000000000000000000000000000000000000000000000000",
1003 builder.Finalize());
1004
1005 builder.Reset();
1006 CHECK(dc.ToPrecision(
1007 9e59, DoubleToStringConverter::kMaxPrecisionDigits, &builder));
1008 CHECK_EQ("899999999999999918767229449717619953810131273674690656206848."
1009 "000000000000000000000000000000000000000000000000000000000000",
1010 builder.Finalize());
1011
1012 builder.Reset();
1013 CHECK(dc.ToPrecision(
1014 -9e59, DoubleToStringConverter::kMaxPrecisionDigits, &builder));
1015 CHECK_EQ("-899999999999999918767229449717619953810131273674690656206848."
1016 "000000000000000000000000000000000000000000000000000000000000",
1017 builder.Finalize());
1018
1019 const double max_double = 1.7976931348623157e308;
1020 builder.Reset();
1021 CHECK(dc.ToPrecision(
1022 max_double, DoubleToStringConverter::kMaxPrecisionDigits, &builder));
1023 CHECK_EQ("1.79769313486231570814527423731704356798070567525844996598917"
1024 "476803157260780028538760589558632766878171540458953514382464e+308",
1025 builder.Finalize());
1026
1027 builder.Reset();
1028 CHECK(dc.ToPrecision(0.000001, 2, &builder));
1029 CHECK_EQ("0.0000010", builder.Finalize());
1030
1031 builder.Reset();
1032 CHECK(dc.ToPrecision(0.0000001, 2, &builder));
1033 CHECK_EQ("1.0e-7", builder.Finalize());
1034
1035 flags = DoubleToStringConverter::NO_FLAGS;
1036 DoubleToStringConverter dc2(flags, NULL, NULL, 'e', 0, 0, 0, 1);
1037 builder.Reset();
1038 CHECK(dc2.ToPrecision(230.0, 2, &builder));
1039 CHECK_EQ("230", builder.Finalize());
1040
1041 builder.Reset();
1042 CHECK(dc2.ToPrecision(23.0, 2, &builder));
1043 CHECK_EQ("23", builder.Finalize());
1044
1045 builder.Reset();
1046 CHECK(dc2.ToPrecision(2.30, 2, &builder));
1047 CHECK_EQ("2.3", builder.Finalize());
1048
1049 builder.Reset();
1050 CHECK(dc2.ToPrecision(2300.0, 2, &builder));
1051 CHECK_EQ("2.3e3", builder.Finalize());
1052
1053 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT;
1054 DoubleToStringConverter dc3(flags, NULL, NULL, 'e', 0, 0, 0, 1);
1055 builder.Reset();
1056 CHECK(dc3.ToPrecision(230.0, 2, &builder));
1057 CHECK_EQ("230.", builder.Finalize());
1058
1059 builder.Reset();
1060 CHECK(dc3.ToPrecision(23.0, 2, &builder));
1061 CHECK_EQ("23.", builder.Finalize());
1062
1063 builder.Reset();
1064 CHECK(dc3.ToPrecision(2.30, 2, &builder));
1065 CHECK_EQ("2.3", builder.Finalize());
1066
1067 builder.Reset();
1068 CHECK(dc3.ToPrecision(2300.0, 2, &builder));
1069 CHECK_EQ("2.3e3", builder.Finalize());
1070
1071 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
1072 DoubleToStringConverter::EMIT_TRAILING_ZERO_AFTER_POINT;
1073 DoubleToStringConverter dc4(flags, NULL, NULL, 'e', 0, 0, 0, 1);
1074 builder.Reset();
1075 CHECK(dc4.ToPrecision(230.0, 2, &builder));
1076 CHECK_EQ("2.3e2", builder.Finalize());
1077
1078 builder.Reset();
1079 CHECK(dc4.ToPrecision(23.0, 2, &builder));
1080 CHECK_EQ("23.0", builder.Finalize());
1081
1082 builder.Reset();
1083 CHECK(dc4.ToPrecision(2.30, 2, &builder));
1084 CHECK_EQ("2.3", builder.Finalize());
1085
1086 builder.Reset();
1087 CHECK(dc4.ToPrecision(2300.0, 2, &builder));
1088 CHECK_EQ("2.3e3", builder.Finalize());
1089
1090 // Test the examples in the comments of ToPrecision.
1091 flags = DoubleToStringConverter::NO_FLAGS;
1092 DoubleToStringConverter dc5(flags, "Infinity", "NaN", 'e', 0, 0, 6, 1);
1093 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT;
1094 DoubleToStringConverter dc6(flags, "Infinity", "NaN", 'e', 0, 0, 6, 1);
1095 flags = DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
1096 DoubleToStringConverter::EMIT_TRAILING_ZERO_AFTER_POINT;
1097 DoubleToStringConverter dc7(flags, "Infinity", "NaN", 'e', 0, 0, 6, 1);
1098
1099 builder.Reset();
1100 CHECK(dc5.ToPrecision(0.0000012345, 2, &builder));
1101 CHECK_EQ("0.0000012", builder.Finalize());
1102
1103 builder.Reset();
1104 CHECK(dc5.ToPrecision(0.00000012345, 2, &builder));
1105 CHECK_EQ("1.2e-7", builder.Finalize());
1106
1107 builder.Reset();
1108 CHECK(dc5.ToPrecision(230.0, 2, &builder));
1109 CHECK_EQ("230", builder.Finalize());
1110
1111 builder.Reset();
1112 CHECK(dc6.ToPrecision(230.0, 2, &builder));
1113 CHECK_EQ("230.", builder.Finalize());
1114
1115 builder.Reset();
1116 CHECK(dc7.ToPrecision(230.0, 2, &builder));
1117 CHECK_EQ("2.3e2", builder.Finalize());
1118
1119 flags = DoubleToStringConverter::NO_FLAGS;
1120 DoubleToStringConverter dc8(flags, NULL, NULL, 'e', 0, 0, 6, 3);
1121
1122 builder.Reset();
1123 CHECK(dc8.ToPrecision(123450.0, 6, &builder));
1124 CHECK_EQ("123450", builder.Finalize());
1125
1126 builder.Reset();
1127 CHECK(dc8.ToPrecision(123450.0, 5, &builder));
1128 CHECK_EQ("123450", builder.Finalize());
1129
1130 builder.Reset();
1131 CHECK(dc8.ToPrecision(123450.0, 4, &builder));
1132 CHECK_EQ("123500", builder.Finalize());
1133
1134 builder.Reset();
1135 CHECK(dc8.ToPrecision(123450.0, 3, &builder));
1136 CHECK_EQ("123000", builder.Finalize());
1137
1138 builder.Reset();
1139 CHECK(dc8.ToPrecision(123450.0, 2, &builder));
1140 CHECK_EQ("1.2e5", builder.Finalize());
1141
1142 // Test special value handling.
1143 builder.Reset();
1144 CHECK(!dc8.ToPrecision(Double::Infinity(), 1, &builder));
1145
1146 builder.Reset();
1147 CHECK(!dc8.ToPrecision(-Double::Infinity(), 1, &builder));
1148
1149 builder.Reset();
1150 CHECK(!dc8.ToPrecision(Double::NaN(), 1, &builder));
1151
1152 builder.Reset();
1153 CHECK(!dc8.ToPrecision(-Double::NaN(), 1, &builder));
1154
1155 builder.Reset();
1156 CHECK(dc7.ToPrecision(Double::Infinity(), 1, &builder));
1157 CHECK_EQ("Infinity", builder.Finalize());
1158
1159 builder.Reset();
1160 CHECK(dc7.ToPrecision(-Double::Infinity(), 1, &builder));
1161 CHECK_EQ("-Infinity", builder.Finalize());
1162
1163 builder.Reset();
1164 CHECK(dc7.ToPrecision(Double::NaN(), 1, &builder));
1165 CHECK_EQ("NaN", builder.Finalize());
1166
1167 builder.Reset();
1168 CHECK(dc7.ToPrecision(-Double::NaN(), 1, &builder));
1169 CHECK_EQ("NaN", builder.Finalize());
1170
1171 // Test NO_TRAILING_ZERO and its interaction with other flags.
1172 flags = DoubleToStringConverter::NO_TRAILING_ZERO;
1173 DoubleToStringConverter dc9(flags, "Infinity", "NaN", 'e', 0, 0, 6, 1);
1174 flags = DoubleToStringConverter::NO_TRAILING_ZERO |
1175 DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT;
1176 DoubleToStringConverter dc10(flags, "Infinity", "NaN", 'e', 0, 0, 6, 1);
1177 flags = DoubleToStringConverter::NO_TRAILING_ZERO |
1178 DoubleToStringConverter::EMIT_TRAILING_DECIMAL_POINT |
1179 DoubleToStringConverter::EMIT_TRAILING_ZERO_AFTER_POINT;
1180 DoubleToStringConverter dc11(flags, "Infinity", "NaN", 'e', 0, 0, 6, 1);
1181
1182 builder.Reset();
1183 CHECK(dc9.ToPrecision(230.001, 5, &builder));
1184 CHECK_EQ("230", builder.Finalize());
1185
1186 builder.Reset();
1187 CHECK(dc10.ToPrecision(230.001, 5, &builder));
1188 CHECK_EQ("230.", builder.Finalize());
1189
1190 builder.Reset();
1191 CHECK(dc11.ToPrecision(230.001, 5, &builder));
1192 CHECK_EQ("230.0", builder.Finalize());
1193
1194 builder.Reset();
1195 CHECK(dc5.ToPrecision(230.001, 5, &builder));
1196 CHECK_EQ("230.00", builder.Finalize());
1197
1198 builder.Reset();
1199 CHECK(dc9.ToPrecision(2300010, 5, &builder));
1200 CHECK_EQ("2.3e6", builder.Finalize());
1201
1202 builder.Reset();
1203 CHECK(dc10.ToPrecision(2300010, 5, &builder));
1204 CHECK_EQ("2.3e6", builder.Finalize());
1205
1206 builder.Reset();
1207 CHECK(dc11.ToPrecision(2300010, 5, &builder));
1208 CHECK_EQ("2.3e6", builder.Finalize());
1209
1210 builder.Reset();
1211 CHECK(dc5.ToPrecision(2300010, 5, &builder));
1212 CHECK_EQ("2.3000e6", builder.Finalize());
1213
1214 builder.Reset();
1215 CHECK(dc9.ToPrecision(0.02300010, 5, &builder));
1216 CHECK_EQ("0.023", builder.Finalize());
1217
1218 builder.Reset();
1219 CHECK(dc10.ToPrecision(0.02300010, 5, &builder));
1220 CHECK_EQ("0.023", builder.Finalize());
1221
1222 builder.Reset();
1223 CHECK(dc11.ToPrecision(0.02300010, 5, &builder));
1224 CHECK_EQ("0.023", builder.Finalize());
1225
1226 builder.Reset();
1227 CHECK(dc5.ToPrecision(0.02300010, 5, &builder));
1228 CHECK_EQ("0.023000", builder.Finalize());
1229
1230 builder.Reset();
1231 CHECK(dc9.ToPrecision(2000010, 5, &builder));
1232 CHECK_EQ("2e6", builder.Finalize());
1233
1234 builder.Reset();
1235 CHECK(dc10.ToPrecision(2000010, 5, &builder));
1236 CHECK_EQ("2e6", builder.Finalize());
1237
1238 builder.Reset();
1239 CHECK(dc11.ToPrecision(2000010, 5, &builder));
1240 CHECK_EQ("2e6", builder.Finalize());
1241
1242 builder.Reset();
1243 CHECK(dc5.ToPrecision(2000010, 5, &builder));
1244 CHECK_EQ("2.0000e6", builder.Finalize());
1245
1246 // Test that rounding up still works with NO_TRAILING_ZERO
1247 builder.Reset();
1248 CHECK(dc9.ToPrecision(2000080, 5, &builder));
1249 CHECK_EQ("2.0001e6", builder.Finalize());
1250
1251 builder.Reset();
1252 CHECK(dc10.ToPrecision(2000080, 5, &builder));
1253 CHECK_EQ("2.0001e6", builder.Finalize());
1254
1255 builder.Reset();
1256 CHECK(dc11.ToPrecision(2000080, 5, &builder));
1257 CHECK_EQ("2.0001e6", builder.Finalize());
1258
1259 builder.Reset();
1260 CHECK(dc5.ToPrecision(2000080, 5, &builder));
1261 CHECK_EQ("2.0001e6", builder.Finalize());
1262 }
1263
1264
TEST(DoubleToStringJavaScript)1265 TEST(DoubleToStringJavaScript) {
1266 const int kBufferSize = 128;
1267 char buffer[kBufferSize];
1268 StringBuilder builder(buffer, kBufferSize);
1269 const DoubleToStringConverter& dc =
1270 DoubleToStringConverter::EcmaScriptConverter();
1271
1272 builder.Reset();
1273 CHECK(dc.ToShortest(Double::NaN(), &builder));
1274 CHECK_EQ("NaN", builder.Finalize());
1275
1276 builder.Reset();
1277 CHECK(dc.ToShortest(Double::Infinity(), &builder));
1278 CHECK_EQ("Infinity", builder.Finalize());
1279
1280 builder.Reset();
1281 CHECK(dc.ToShortest(-Double::Infinity(), &builder));
1282 CHECK_EQ("-Infinity", builder.Finalize());
1283
1284 builder.Reset();
1285 CHECK(dc.ToShortest(0.0, &builder));
1286 CHECK_EQ("0", builder.Finalize());
1287
1288 builder.Reset();
1289 CHECK(dc.ToShortest(9.0, &builder));
1290 CHECK_EQ("9", builder.Finalize());
1291
1292 builder.Reset();
1293 CHECK(dc.ToShortest(90.0, &builder));
1294 CHECK_EQ("90", builder.Finalize());
1295
1296 builder.Reset();
1297 CHECK(dc.ToShortest(90.12, &builder));
1298 CHECK_EQ("90.12", builder.Finalize());
1299
1300 builder.Reset();
1301 CHECK(dc.ToShortest(0.1, &builder));
1302 CHECK_EQ("0.1", builder.Finalize());
1303
1304 builder.Reset();
1305 CHECK(dc.ToShortest(0.01, &builder));
1306 CHECK_EQ("0.01", builder.Finalize());
1307
1308 builder.Reset();
1309 CHECK(dc.ToShortest(0.0123, &builder));
1310 CHECK_EQ("0.0123", builder.Finalize());
1311
1312 builder.Reset();
1313 CHECK(dc.ToShortest(111111111111111111111.0, &builder));
1314 CHECK_EQ("111111111111111110000", builder.Finalize());
1315
1316 builder.Reset();
1317 CHECK(dc.ToShortest(100000000000000000000.0, &builder));
1318 CHECK_EQ("100000000000000000000", builder.Finalize());
1319
1320 builder.Reset();
1321 CHECK(dc.ToShortest(1111111111111111111111.0, &builder));
1322 CHECK_EQ("1.1111111111111111e+21", builder.Finalize());
1323
1324 builder.Reset();
1325 CHECK(dc.ToShortest(11111111111111111111111.0, &builder));
1326 CHECK_EQ("1.1111111111111111e+22", builder.Finalize());
1327
1328 builder.Reset();
1329 CHECK(dc.ToShortest(0.00001, &builder));
1330 CHECK_EQ("0.00001", builder.Finalize());
1331
1332 builder.Reset();
1333 CHECK(dc.ToShortest(0.000001, &builder));
1334 CHECK_EQ("0.000001", builder.Finalize());
1335
1336 builder.Reset();
1337 CHECK(dc.ToShortest(0.0000001, &builder));
1338 CHECK_EQ("1e-7", builder.Finalize());
1339
1340 builder.Reset();
1341 CHECK(dc.ToShortest(0.00000012, &builder));
1342 CHECK_EQ("1.2e-7", builder.Finalize());
1343
1344 builder.Reset();
1345 CHECK(dc.ToShortest(0.000000123, &builder));
1346 CHECK_EQ("1.23e-7", builder.Finalize());
1347
1348 builder.Reset();
1349 CHECK(dc.ToShortest(0.00000001, &builder));
1350 CHECK_EQ("1e-8", builder.Finalize());
1351
1352 builder.Reset();
1353 CHECK(dc.ToShortest(0.000000012, &builder));
1354 CHECK_EQ("1.2e-8", builder.Finalize());
1355
1356 builder.Reset();
1357 CHECK(dc.ToShortest(0.000000012, &builder));
1358 CHECK_EQ("1.2e-8", builder.Finalize());
1359
1360 builder.Reset();
1361 CHECK(dc.ToShortest(0.0000000123, &builder));
1362 CHECK_EQ("1.23e-8", builder.Finalize());
1363
1364 builder.Reset();
1365 CHECK(dc.ToShortest(-0.0, &builder));
1366 CHECK_EQ("0", builder.Finalize());
1367
1368 builder.Reset();
1369 CHECK(dc.ToShortest(-9.0, &builder));
1370 CHECK_EQ("-9", builder.Finalize());
1371
1372 builder.Reset();
1373 CHECK(dc.ToShortest(-90.0, &builder));
1374 CHECK_EQ("-90", builder.Finalize());
1375
1376 builder.Reset();
1377 CHECK(dc.ToShortest(-90.12, &builder));
1378 CHECK_EQ("-90.12", builder.Finalize());
1379
1380 builder.Reset();
1381 CHECK(dc.ToShortest(-0.1, &builder));
1382 CHECK_EQ("-0.1", builder.Finalize());
1383
1384 builder.Reset();
1385 CHECK(dc.ToShortest(-0.01, &builder));
1386 CHECK_EQ("-0.01", builder.Finalize());
1387
1388 builder.Reset();
1389 CHECK(dc.ToShortest(-0.0123, &builder));
1390 CHECK_EQ("-0.0123", builder.Finalize());
1391
1392 builder.Reset();
1393 CHECK(dc.ToShortest(-111111111111111111111.0, &builder));
1394 CHECK_EQ("-111111111111111110000", builder.Finalize());
1395
1396 builder.Reset();
1397 CHECK(dc.ToShortest(-1111111111111111111111.0, &builder));
1398 CHECK_EQ("-1.1111111111111111e+21", builder.Finalize());
1399
1400 builder.Reset();
1401 CHECK(dc.ToShortest(-11111111111111111111111.0, &builder));
1402 CHECK_EQ("-1.1111111111111111e+22", builder.Finalize());
1403
1404 builder.Reset();
1405 CHECK(dc.ToShortest(-0.00001, &builder));
1406 CHECK_EQ("-0.00001", builder.Finalize());
1407
1408 builder.Reset();
1409 CHECK(dc.ToShortest(-0.000001, &builder));
1410 CHECK_EQ("-0.000001", builder.Finalize());
1411
1412 builder.Reset();
1413 CHECK(dc.ToShortest(-0.0000001, &builder));
1414 CHECK_EQ("-1e-7", builder.Finalize());
1415
1416 builder.Reset();
1417 CHECK(dc.ToShortest(-0.00000012, &builder));
1418 CHECK_EQ("-1.2e-7", builder.Finalize());
1419
1420 builder.Reset();
1421 CHECK(dc.ToShortest(-0.000000123, &builder));
1422 CHECK_EQ("-1.23e-7", builder.Finalize());
1423
1424 builder.Reset();
1425 CHECK(dc.ToShortest(-0.00000001, &builder));
1426 CHECK_EQ("-1e-8", builder.Finalize());
1427
1428 builder.Reset();
1429 CHECK(dc.ToShortest(-0.000000012, &builder));
1430 CHECK_EQ("-1.2e-8", builder.Finalize());
1431
1432 builder.Reset();
1433 CHECK(dc.ToShortest(-0.000000012, &builder));
1434 CHECK_EQ("-1.2e-8", builder.Finalize());
1435
1436 builder.Reset();
1437 CHECK(dc.ToShortest(-0.0000000123, &builder));
1438 CHECK_EQ("-1.23e-8", builder.Finalize());
1439
1440 builder.Reset();
1441 CHECK(dc.ToFixed(Double::NaN(), 2, &builder));
1442 CHECK_EQ("NaN", builder.Finalize());
1443
1444 builder.Reset();
1445 CHECK(dc.ToFixed(Double::Infinity(), 2, &builder));
1446 CHECK_EQ("Infinity", builder.Finalize());
1447
1448 builder.Reset();
1449 CHECK(dc.ToFixed(-Double::Infinity(), 2, &builder));
1450 CHECK_EQ("-Infinity", builder.Finalize());
1451
1452 builder.Reset();
1453 CHECK(dc.ToFixed(-0.1, 1, &builder));
1454 CHECK_EQ("-0.1", builder.Finalize());
1455
1456 builder.Reset();
1457 CHECK(dc.ToFixed(-0.1, 2, &builder));
1458 CHECK_EQ("-0.10", builder.Finalize());
1459
1460 builder.Reset();
1461 CHECK(dc.ToFixed(-0.1, 3, &builder));
1462 CHECK_EQ("-0.100", builder.Finalize());
1463
1464 builder.Reset();
1465 CHECK(dc.ToFixed(-0.01, 2, &builder));
1466 CHECK_EQ("-0.01", builder.Finalize());
1467
1468 builder.Reset();
1469 CHECK(dc.ToFixed(-0.01, 3, &builder));
1470 CHECK_EQ("-0.010", builder.Finalize());
1471
1472 builder.Reset();
1473 CHECK(dc.ToFixed(-0.01, 4, &builder));
1474 CHECK_EQ("-0.0100", builder.Finalize());
1475
1476 builder.Reset();
1477 CHECK(dc.ToFixed(-0.001, 2, &builder));
1478 CHECK_EQ("-0.00", builder.Finalize());
1479
1480 builder.Reset();
1481 CHECK(dc.ToFixed(-0.001, 3, &builder));
1482 CHECK_EQ("-0.001", builder.Finalize());
1483
1484 builder.Reset();
1485 CHECK(dc.ToFixed(-0.001, 4, &builder));
1486 CHECK_EQ("-0.0010", builder.Finalize());
1487
1488 builder.Reset();
1489 CHECK(dc.ToFixed(-1.0, 4, &builder));
1490 CHECK_EQ("-1.0000", builder.Finalize());
1491
1492 builder.Reset();
1493 CHECK(dc.ToFixed(-1.0, 1, &builder));
1494 CHECK_EQ("-1.0", builder.Finalize());
1495
1496 builder.Reset();
1497 CHECK(dc.ToFixed(-1.0, 0, &builder));
1498 CHECK_EQ("-1", builder.Finalize());
1499
1500 builder.Reset();
1501 CHECK(dc.ToFixed(-12.0, 0, &builder));
1502 CHECK_EQ("-12", builder.Finalize());
1503
1504 builder.Reset();
1505 CHECK(dc.ToFixed(-1.1, 0, &builder));
1506 CHECK_EQ("-1", builder.Finalize());
1507
1508 builder.Reset();
1509 CHECK(dc.ToFixed(-12.1, 0, &builder));
1510 CHECK_EQ("-12", builder.Finalize());
1511
1512 builder.Reset();
1513 CHECK(dc.ToFixed(-1.12, 0, &builder));
1514 CHECK_EQ("-1", builder.Finalize());
1515
1516 builder.Reset();
1517 CHECK(dc.ToFixed(-12.12, 0, &builder));
1518 CHECK_EQ("-12", builder.Finalize());
1519
1520 builder.Reset();
1521 CHECK(dc.ToFixed(-0.0000006, 7, &builder));
1522 CHECK_EQ("-0.0000006", builder.Finalize());
1523
1524 builder.Reset();
1525 CHECK(dc.ToFixed(-0.00000006, 8, &builder));
1526 CHECK_EQ("-0.00000006", builder.Finalize());
1527
1528 builder.Reset();
1529 CHECK(dc.ToFixed(-0.00000006, 9, &builder));
1530 CHECK_EQ("-0.000000060", builder.Finalize());
1531
1532 builder.Reset();
1533 CHECK(dc.ToFixed(-0.00000006, 10, &builder));
1534 CHECK_EQ("-0.0000000600", builder.Finalize());
1535
1536 builder.Reset();
1537 CHECK(dc.ToFixed(-0, 0, &builder));
1538 CHECK_EQ("0", builder.Finalize());
1539
1540 builder.Reset();
1541 CHECK(dc.ToFixed(-0, 1, &builder));
1542 CHECK_EQ("0.0", builder.Finalize());
1543
1544 builder.Reset();
1545 CHECK(dc.ToFixed(-0, 2, &builder));
1546 CHECK_EQ("0.00", builder.Finalize());
1547
1548 builder.Reset();
1549 CHECK(dc.ToFixed(1000, 0, &builder));
1550 CHECK_EQ("1000", builder.Finalize());
1551
1552 builder.Reset();
1553 CHECK(dc.ToFixed(0.00001, 0, &builder));
1554 CHECK_EQ("0", builder.Finalize());
1555
1556 builder.Reset();
1557 CHECK(dc.ToFixed(0.00001, 5, &builder));
1558 CHECK_EQ("0.00001", builder.Finalize());
1559
1560 builder.Reset();
1561 CHECK(dc.ToFixed(0.0000000000000000001, 20, &builder));
1562 CHECK_EQ("0.00000000000000000010", builder.Finalize());
1563
1564 builder.Reset();
1565 CHECK(dc.ToFixed(0.00001, 17, &builder));
1566 CHECK_EQ("0.00001000000000000", builder.Finalize());
1567
1568 builder.Reset();
1569 CHECK(dc.ToFixed(1000000000000000128.0, 0, &builder));
1570 CHECK_EQ("1000000000000000128", builder.Finalize());
1571
1572 builder.Reset();
1573 CHECK(dc.ToFixed(1000000000000000128.0, 1, &builder));
1574 CHECK_EQ("1000000000000000128.0", builder.Finalize());
1575
1576 builder.Reset();
1577 CHECK(dc.ToFixed(1000000000000000128.0, 2, &builder));
1578 CHECK_EQ("1000000000000000128.00", builder.Finalize());
1579
1580 builder.Reset();
1581 CHECK(dc.ToFixed(1000000000000000128.0, 20, &builder));
1582 CHECK_EQ("1000000000000000128.00000000000000000000", builder.Finalize());
1583
1584 builder.Reset();
1585 CHECK(dc.ToFixed(0.0, 0, &builder));
1586 CHECK_EQ("0", builder.Finalize());
1587
1588 builder.Reset();
1589 CHECK(dc.ToFixed(-42.0, 3, &builder));
1590 CHECK_EQ("-42.000", builder.Finalize());
1591
1592 builder.Reset();
1593 CHECK(dc.ToFixed(-1000000000000000128.0, 0, &builder));
1594 CHECK_EQ("-1000000000000000128", builder.Finalize());
1595
1596 builder.Reset();
1597 CHECK(dc.ToFixed(-0.0000000000000000001, 20, &builder));
1598 CHECK_EQ("-0.00000000000000000010", builder.Finalize());
1599
1600 builder.Reset();
1601 CHECK(dc.ToFixed(0.123123123123123, 20, &builder));
1602 CHECK_EQ("0.12312312312312299889", builder.Finalize());
1603
1604 builder.Reset();
1605 CHECK(dc.ToFixed(0.5, 0, &builder));
1606 CHECK_EQ("1", builder.Finalize());
1607
1608 builder.Reset();
1609 CHECK(dc.ToFixed(-0.5, 0, &builder));
1610 CHECK_EQ("-1", builder.Finalize());
1611
1612 builder.Reset();
1613 CHECK(dc.ToFixed(1.25, 1, &builder));
1614 CHECK_EQ("1.3", builder.Finalize());
1615
1616 builder.Reset();
1617 CHECK(dc.ToFixed(234.20405, 4, &builder));
1618 CHECK_EQ("234.2040", builder.Finalize());
1619
1620 builder.Reset();
1621 CHECK(dc.ToFixed(234.2040506, 4, &builder));
1622 CHECK_EQ("234.2041", builder.Finalize());
1623
1624 builder.Reset();
1625 CHECK(dc.ToExponential(1.0, -1, &builder));
1626 CHECK_EQ("1e+0", builder.Finalize());
1627
1628 builder.Reset();
1629 CHECK(dc.ToExponential(11.0, -1, &builder));
1630 CHECK_EQ("1.1e+1", builder.Finalize());
1631
1632 builder.Reset();
1633 CHECK(dc.ToExponential(112.0, -1, &builder));
1634 CHECK_EQ("1.12e+2", builder.Finalize());
1635
1636 builder.Reset();
1637 CHECK(dc.ToExponential(1.0, 0, &builder));
1638 CHECK_EQ("1e+0", builder.Finalize());
1639
1640 builder.Reset();
1641 CHECK(dc.ToExponential(11.0, 0, &builder));
1642 CHECK_EQ("1e+1", builder.Finalize());
1643
1644 builder.Reset();
1645 CHECK(dc.ToExponential(112.0, 0, &builder));
1646 CHECK_EQ("1e+2", builder.Finalize());
1647
1648 builder.Reset();
1649 CHECK(dc.ToExponential(1.0, 1, &builder));
1650 CHECK_EQ("1.0e+0", builder.Finalize());
1651
1652 builder.Reset();
1653 CHECK(dc.ToExponential(11.0, 1, &builder));
1654 CHECK_EQ("1.1e+1", builder.Finalize());
1655
1656 builder.Reset();
1657 CHECK(dc.ToExponential(112.0, 1, &builder));
1658 CHECK_EQ("1.1e+2", builder.Finalize());
1659
1660 builder.Reset();
1661 CHECK(dc.ToExponential(1.0, 2, &builder));
1662 CHECK_EQ("1.00e+0", builder.Finalize());
1663
1664 builder.Reset();
1665 CHECK(dc.ToExponential(11.0, 2, &builder));
1666 CHECK_EQ("1.10e+1", builder.Finalize());
1667
1668 builder.Reset();
1669 CHECK(dc.ToExponential(112.0, 2, &builder));
1670 CHECK_EQ("1.12e+2", builder.Finalize());
1671
1672 builder.Reset();
1673 CHECK(dc.ToExponential(1.0, 3, &builder));
1674 CHECK_EQ("1.000e+0", builder.Finalize());
1675
1676 builder.Reset();
1677 CHECK(dc.ToExponential(11.0, 3, &builder));
1678 CHECK_EQ("1.100e+1", builder.Finalize());
1679
1680 builder.Reset();
1681 CHECK(dc.ToExponential(112.0, 3, &builder));
1682 CHECK_EQ("1.120e+2", builder.Finalize());
1683
1684 builder.Reset();
1685 CHECK(dc.ToExponential(0.1, -1, &builder));
1686 CHECK_EQ("1e-1", builder.Finalize());
1687
1688 builder.Reset();
1689 CHECK(dc.ToExponential(0.11, -1, &builder));
1690 CHECK_EQ("1.1e-1", builder.Finalize());
1691
1692 builder.Reset();
1693 CHECK(dc.ToExponential(0.112, -1, &builder));
1694 CHECK_EQ("1.12e-1", builder.Finalize());
1695
1696 builder.Reset();
1697 CHECK(dc.ToExponential(0.1, 0, &builder));
1698 CHECK_EQ("1e-1", builder.Finalize());
1699
1700 builder.Reset();
1701 CHECK(dc.ToExponential(0.11, 0, &builder));
1702 CHECK_EQ("1e-1", builder.Finalize());
1703
1704 builder.Reset();
1705 CHECK(dc.ToExponential(0.112, 0, &builder));
1706 CHECK_EQ("1e-1", builder.Finalize());
1707
1708 builder.Reset();
1709 CHECK(dc.ToExponential(0.1, 1, &builder));
1710 CHECK_EQ("1.0e-1", builder.Finalize());
1711
1712 builder.Reset();
1713 CHECK(dc.ToExponential(0.11, 1, &builder));
1714 CHECK_EQ("1.1e-1", builder.Finalize());
1715
1716 builder.Reset();
1717 CHECK(dc.ToExponential(0.112, 1, &builder));
1718 CHECK_EQ("1.1e-1", builder.Finalize());
1719
1720 builder.Reset();
1721 CHECK(dc.ToExponential(0.1, 2, &builder));
1722 CHECK_EQ("1.00e-1", builder.Finalize());
1723
1724 builder.Reset();
1725 CHECK(dc.ToExponential(0.11, 2, &builder));
1726 CHECK_EQ("1.10e-1", builder.Finalize());
1727
1728 builder.Reset();
1729 CHECK(dc.ToExponential(0.112, 2, &builder));
1730 CHECK_EQ("1.12e-1", builder.Finalize());
1731
1732 builder.Reset();
1733 CHECK(dc.ToExponential(0.1, 3, &builder));
1734 CHECK_EQ("1.000e-1", builder.Finalize());
1735
1736 builder.Reset();
1737 CHECK(dc.ToExponential(0.11, 3, &builder));
1738 CHECK_EQ("1.100e-1", builder.Finalize());
1739
1740 builder.Reset();
1741 CHECK(dc.ToExponential(0.112, 3, &builder));
1742 CHECK_EQ("1.120e-1", builder.Finalize());
1743
1744 builder.Reset();
1745 CHECK(dc.ToExponential(-1.0, -1, &builder));
1746 CHECK_EQ("-1e+0", builder.Finalize());
1747
1748 builder.Reset();
1749 CHECK(dc.ToExponential(-11.0, -1, &builder));
1750 CHECK_EQ("-1.1e+1", builder.Finalize());
1751
1752 builder.Reset();
1753 CHECK(dc.ToExponential(-112.0, -1, &builder));
1754 CHECK_EQ("-1.12e+2", builder.Finalize());
1755
1756 builder.Reset();
1757 CHECK(dc.ToExponential(-1.0, 0, &builder));
1758 CHECK_EQ("-1e+0", builder.Finalize());
1759
1760 builder.Reset();
1761 CHECK(dc.ToExponential(-11.0, 0, &builder));
1762 CHECK_EQ("-1e+1", builder.Finalize());
1763
1764 builder.Reset();
1765 CHECK(dc.ToExponential(-112.0, 0, &builder));
1766 CHECK_EQ("-1e+2", builder.Finalize());
1767
1768 builder.Reset();
1769 CHECK(dc.ToExponential(-1.0, 1, &builder));
1770 CHECK_EQ("-1.0e+0", builder.Finalize());
1771
1772 builder.Reset();
1773 CHECK(dc.ToExponential(-11.0, 1, &builder));
1774 CHECK_EQ("-1.1e+1", builder.Finalize());
1775
1776 builder.Reset();
1777 CHECK(dc.ToExponential(-112.0, 1, &builder));
1778 CHECK_EQ("-1.1e+2", builder.Finalize());
1779
1780 builder.Reset();
1781 CHECK(dc.ToExponential(-1.0, 2, &builder));
1782 CHECK_EQ("-1.00e+0", builder.Finalize());
1783
1784 builder.Reset();
1785 CHECK(dc.ToExponential(-11.0, 2, &builder));
1786 CHECK_EQ("-1.10e+1", builder.Finalize());
1787
1788 builder.Reset();
1789 CHECK(dc.ToExponential(-112.0, 2, &builder));
1790 CHECK_EQ("-1.12e+2", builder.Finalize());
1791
1792 builder.Reset();
1793 CHECK(dc.ToExponential(-1.0, 3, &builder));
1794 CHECK_EQ("-1.000e+0", builder.Finalize());
1795
1796 builder.Reset();
1797 CHECK(dc.ToExponential(-11.0, 3, &builder));
1798 CHECK_EQ("-1.100e+1", builder.Finalize());
1799
1800 builder.Reset();
1801 CHECK(dc.ToExponential(-112.0, 3, &builder));
1802 CHECK_EQ("-1.120e+2", builder.Finalize());
1803
1804 builder.Reset();
1805 CHECK(dc.ToExponential(-0.1, -1, &builder));
1806 CHECK_EQ("-1e-1", builder.Finalize());
1807
1808 builder.Reset();
1809 CHECK(dc.ToExponential(-0.11, -1, &builder));
1810 CHECK_EQ("-1.1e-1", builder.Finalize());
1811
1812 builder.Reset();
1813 CHECK(dc.ToExponential(-0.112, -1, &builder));
1814 CHECK_EQ("-1.12e-1", builder.Finalize());
1815
1816 builder.Reset();
1817 CHECK(dc.ToExponential(-0.1, 0, &builder));
1818 CHECK_EQ("-1e-1", builder.Finalize());
1819
1820 builder.Reset();
1821 CHECK(dc.ToExponential(-0.11, 0, &builder));
1822 CHECK_EQ("-1e-1", builder.Finalize());
1823
1824 builder.Reset();
1825 CHECK(dc.ToExponential(-0.112, 0, &builder));
1826 CHECK_EQ("-1e-1", builder.Finalize());
1827
1828 builder.Reset();
1829 CHECK(dc.ToExponential(-0.1, 1, &builder));
1830 CHECK_EQ("-1.0e-1", builder.Finalize());
1831
1832 builder.Reset();
1833 CHECK(dc.ToExponential(-0.11, 1, &builder));
1834 CHECK_EQ("-1.1e-1", builder.Finalize());
1835
1836 builder.Reset();
1837 CHECK(dc.ToExponential(-0.112, 1, &builder));
1838 CHECK_EQ("-1.1e-1", builder.Finalize());
1839
1840 builder.Reset();
1841 CHECK(dc.ToExponential(-0.1, 2, &builder));
1842 CHECK_EQ("-1.00e-1", builder.Finalize());
1843
1844 builder.Reset();
1845 CHECK(dc.ToExponential(-0.11, 2, &builder));
1846 CHECK_EQ("-1.10e-1", builder.Finalize());
1847
1848 builder.Reset();
1849 CHECK(dc.ToExponential(-0.112, 2, &builder));
1850 CHECK_EQ("-1.12e-1", builder.Finalize());
1851
1852 builder.Reset();
1853 CHECK(dc.ToExponential(-0.1, 3, &builder));
1854 CHECK_EQ("-1.000e-1", builder.Finalize());
1855
1856 builder.Reset();
1857 CHECK(dc.ToExponential(-0.11, 3, &builder));
1858 CHECK_EQ("-1.100e-1", builder.Finalize());
1859
1860 builder.Reset();
1861 CHECK(dc.ToExponential(-0.112, 3, &builder));
1862 CHECK_EQ("-1.120e-1", builder.Finalize());
1863
1864 builder.Reset();
1865 CHECK(dc.ToExponential(Double::NaN(), 2, &builder));
1866 CHECK_EQ("NaN", builder.Finalize());
1867
1868 builder.Reset();
1869 CHECK(dc.ToExponential(Double::Infinity(), 2, &builder));
1870 CHECK_EQ("Infinity", builder.Finalize());
1871
1872 builder.Reset();
1873 CHECK(dc.ToExponential(-Double::Infinity(), 2, &builder));
1874 CHECK_EQ("-Infinity", builder.Finalize());
1875
1876 builder.Reset();
1877 CHECK(dc.ToExponential(1.0, 0, &builder));
1878 CHECK_EQ("1e+0", builder.Finalize());
1879
1880 builder.Reset();
1881 CHECK(dc.ToExponential(0.0, -1, &builder));
1882 CHECK_EQ("0e+0", builder.Finalize());
1883
1884 builder.Reset();
1885 CHECK(dc.ToExponential(0.0, 2, &builder));
1886 CHECK_EQ("0.00e+0", builder.Finalize());
1887
1888 builder.Reset();
1889 CHECK(dc.ToExponential(11.2356, 0, &builder));
1890 CHECK_EQ("1e+1", builder.Finalize());
1891
1892 builder.Reset();
1893 CHECK(dc.ToExponential(11.2356, 4, &builder));
1894 CHECK_EQ("1.1236e+1", builder.Finalize());
1895
1896 builder.Reset();
1897 CHECK(dc.ToExponential(0.000112356, 4, &builder));
1898 CHECK_EQ("1.1236e-4", builder.Finalize());
1899
1900 builder.Reset();
1901 CHECK(dc.ToExponential(-0.000112356, 4, &builder));
1902 CHECK_EQ("-1.1236e-4", builder.Finalize());
1903
1904 builder.Reset();
1905 CHECK(dc.ToExponential(0.000112356, -1, &builder));
1906 CHECK_EQ("1.12356e-4", builder.Finalize());
1907
1908 builder.Reset();
1909 CHECK(dc.ToExponential(-0.000112356, -1, &builder));
1910 CHECK_EQ("-1.12356e-4", builder.Finalize());
1911
1912 builder.Reset();
1913 CHECK(dc.ToPrecision(Double::NaN(), 1, &builder));
1914 CHECK_EQ("NaN", builder.Finalize());
1915
1916 builder.Reset();
1917 CHECK(dc.ToPrecision(Double::Infinity(), 2, &builder));
1918 CHECK_EQ("Infinity", builder.Finalize());
1919
1920 builder.Reset();
1921 CHECK(dc.ToPrecision(-Double::Infinity(), 2, &builder));
1922 CHECK_EQ("-Infinity", builder.Finalize());
1923
1924 builder.Reset();
1925 CHECK(dc.ToPrecision(0.000555, 15, &builder));
1926 CHECK_EQ("0.000555000000000000", builder.Finalize());
1927
1928 builder.Reset();
1929 CHECK(dc.ToPrecision(0.000000555, 15, &builder));
1930 CHECK_EQ("5.55000000000000e-7", builder.Finalize());
1931
1932 builder.Reset();
1933 CHECK(dc.ToPrecision(-0.000000555, 15, &builder));
1934 CHECK_EQ("-5.55000000000000e-7", builder.Finalize());
1935
1936 builder.Reset();
1937 CHECK(dc.ToPrecision(123456789.0, 1, &builder));
1938 CHECK_EQ("1e+8", builder.Finalize());
1939
1940 builder.Reset();
1941 CHECK(dc.ToPrecision(123456789.0, 9, &builder));
1942 CHECK_EQ("123456789", builder.Finalize());
1943
1944 builder.Reset();
1945 CHECK(dc.ToPrecision(123456789.0, 8, &builder));
1946 CHECK_EQ("1.2345679e+8", builder.Finalize());
1947
1948 builder.Reset();
1949 CHECK(dc.ToPrecision(123456789.0, 7, &builder));
1950 CHECK_EQ("1.234568e+8", builder.Finalize());
1951
1952 builder.Reset();
1953 CHECK(dc.ToPrecision(-123456789.0, 7, &builder));
1954 CHECK_EQ("-1.234568e+8", builder.Finalize());
1955
1956 builder.Reset();
1957 CHECK(dc.ToPrecision(-.0000000012345, 2, &builder));
1958 CHECK_EQ("-1.2e-9", builder.Finalize());
1959
1960 builder.Reset();
1961 CHECK(dc.ToPrecision(-.000000012345, 2, &builder));
1962 CHECK_EQ("-1.2e-8", builder.Finalize());
1963
1964 builder.Reset();
1965 CHECK(dc.ToPrecision(-.00000012345, 2, &builder));
1966 CHECK_EQ("-1.2e-7", builder.Finalize());
1967
1968 builder.Reset();
1969 CHECK(dc.ToPrecision(-.0000012345, 2, &builder));
1970 CHECK_EQ("-0.0000012", builder.Finalize());
1971
1972 builder.Reset();
1973 CHECK(dc.ToPrecision(-.000012345, 2, &builder));
1974 CHECK_EQ("-0.000012", builder.Finalize());
1975
1976 builder.Reset();
1977 CHECK(dc.ToPrecision(-.00012345, 2, &builder));
1978 CHECK_EQ("-0.00012", builder.Finalize());
1979
1980 builder.Reset();
1981 CHECK(dc.ToPrecision(-.0012345, 2, &builder));
1982 CHECK_EQ("-0.0012", builder.Finalize());
1983
1984 builder.Reset();
1985 CHECK(dc.ToPrecision(-.012345, 2, &builder));
1986 CHECK_EQ("-0.012", builder.Finalize());
1987
1988 builder.Reset();
1989 CHECK(dc.ToPrecision(-.12345, 2, &builder));
1990 CHECK_EQ("-0.12", builder.Finalize());
1991
1992 builder.Reset();
1993 CHECK(dc.ToPrecision(-1.2345, 2, &builder));
1994 CHECK_EQ("-1.2", builder.Finalize());
1995
1996 builder.Reset();
1997 CHECK(dc.ToPrecision(-12.345, 2, &builder));
1998 CHECK_EQ("-12", builder.Finalize());
1999
2000 builder.Reset();
2001 CHECK(dc.ToPrecision(-123.45, 2, &builder));
2002 CHECK_EQ("-1.2e+2", builder.Finalize());
2003
2004 builder.Reset();
2005 CHECK(dc.ToPrecision(-1234.5, 2, &builder));
2006 CHECK_EQ("-1.2e+3", builder.Finalize());
2007
2008 builder.Reset();
2009 CHECK(dc.ToPrecision(-12345.0, 2, &builder));
2010 CHECK_EQ("-1.2e+4", builder.Finalize());
2011
2012 builder.Reset();
2013 CHECK(dc.ToPrecision(-12345.67, 4, &builder));
2014 CHECK_EQ("-1.235e+4", builder.Finalize());
2015
2016 builder.Reset();
2017 CHECK(dc.ToPrecision(-12344.67, 4, &builder));
2018 CHECK_EQ("-1.234e+4", builder.Finalize());
2019
2020 builder.Reset();
2021 CHECK(dc.ToPrecision(1.25, 2, &builder));
2022 CHECK_EQ("1.3", builder.Finalize());
2023
2024 builder.Reset();
2025 CHECK(dc.ToPrecision(1.35, 2, &builder));
2026 CHECK_EQ("1.4", builder.Finalize());
2027 }
2028
2029
StrToD16(const uc16 * str16,int length,int flags,double empty_string_value,int * processed_characters_count,bool * processed_all,uc16 separator=StringToDoubleConverter::kNoSeparator)2030 static double StrToD16(const uc16* str16, int length, int flags,
2031 double empty_string_value,
2032 int* processed_characters_count, bool* processed_all,
2033 uc16 separator = StringToDoubleConverter::kNoSeparator) {
2034 StringToDoubleConverter converter(flags, empty_string_value, Double::NaN(),
2035 NULL, NULL, separator);
2036 double result =
2037 converter.StringToDouble(str16, length, processed_characters_count);
2038 *processed_all = (length == *processed_characters_count);
2039 return result;
2040 }
2041
2042
StrToD16(const char * str,int flags,double empty_string_value,int * processed_characters_count,bool * processed_all,char char_separator,uc16 separator)2043 static double StrToD16(const char* str, int flags,
2044 double empty_string_value,
2045 int* processed_characters_count, bool* processed_all,
2046 char char_separator, uc16 separator) {
2047 uc16 str16[256];
2048 int length = -1;
2049 for (int i = 0;; i++) {
2050 if (str[i] == char_separator) {
2051 str16[i] = separator;
2052 } else {
2053 str16[i] = str[i];
2054 }
2055 if (str[i] == '\0') {
2056 length = i;
2057 break;
2058 }
2059 }
2060 DOUBLE_CONVERSION_ASSERT(length < 256);
2061 StringToDoubleConverter converter(flags, empty_string_value, Double::NaN(),
2062 NULL, NULL, separator);
2063 double result =
2064 converter.StringToDouble(str16, length, processed_characters_count);
2065 *processed_all = (length == *processed_characters_count);
2066 return result;
2067 }
2068
2069
StrToD(const char * str,int flags,double empty_string_value,int * processed_characters_count,bool * processed_all,uc16 separator=StringToDoubleConverter::kNoSeparator)2070 static double StrToD(const char* str, int flags, double empty_string_value,
2071 int* processed_characters_count, bool* processed_all,
2072 uc16 separator = StringToDoubleConverter::kNoSeparator) {
2073 StringToDoubleConverter converter(flags, empty_string_value, Double::NaN(),
2074 NULL, NULL, separator);
2075 double result = converter.StringToDouble(str, strlen(str),
2076 processed_characters_count);
2077 *processed_all =
2078 ((strlen(str) == static_cast<unsigned>(*processed_characters_count)));
2079
2080 uc16 buffer16[256];
2081 DOUBLE_CONVERSION_ASSERT(strlen(str) < DOUBLE_CONVERSION_ARRAY_SIZE(buffer16));
2082 int len = strlen(str);
2083 for (int i = 0; i < len; i++) {
2084 buffer16[i] = str[i];
2085 }
2086 int processed_characters_count16;
2087 bool processed_all16;
2088 double result16 = StrToD16(buffer16, len, flags, empty_string_value,
2089 &processed_characters_count16, &processed_all16,
2090 separator);
2091 CHECK_EQ(result, result16);
2092 CHECK_EQ(*processed_characters_count, processed_characters_count16);
2093 return result;
2094 }
2095
2096
TEST(StringToDoubleVarious)2097 TEST(StringToDoubleVarious) {
2098 int flags;
2099 int processed;
2100 bool all_used;
2101
2102 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
2103 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN |
2104 StringToDoubleConverter::ALLOW_TRAILING_SPACES;
2105
2106 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
2107 CHECK(all_used);
2108
2109 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
2110 CHECK(all_used);
2111
2112 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
2113 CHECK(all_used);
2114
2115 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
2116 CHECK(all_used);
2117
2118 CHECK_EQ(42.0, StrToD("42", flags, 0.0, &processed, &all_used));
2119 CHECK(all_used);
2120
2121 CHECK_EQ(42.0, StrToD(" + 42 ", flags, 0.0, &processed, &all_used));
2122 CHECK(all_used);
2123
2124 CHECK_EQ(-42.0, StrToD(" - 42 ", flags, 0.0, &processed, &all_used));
2125 CHECK(all_used);
2126
2127 CHECK_EQ(Double::NaN(), StrToD("x", flags, 1.0, &processed, &all_used));
2128 CHECK_EQ(0, processed);
2129
2130 CHECK_EQ(Double::NaN(), StrToD(" x", flags, 1.0, &processed, &all_used));
2131 CHECK_EQ(0, processed);
2132
2133 CHECK_EQ(Double::NaN(), StrToD("42x", flags, 0.0, &processed, &all_used));
2134 CHECK_EQ(0, processed);
2135
2136 CHECK_EQ(Double::NaN(), StrToD("42 x", flags, 0.0, &processed, &all_used));
2137 CHECK_EQ(0, processed);
2138
2139 CHECK_EQ(Double::NaN(), StrToD(" + 42 x", flags, 0.0, &processed, &all_used));
2140 CHECK_EQ(0, processed);
2141
2142 CHECK_EQ(Double::NaN(), StrToD(" - 42 x", flags, 0.0, &processed, &all_used));
2143 CHECK_EQ(0, processed);
2144
2145
2146 flags = StringToDoubleConverter::ALLOW_TRAILING_JUNK;
2147
2148 CHECK_EQ(123.0, StrToD("123e", flags, 0.0, &processed, &all_used));
2149 CHECK_EQ(processed, 3);
2150
2151 CHECK_EQ(123.0, StrToD("123e-", flags, 0.0, &processed, &all_used));
2152 CHECK_EQ(processed, 3);
2153
2154 CHECK_EQ(123.0, StrToD("123e-a", flags, 0.0, &processed, &all_used));
2155 CHECK_EQ(processed, 3);
2156
2157
2158 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
2159 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN |
2160 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
2161 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
2162
2163 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
2164 CHECK(all_used);
2165
2166 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
2167 CHECK(all_used);
2168
2169 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
2170 CHECK(all_used);
2171
2172 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
2173 CHECK(all_used);
2174
2175 CHECK_EQ(42.0, StrToD("42", flags, 0.0, &processed, &all_used));
2176 CHECK(all_used);
2177
2178 CHECK_EQ(42.0, StrToD(" + 42 ", flags, 0.0, &processed, &all_used));
2179 CHECK(all_used);
2180
2181 CHECK_EQ(-42.0, StrToD(" - 42 ", flags, 0.0, &processed, &all_used));
2182 CHECK(all_used);
2183
2184 CHECK_EQ(Double::NaN(), StrToD("x", flags, 1.0, &processed, &all_used));
2185 CHECK_EQ(0, processed);
2186
2187 CHECK_EQ(Double::NaN(), StrToD(" x", flags, 1.0, &processed, &all_used));
2188 CHECK_EQ(0, processed);
2189
2190 CHECK_EQ(42.0, StrToD("42x", flags, 0.0, &processed, &all_used));
2191 CHECK_EQ(2, processed);
2192
2193 CHECK_EQ(42.0, StrToD("42 x", flags, 0.0, &processed, &all_used));
2194 CHECK_EQ(3, processed);
2195
2196 CHECK_EQ(42.0, StrToD(" + 42 x", flags, 0.0, &processed, &all_used));
2197 CHECK_EQ(6, processed);
2198
2199 CHECK_EQ(-42.0, StrToD(" - 42 x", flags, 0.0, &processed, &all_used));
2200 CHECK_EQ(6, processed);
2201
2202
2203 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
2204 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN |
2205 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
2206
2207 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
2208 CHECK(all_used);
2209
2210 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
2211 CHECK(all_used);
2212
2213 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
2214 CHECK(all_used);
2215
2216 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
2217 CHECK(all_used);
2218
2219 CHECK_EQ(42.0, StrToD("42", flags, 0.0, &processed, &all_used));
2220 CHECK(all_used);
2221
2222 CHECK_EQ(42.0, StrToD(" + 42 ", flags, 0.0, &processed, &all_used));
2223 CHECK_EQ(5, processed);
2224
2225 CHECK_EQ(-42.0, StrToD(" - 42 ", flags, 0.0, &processed, &all_used));
2226 CHECK_EQ(5, processed);
2227
2228 CHECK_EQ(Double::NaN(), StrToD("x", flags, 1.0, &processed, &all_used));
2229 CHECK_EQ(0, processed);
2230
2231 CHECK_EQ(Double::NaN(), StrToD(" x", flags, 1.0, &processed, &all_used));
2232 CHECK_EQ(0, processed);
2233
2234 CHECK_EQ(42.0, StrToD("42x", flags, 0.0, &processed, &all_used));
2235 CHECK_EQ(2, processed);
2236
2237 CHECK_EQ(42.0, StrToD("42 x", flags, 0.0, &processed, &all_used));
2238 CHECK_EQ(2, processed);
2239
2240 CHECK_EQ(42.0, StrToD(" + 42 x", flags, 0.0, &processed, &all_used));
2241 CHECK_EQ(5, processed);
2242
2243 CHECK_EQ(-42.0, StrToD(" - 42 x", flags, 0.0, &processed, &all_used));
2244 CHECK_EQ(5, processed);
2245
2246 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
2247 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
2248
2249 CHECK_EQ(42.0, StrToD(" +42 ", flags, 0.0, &processed, &all_used));
2250 CHECK_EQ(4, processed);
2251
2252 CHECK_EQ(-42.0, StrToD(" -42 ", flags, 0.0, &processed, &all_used));
2253 CHECK_EQ(4, processed);
2254
2255 CHECK_EQ(Double::NaN(), StrToD(" + 42 ", flags, 0.0, &processed, &all_used));
2256 CHECK_EQ(0, processed);
2257
2258 CHECK_EQ(Double::NaN(), StrToD(" - 42 ", flags, 0.0, &processed, &all_used));
2259 CHECK_EQ(0, processed);
2260
2261
2262 flags = StringToDoubleConverter::NO_FLAGS;
2263
2264 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
2265 CHECK(all_used);
2266
2267 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
2268 CHECK(all_used);
2269
2270 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 0.0, &processed, &all_used));
2271 CHECK_EQ(0, processed);
2272
2273 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 1.0, &processed, &all_used));
2274 CHECK_EQ(0, processed);
2275
2276 CHECK_EQ(42.0, StrToD("42", flags, 0.0, &processed, &all_used));
2277 CHECK(all_used);
2278
2279 CHECK_EQ(Double::NaN(), StrToD(" + 42 ", flags, 0.0, &processed, &all_used));
2280 CHECK_EQ(0, processed);
2281
2282 CHECK_EQ(Double::NaN(), StrToD(" - 42 ", flags, 0.0, &processed, &all_used));
2283 CHECK_EQ(0, processed);
2284
2285 CHECK_EQ(Double::NaN(), StrToD("x", flags, 1.0, &processed, &all_used));
2286 CHECK_EQ(0, processed);
2287
2288 CHECK_EQ(Double::NaN(), StrToD(" x", flags, 1.0, &processed, &all_used));
2289 CHECK_EQ(0, processed);
2290
2291 CHECK_EQ(Double::NaN(), StrToD("42x", flags, 0.0, &processed, &all_used));
2292 CHECK_EQ(0, processed);
2293
2294 CHECK_EQ(Double::NaN(), StrToD("42 x", flags, 0.0, &processed, &all_used));
2295 CHECK_EQ(0, processed);
2296
2297 CHECK_EQ(Double::NaN(), StrToD(" + 42 x", flags, 0.0, &processed, &all_used));
2298 CHECK_EQ(0, processed);
2299
2300 CHECK_EQ(Double::NaN(), StrToD(" - 42 x", flags, 0.0, &processed, &all_used));
2301 CHECK_EQ(0, processed);
2302
2303
2304 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES;
2305
2306 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
2307 CHECK(all_used);
2308
2309 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
2310 CHECK(all_used);
2311
2312 CHECK_EQ(42.0, StrToD(" 42", flags, 0.0, &processed, &all_used));
2313 CHECK(all_used);
2314
2315 CHECK_EQ(Double::NaN(), StrToD("42 ", flags, 0.0, &processed, &all_used));
2316 CHECK_EQ(0, processed);
2317
2318
2319 flags = StringToDoubleConverter::ALLOW_TRAILING_SPACES;
2320
2321 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
2322 CHECK(all_used);
2323
2324 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
2325 CHECK(all_used);
2326
2327 CHECK_EQ(42.0, StrToD("42 ", flags, 0.0, &processed, &all_used));
2328 CHECK(all_used);
2329
2330 CHECK_EQ(Double::NaN(), StrToD(" 42", flags, 0.0, &processed, &all_used));
2331 CHECK_EQ(0, processed);
2332 }
2333
2334
TEST(StringToDoubleEmptyString)2335 TEST(StringToDoubleEmptyString) {
2336 int flags;
2337 int processed;
2338 bool all_used;
2339
2340 flags = StringToDoubleConverter::NO_FLAGS;
2341 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
2342 CHECK(all_used);
2343
2344 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
2345 CHECK(all_used);
2346
2347 CHECK_EQ(Double::NaN(), StrToD("", flags, Double::NaN(),
2348 &processed, &all_used));
2349 CHECK(all_used);
2350
2351 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 0.0, &processed, &all_used));
2352 CHECK_EQ(0, processed);
2353
2354 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 1.0, &processed, &all_used));
2355 CHECK_EQ(0, processed);
2356
2357 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
2358 &processed, &all_used));
2359 CHECK_EQ(0, processed);
2360
2361 flags = StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
2362 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
2363 CHECK(all_used);
2364
2365 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
2366 CHECK(all_used);
2367
2368 CHECK_EQ(Double::NaN(), StrToD("", flags, Double::NaN(),
2369 &processed, &all_used));
2370 CHECK(all_used);
2371
2372 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 0.0, &processed, &all_used));
2373 CHECK_EQ(0, processed);
2374
2375 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 1.0, &processed, &all_used));
2376 CHECK_EQ(0, processed);
2377
2378 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
2379 &processed, &all_used));
2380 CHECK_EQ(0, processed);
2381
2382 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES;
2383 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
2384 CHECK(all_used);
2385
2386 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
2387 CHECK(all_used);
2388
2389 CHECK_EQ(Double::NaN(), StrToD("", flags, Double::NaN(),
2390 &processed, &all_used));
2391 CHECK(all_used);
2392
2393 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
2394 CHECK(all_used);
2395
2396 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
2397 CHECK(all_used);
2398
2399 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
2400 &processed, &all_used));
2401 CHECK(all_used);
2402
2403 flags = StringToDoubleConverter::ALLOW_TRAILING_SPACES;
2404 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
2405 CHECK(all_used);
2406
2407 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
2408 CHECK(all_used);
2409
2410 CHECK_EQ(Double::NaN(), StrToD("", flags, Double::NaN(),
2411 &processed, &all_used));
2412 CHECK(all_used);
2413
2414 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
2415 CHECK(all_used);
2416
2417 CHECK_EQ(1.0, StrToD(" ", flags, 1.0, &processed, &all_used));
2418 CHECK(all_used);
2419
2420 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
2421 &processed, &all_used));
2422 CHECK(all_used);
2423
2424 flags = StringToDoubleConverter::ALLOW_TRAILING_JUNK;
2425 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
2426 CHECK(all_used);
2427
2428 CHECK_EQ(1.0, StrToD("", flags, 1.0, &processed, &all_used));
2429 CHECK(all_used);
2430
2431 CHECK_EQ(Double::NaN(), StrToD("", flags, Double::NaN(),
2432 &processed, &all_used));
2433 CHECK(all_used);
2434
2435 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 0.0, &processed, &all_used));
2436 CHECK_EQ(0, processed);
2437
2438 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 1.0, &processed, &all_used));
2439 CHECK_EQ(0, processed);
2440
2441 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
2442 &processed, &all_used));
2443 CHECK_EQ(0, processed);
2444
2445 CHECK_EQ(Double::NaN(), StrToD("x", flags, 0.0, &processed, &all_used));
2446 CHECK_EQ(0, processed);
2447
2448 CHECK_EQ(Double::NaN(), StrToD(" x", flags, 0.0, &processed, &all_used));
2449 CHECK_EQ(0, processed);
2450 }
2451
2452
TEST(StringToDoubleHexString)2453 TEST(StringToDoubleHexString) {
2454 int flags;
2455 int processed;
2456 bool all_used;
2457
2458 flags = StringToDoubleConverter::ALLOW_HEX |
2459 StringToDoubleConverter::ALLOW_LEADING_SPACES |
2460 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
2461 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
2462
2463 CHECK_EQ(18.0, StrToD("0x12", flags, 0.0, &processed, &all_used));
2464 CHECK(all_used);
2465
2466 CHECK_EQ(0.0, StrToD("0x0", flags, 1.0, &processed, &all_used));
2467 CHECK(all_used);
2468
2469 CHECK_EQ(static_cast<double>(0x123456789),
2470 StrToD("0x123456789", flags, Double::NaN(), &processed, &all_used));
2471 CHECK(all_used);
2472
2473 CHECK_EQ(18.0, StrToD(" 0x12 ", flags, 0.0, &processed, &all_used));
2474 CHECK(all_used);
2475
2476 CHECK_EQ(0.0, StrToD(" 0x0 ", flags, 1.0, &processed, &all_used));
2477 CHECK(all_used);
2478
2479 CHECK_EQ(static_cast<double>(0x123456789),
2480 StrToD(" 0x123456789 ", flags, Double::NaN(),
2481 &processed, &all_used));
2482 CHECK(all_used);
2483
2484 CHECK_EQ(static_cast<double>(0xabcdef),
2485 StrToD("0xabcdef", flags, 0.0, &processed, &all_used));
2486 CHECK(all_used);
2487
2488 CHECK_EQ(static_cast<double>(0xabcdef),
2489 StrToD("0xABCDEF", flags, 0.0, &processed, &all_used));
2490 CHECK(all_used);
2491
2492 CHECK_EQ(static_cast<double>(0xabcdef),
2493 StrToD(" 0xabcdef ", flags, 0.0, &processed, &all_used));
2494 CHECK(all_used);
2495
2496 CHECK_EQ(static_cast<double>(0xabcdef),
2497 StrToD(" 0xABCDEF ", flags, 0.0, &processed, &all_used));
2498 CHECK(all_used);
2499
2500 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
2501 &processed, &all_used));
2502 CHECK(all_used);
2503
2504 CHECK_EQ(Double::NaN(), StrToD("0x", flags, 0.0,
2505 &processed, &all_used));
2506 CHECK_EQ(0, processed);
2507
2508 CHECK_EQ(Double::NaN(), StrToD(" 0x ", flags, 0.0,
2509 &processed, &all_used));
2510 CHECK_EQ(0, processed);
2511
2512 CHECK_EQ(Double::NaN(), StrToD(" 0x 3", flags, 0.0,
2513 &processed, &all_used));
2514 CHECK_EQ(0, processed);
2515
2516 CHECK_EQ(Double::NaN(), StrToD("0x3g", flags, 0.0,
2517 &processed, &all_used));
2518 CHECK_EQ(0, processed);
2519
2520 CHECK_EQ(Double::NaN(), StrToD("0x3.23", flags, 0.0,
2521 &processed, &all_used));
2522 CHECK_EQ(0, processed);
2523
2524 CHECK_EQ(Double::NaN(), StrToD("x3", flags, 0.0,
2525 &processed, &all_used));
2526 CHECK_EQ(0, processed);
2527
2528 CHECK_EQ(Double::NaN(), StrToD("0x3 foo", flags, 0.0,
2529 &processed, &all_used));
2530 CHECK_EQ(0, processed);
2531
2532 CHECK_EQ(Double::NaN(), StrToD(" 0x3 foo", flags, 0.0,
2533 &processed, &all_used));
2534 CHECK_EQ(0, processed);
2535
2536 CHECK_EQ(Double::NaN(), StrToD("+ 0x3 foo", flags, 0.0,
2537 &processed, &all_used));
2538 CHECK_EQ(0, processed);
2539
2540 CHECK_EQ(Double::NaN(), StrToD("+", flags, 0.0, &processed, &all_used));
2541 CHECK_EQ(0, processed);
2542
2543 CHECK_EQ(Double::NaN(), StrToD("-", flags, 0.0, &processed, &all_used));
2544 CHECK_EQ(0, processed);
2545
2546 CHECK_EQ(-5.0, StrToD("-0x5", flags, 0.0, &processed, &all_used));
2547 CHECK(all_used);
2548
2549 CHECK_EQ(-5.0, StrToD(" - 0x5 ", flags, 0.0, &processed, &all_used));
2550 CHECK(all_used);
2551
2552 CHECK_EQ(5.0, StrToD(" + 0x5 ", flags, 0.0, &processed, &all_used));
2553 CHECK(all_used);
2554
2555 CHECK_EQ(Double::NaN(), StrToD("- -0x5", flags, 0.0, &processed, &all_used));
2556 CHECK_EQ(0, processed);
2557
2558 CHECK_EQ(Double::NaN(), StrToD("- +0x5", flags, 0.0, &processed, &all_used));
2559 CHECK_EQ(0, processed);
2560
2561 CHECK_EQ(Double::NaN(), StrToD("+ +0x5", flags, 0.0, &processed, &all_used));
2562 CHECK_EQ(0, processed);
2563
2564 flags = StringToDoubleConverter::ALLOW_HEX;
2565
2566 CHECK_EQ(18.0, StrToD("0x12", flags, 0.0, &processed, &all_used));
2567 CHECK(all_used);
2568
2569 CHECK_EQ(0.0, StrToD("0x0", flags, 1.0, &processed, &all_used));
2570 CHECK(all_used);
2571
2572 CHECK_EQ(static_cast<double>(0x123456789),
2573 StrToD("0x123456789", flags, Double::NaN(), &processed, &all_used));
2574 CHECK(all_used);
2575
2576 CHECK_EQ(Double::NaN(), StrToD(" 0x12 ", flags, 0.0, &processed, &all_used));
2577 CHECK_EQ(0, processed);
2578
2579 CHECK_EQ(Double::NaN(), StrToD(" 0x0 ", flags, 1.0, &processed, &all_used));
2580 CHECK_EQ(0, processed);
2581
2582 CHECK_EQ(Double::NaN(), StrToD(" 0x123456789 ", flags, Double::NaN(),
2583 &processed, &all_used));
2584 CHECK_EQ(0, processed);
2585
2586 CHECK_EQ(static_cast<double>(0xabcdef),
2587 StrToD("0xabcdef", flags, 0.0, &processed, &all_used));
2588 CHECK(all_used);
2589
2590 CHECK_EQ(static_cast<double>(0xabcdef),
2591 StrToD("0xABCDEF", flags, 0.0, &processed, &all_used));
2592 CHECK(all_used);
2593
2594 CHECK_EQ(Double::NaN(),
2595 StrToD(" 0xabcdef ", flags, 0.0, &processed, &all_used));
2596 CHECK_EQ(0, processed);
2597
2598 CHECK_EQ(Double::NaN(),
2599 StrToD(" 0xABCDEF ", flags, 0.0, &processed, &all_used));
2600 CHECK_EQ(0, processed);
2601
2602 CHECK_EQ(Double::NaN(),
2603 StrToD(" ", flags, 0.0, &processed, &all_used));
2604 CHECK_EQ(0, processed);
2605
2606 CHECK_EQ(Double::NaN(), StrToD("0x", flags, 0.0,
2607 &processed, &all_used));
2608 CHECK_EQ(0, processed);
2609
2610 CHECK_EQ(Double::NaN(), StrToD(" 0x ", flags, 0.0,
2611 &processed, &all_used));
2612 CHECK_EQ(0, processed);
2613
2614 CHECK_EQ(Double::NaN(), StrToD(" 0x 3", flags, 0.0,
2615 &processed, &all_used));
2616 CHECK_EQ(0, processed);
2617
2618 CHECK_EQ(Double::NaN(), StrToD("0x3g", flags, 0.0,
2619 &processed, &all_used));
2620 CHECK_EQ(0, processed);
2621
2622 CHECK_EQ(Double::NaN(), StrToD("0x3.23", flags, 0.0,
2623 &processed, &all_used));
2624 CHECK_EQ(0, processed);
2625
2626 CHECK_EQ(Double::NaN(), StrToD("x3", flags, 0.0,
2627 &processed, &all_used));
2628 CHECK_EQ(0, processed);
2629
2630 CHECK_EQ(Double::NaN(), StrToD("+ 0x3 foo", flags, 0.0,
2631 &processed, &all_used));
2632 CHECK_EQ(0, processed);
2633
2634 CHECK_EQ(Double::NaN(), StrToD("+", flags, 0.0, &processed, &all_used));
2635 CHECK_EQ(0, processed);
2636
2637 CHECK_EQ(Double::NaN(), StrToD("-", flags, 0.0, &processed, &all_used));
2638 CHECK_EQ(0, processed);
2639
2640 CHECK_EQ(-5.0, StrToD("-0x5", flags, 0.0, &processed, &all_used));
2641 CHECK(all_used);
2642
2643 CHECK_EQ(Double::NaN(), StrToD(" - 0x5 ", flags, 0.0, &processed, &all_used));
2644 CHECK_EQ(0, processed);
2645
2646 CHECK_EQ(Double::NaN(), StrToD(" + 0x5 ", flags, 0.0, &processed, &all_used));
2647 CHECK_EQ(0, processed);
2648
2649 CHECK_EQ(Double::NaN(), StrToD("- -0x5", flags, 0.0, &processed, &all_used));
2650 CHECK_EQ(0, processed);
2651
2652 CHECK_EQ(Double::NaN(), StrToD("- +0x5", flags, 0.0, &processed, &all_used));
2653 CHECK_EQ(0, processed);
2654
2655 CHECK_EQ(Double::NaN(), StrToD("+ +0x5", flags, 0.0, &processed, &all_used));
2656 CHECK_EQ(0, processed);
2657
2658 flags = StringToDoubleConverter::ALLOW_TRAILING_JUNK |
2659 StringToDoubleConverter::ALLOW_HEX;
2660
2661 CHECK_EQ(18.0, StrToD("0x12", flags, 0.0, &processed, &all_used));
2662 CHECK(all_used);
2663
2664 CHECK_EQ(0.0, StrToD("0x0", flags, 1.0, &processed, &all_used));
2665 CHECK(all_used);
2666
2667 CHECK_EQ(static_cast<double>(0x123456789),
2668 StrToD("0x123456789", flags, Double::NaN(), &processed, &all_used));
2669 CHECK(all_used);
2670
2671 CHECK_EQ(Double::NaN(), StrToD(" 0x12 ", flags, 0.0, &processed, &all_used));
2672 CHECK_EQ(0, processed);
2673
2674 CHECK_EQ(Double::NaN(), StrToD(" 0x0 ", flags, 1.0, &processed, &all_used));
2675 CHECK_EQ(0, processed);
2676
2677 CHECK_EQ(18.0, StrToD("0x12 ", flags, 0.0, &processed, &all_used));
2678 CHECK_EQ(4, processed);
2679
2680 CHECK_EQ(0.0, StrToD("0x0 ", flags, 1.0, &processed, &all_used));
2681 CHECK_EQ(3, processed);
2682
2683 CHECK_EQ(Double::NaN(),
2684 StrToD(" 0x123456789 ", flags, Double::NaN(),
2685 &processed, &all_used));
2686 CHECK_EQ(0, processed);
2687
2688 CHECK_EQ(static_cast<double>(0xabcdef),
2689 StrToD("0xabcdef", flags, 0.0, &processed, &all_used));
2690 CHECK(all_used);
2691
2692 CHECK_EQ(static_cast<double>(0xabcdef),
2693 StrToD("0xABCDEF", flags, 0.0, &processed, &all_used));
2694 CHECK(all_used);
2695
2696 CHECK_EQ(Double::NaN(),
2697 StrToD(" 0xabcdef ", flags, 0.0, &processed, &all_used));
2698 CHECK_EQ(0, processed);
2699
2700 CHECK_EQ(Double::NaN(),
2701 StrToD(" 0xABCDEF ", flags, 0.0, &processed, &all_used));
2702 CHECK_EQ(0, processed);
2703
2704 CHECK_EQ(static_cast<double>(0xabcdef),
2705 StrToD("0xabcdef ", flags, 0.0, &processed, &all_used));
2706 CHECK_EQ(8, processed);
2707
2708 CHECK_EQ(static_cast<double>(0xabcdef),
2709 StrToD("0xABCDEF ", flags, 0.0, &processed, &all_used));
2710 CHECK_EQ(8, processed);
2711
2712 CHECK_EQ(Double::NaN(),
2713 StrToD(" 0xabcdef", flags, 0.0, &processed, &all_used));
2714 CHECK_EQ(0, processed);
2715
2716 CHECK_EQ(Double::NaN(),
2717 StrToD(" 0xABCDEF", flags, 0.0, &processed, &all_used));
2718 CHECK_EQ(0, processed);
2719
2720 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 0.0, &processed, &all_used));
2721 CHECK_EQ(0, processed);
2722
2723 CHECK_EQ(Double::NaN(), StrToD("0x", flags, 0.0,
2724 &processed, &all_used));
2725 CHECK_EQ(0, processed);
2726
2727 CHECK_EQ(Double::NaN(), StrToD(" 0x ", flags, 0.0,
2728 &processed, &all_used));
2729 CHECK_EQ(0, processed);
2730
2731 CHECK_EQ(Double::NaN(), StrToD(" 0x 3", flags, 0.0,
2732 &processed, &all_used));
2733 CHECK_EQ(0, processed);
2734
2735 CHECK_EQ(3.0, StrToD("0x3g", flags, 0.0, &processed, &all_used));
2736 CHECK_EQ(3, processed);
2737
2738 CHECK_EQ(3.0, StrToD("0x3.234", flags, 0.0, &processed, &all_used));
2739 CHECK_EQ(3, processed);
2740
2741 CHECK_EQ(Double::NaN(), StrToD(" 0x3g", flags, 0.0, &processed, &all_used));
2742 CHECK_EQ(0, processed);
2743
2744 CHECK_EQ(Double::NaN(),
2745 StrToD(" 0x3.234", flags, 0.0, &processed, &all_used));
2746 CHECK_EQ(0, processed);
2747
2748 CHECK_EQ(Double::NaN(), StrToD("x3", flags, 0.0,
2749 &processed, &all_used));
2750 CHECK_EQ(0, processed);
2751
2752 CHECK_EQ(Double::NaN(), StrToD("+ 0x3 foo", flags, 0.0,
2753 &processed, &all_used));
2754 CHECK_EQ(0, processed);
2755
2756 CHECK_EQ(Double::NaN(), StrToD("+", flags, 0.0, &processed, &all_used));
2757 CHECK_EQ(0, processed);
2758
2759 CHECK_EQ(Double::NaN(), StrToD("-", flags, 0.0, &processed, &all_used));
2760 CHECK_EQ(0, processed);
2761
2762 CHECK_EQ(-5.0, StrToD("-0x5", flags, 0.0, &processed, &all_used));
2763 CHECK(all_used);
2764
2765 CHECK_EQ(Double::NaN(), StrToD(" - 0x5 ", flags, 0.0, &processed, &all_used));
2766 CHECK_EQ(0, processed);
2767
2768 CHECK_EQ(Double::NaN(), StrToD(" + 0x5 ", flags, 0.0, &processed, &all_used));
2769 CHECK_EQ(0, processed);
2770
2771 CHECK_EQ(Double::NaN(), StrToD("- -0x5", flags, 0.0, &processed, &all_used));
2772 CHECK_EQ(0, processed);
2773
2774 CHECK_EQ(Double::NaN(), StrToD("- +0x5", flags, 0.0, &processed, &all_used));
2775 CHECK_EQ(0, processed);
2776
2777 CHECK_EQ(Double::NaN(), StrToD("+ +0x5", flags, 0.0, &processed, &all_used));
2778 CHECK_EQ(0, processed);
2779
2780 flags = StringToDoubleConverter::ALLOW_TRAILING_JUNK |
2781 StringToDoubleConverter::ALLOW_LEADING_SPACES |
2782 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
2783 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN |
2784 StringToDoubleConverter::ALLOW_HEX;
2785
2786 CHECK_EQ(18.0, StrToD("0x12", flags, 0.0, &processed, &all_used));
2787 CHECK(all_used);
2788
2789 CHECK_EQ(0.0, StrToD("0x0", flags, 1.0, &processed, &all_used));
2790 CHECK(all_used);
2791
2792 CHECK_EQ(static_cast<double>(0x123456789),
2793 StrToD("0x123456789", flags, Double::NaN(), &processed, &all_used));
2794 CHECK(all_used);
2795
2796 CHECK_EQ(18.0, StrToD(" 0x12 ", flags, 0.0, &processed, &all_used));
2797 CHECK(all_used);
2798
2799 CHECK_EQ(0.0, StrToD(" 0x0 ", flags, 1.0, &processed, &all_used));
2800 CHECK(all_used);
2801
2802 CHECK_EQ(static_cast<double>(0x123456789),
2803 StrToD(" 0x123456789 ", flags, Double::NaN(),
2804 &processed, &all_used));
2805 CHECK(all_used);
2806
2807 CHECK_EQ(static_cast<double>(0xabcdef),
2808 StrToD("0xabcdef", flags, 0.0, &processed, &all_used));
2809 CHECK(all_used);
2810
2811 CHECK_EQ(static_cast<double>(0xabcdef),
2812 StrToD("0xABCDEF", flags, 0.0, &processed, &all_used));
2813 CHECK(all_used);
2814
2815 CHECK_EQ(static_cast<double>(0xabcdef),
2816 StrToD(" 0xabcdef ", flags, 0.0, &processed, &all_used));
2817 CHECK(all_used);
2818
2819 CHECK_EQ(static_cast<double>(0xabcdef),
2820 StrToD(" 0xABCDEF ", flags, 0.0, &processed, &all_used));
2821 CHECK(all_used);
2822
2823 CHECK_EQ(static_cast<double>(0xabc),
2824 StrToD(" 0xabc def ", flags, 0.0, &processed, &all_used));
2825 CHECK_EQ(7, processed);
2826
2827 CHECK_EQ(static_cast<double>(0xabc),
2828 StrToD(" 0xABC DEF ", flags, 0.0, &processed, &all_used));
2829 CHECK_EQ(7, processed);
2830
2831 CHECK_EQ(static_cast<double>(0x12),
2832 StrToD(" 0x12 ", flags, 0.0, &processed, &all_used));
2833 CHECK(all_used);
2834
2835 CHECK_EQ(0.0, StrToD(" 0x0 ", flags, 1.0, &processed, &all_used));
2836 CHECK(all_used);
2837
2838 CHECK_EQ(static_cast<double>(0x123456789),
2839 StrToD(" 0x123456789 ", flags, Double::NaN(),
2840 &processed, &all_used));
2841 CHECK(all_used);
2842
2843 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
2844 &processed, &all_used));
2845 CHECK(all_used);
2846
2847 CHECK_EQ(Double::NaN(), StrToD("0x", flags, 0.0,
2848 &processed, &all_used));
2849 CHECK_EQ(0, processed);
2850
2851 CHECK_EQ(Double::NaN(), StrToD(" 0x ", flags, 0.0,
2852 &processed, &all_used));
2853 CHECK_EQ(0, processed);
2854
2855 CHECK_EQ(Double::NaN(), StrToD(" 0x 3", flags, 0.0,
2856 &processed, &all_used));
2857 CHECK_EQ(0, processed);
2858
2859 CHECK_EQ((double)0x3, StrToD("0x3g", flags, 0.0, &processed, &all_used));
2860 CHECK_EQ(3, processed);
2861
2862 CHECK_EQ((double)0x3, StrToD("0x3.234", flags, 0.0, &processed, &all_used));
2863 CHECK_EQ(3, processed);
2864
2865 CHECK_EQ(Double::NaN(), StrToD("x3", flags, 0.0,
2866 &processed, &all_used));
2867 CHECK_EQ(0, processed);
2868
2869 CHECK_EQ(-5.634002666912405e+27, StrToD("-0x123456789012345678901234",
2870 flags, 0.0,
2871 &processed, &all_used));
2872 CHECK(all_used);
2873
2874 CHECK_EQ(72057594037927940.0, StrToD("0x100000000000001", flags, 0.0,
2875 &processed, &all_used));
2876 CHECK(all_used);
2877
2878 CHECK_EQ(72057594037927940.0, StrToD("0x100000000000000", flags, 0.0,
2879 &processed, &all_used));
2880 CHECK(all_used);
2881
2882 CHECK_EQ(295147905179352830000.0, StrToD("0x100000000000000001", flags, 0.0,
2883 &processed, &all_used));
2884 CHECK(all_used);
2885
2886 CHECK_EQ(295147905179352830000.0, StrToD("0x100000000000000000", flags, 0.0,
2887 &processed, &all_used));
2888 CHECK(all_used);
2889
2890 CHECK_EQ(295147905179352900000.0, StrToD("0x100000000000008001", flags, 0.0,
2891 &processed, &all_used));
2892 CHECK(all_used);
2893
2894 CHECK_EQ(295147905179352830000.0, StrToD("0x100000000000008000", flags, 0.0,
2895 &processed, &all_used));
2896 CHECK(all_used);
2897
2898 CHECK_EQ(295147905179352960000.0, StrToD("0x100000000000018001", flags, 0.0,
2899 &processed, &all_used));
2900 CHECK(all_used);
2901
2902 CHECK_EQ(295147905179352960000.0, StrToD("0x100000000000018000", flags, 0.0,
2903 &processed, &all_used));
2904 CHECK(all_used);
2905
2906 flags = StringToDoubleConverter::ALLOW_HEX_FLOATS;
2907
2908 CHECK_EQ(3.0, StrToD("0x3p0", flags, 0.0, &processed, &all_used));
2909 CHECK(all_used);
2910
2911 CHECK_EQ(0.0, StrToD("0x.0p0", flags, 0.0, &processed, &all_used));
2912 CHECK(all_used);
2913
2914 CHECK_EQ(3.0, StrToD("0x3.0p0", flags, 0.0, &processed, &all_used));
2915 CHECK(all_used);
2916
2917 CHECK_EQ(3.0, StrToD("0x3.p0", flags, 0.0, &processed, &all_used));
2918 CHECK(all_used);
2919
2920 CHECK_EQ(-5.634002666912405e+27, StrToD("-0x123456789012345678901234p0",
2921 flags, 0.0,
2922 &processed, &all_used));
2923 CHECK(all_used);
2924
2925 CHECK_EQ(72057594037927940.0, StrToD("0x100000000000001p0", flags, 0.0,
2926 &processed, &all_used));
2927 CHECK(all_used);
2928
2929 CHECK_EQ(72057594037927940.0, StrToD("0x100000000000000p0", flags, 0.0,
2930 &processed, &all_used));
2931 CHECK(all_used);
2932
2933 CHECK_EQ(295147905179352830000.0, StrToD("0x100000000000000001p0", flags, 0.0,
2934 &processed, &all_used));
2935 CHECK(all_used);
2936
2937 CHECK_EQ(295147905179352830000.0, StrToD("0x100000000000000000p0", flags, 0.0,
2938 &processed, &all_used));
2939 CHECK(all_used);
2940
2941 CHECK_EQ(295147905179352900000.0, StrToD("0x100000000000008001p0", flags, 0.0,
2942 &processed, &all_used));
2943 CHECK(all_used);
2944
2945 CHECK_EQ(295147905179352830000.0, StrToD("0x100000000000008000p0", flags, 0.0,
2946 &processed, &all_used));
2947 CHECK(all_used);
2948
2949 CHECK_EQ(295147905179352960000.0, StrToD("0x100000000000018001p0", flags, 0.0,
2950 &processed, &all_used));
2951 CHECK(all_used);
2952
2953 CHECK_EQ(295147905179352960000.0, StrToD("0x100000000000018000p0", flags, 0.0,
2954 &processed, &all_used));
2955 CHECK(all_used);
2956
2957 CHECK_EQ(4.722366482869645e+21, StrToD("0x100000000000000001p4", flags, 0.0,
2958 &processed, &all_used));
2959 CHECK(all_used);
2960
2961 CHECK_EQ(4.722366482869645e+21, StrToD("0x100000000000000000p+4", flags, 0.0,
2962 &processed, &all_used));
2963 CHECK(all_used);
2964
2965 CHECK_EQ(4.722366482869646e+21, StrToD("0x100000000000008001p04", flags, 0.0,
2966 &processed, &all_used));
2967 CHECK(all_used);
2968
2969 CHECK_EQ(18446744073709552000.0, StrToD("0x100000000000008000p-4", flags, 0.0,
2970 &processed, &all_used));
2971 CHECK(all_used);
2972
2973 CHECK_EQ(18446744073709560000.0, StrToD("0x100000000000018001p-04", flags, 0.0,
2974 &processed, &all_used));
2975 CHECK(all_used);
2976
2977 CHECK_EQ(4.722366482869647e+21, StrToD("0x100000000000018000p4", flags, 0.0,
2978 &processed, &all_used));
2979 CHECK(all_used);
2980
2981 CHECK_EQ(Double::Infinity(), StrToD("0x1p2000", flags, 0.0,
2982 &processed, &all_used));
2983 CHECK(all_used);
2984
2985 CHECK_EQ(0.0, StrToD("0x1p-2000", flags, 0.0, &processed, &all_used));
2986 CHECK(all_used);
2987
2988 CHECK_EQ(-0.0, StrToD("-0x1p-2000", flags, 0.0, &processed, &all_used));
2989 CHECK(all_used);
2990
2991 CHECK_EQ(Double::NaN(), StrToD(" ", flags, Double::NaN(),
2992 &processed, &all_used));
2993 CHECK_EQ(0, processed);
2994
2995 CHECK_EQ(Double::NaN(), StrToD("0x", flags, 0.0,
2996 &processed, &all_used));
2997 CHECK_EQ(0, processed);
2998
2999 CHECK_EQ(Double::NaN(), StrToD(" 0x ", flags, 0.0,
3000 &processed, &all_used));
3001 CHECK_EQ(0, processed);
3002
3003 CHECK_EQ(Double::NaN(), StrToD(" 0x 3", flags, 0.0,
3004 &processed, &all_used));
3005 CHECK_EQ(0, processed);
3006
3007 CHECK_EQ(Double::NaN(), StrToD("0x3g", flags, 0.0,
3008 &processed, &all_used));
3009 CHECK_EQ(0, processed);
3010
3011 CHECK_EQ(Double::NaN(), StrToD("x3", flags, 0.0,
3012 &processed, &all_used));
3013 CHECK_EQ(0, processed);
3014
3015 CHECK_EQ(Double::NaN(), StrToD("0x3 foo", flags, 0.0,
3016 &processed, &all_used));
3017 CHECK_EQ(0, processed);
3018
3019 CHECK_EQ(Double::NaN(), StrToD(" 0x3 foo", flags, 0.0,
3020 &processed, &all_used));
3021 CHECK_EQ(0, processed);
3022
3023 CHECK_EQ(Double::NaN(), StrToD("+ 0x3 foo", flags, 0.0,
3024 &processed, &all_used));
3025 CHECK_EQ(0, processed);
3026
3027 CHECK_EQ(Double::NaN(), StrToD("+", flags, 0.0, &processed, &all_used));
3028 CHECK_EQ(0, processed);
3029
3030 CHECK_EQ(Double::NaN(), StrToD("-", flags, 0.0, &processed, &all_used));
3031 CHECK_EQ(0, processed);
3032
3033 CHECK_EQ(Double::NaN(), StrToD("- -0x5", flags, 0.0, &processed, &all_used));
3034 CHECK_EQ(0, processed);
3035
3036 CHECK_EQ(Double::NaN(), StrToD("- +0x5", flags, 0.0, &processed, &all_used));
3037 CHECK_EQ(0, processed);
3038
3039 CHECK_EQ(Double::NaN(), StrToD("+ +0x5", flags, 0.0, &processed, &all_used));
3040 CHECK_EQ(0, processed);
3041
3042 CHECK_EQ(Double::NaN(), StrToD("0xp1", flags, 0.0, &processed, &all_used));
3043 CHECK_EQ(0, processed);
3044
3045 CHECK_EQ(Double::NaN(), StrToD("0x.p1", flags, 0.0, &processed, &all_used));
3046 CHECK_EQ(0, processed);
3047
3048 CHECK_EQ(Double::Infinity(), StrToD("0x1.p10000000000000000", flags, 0.0,
3049 &processed, &all_used));
3050 CHECK(all_used);
3051
3052 CHECK_EQ(0.0, StrToD("0x1.p-10000000000000000", flags, 0.0,
3053 &processed, &all_used));
3054 CHECK(all_used);
3055 }
3056
3057
TEST(StringToDoubleOctalString)3058 TEST(StringToDoubleOctalString) {
3059 int flags;
3060 int processed;
3061 bool all_used;
3062
3063 flags = StringToDoubleConverter::ALLOW_OCTALS |
3064 StringToDoubleConverter::ALLOW_LEADING_SPACES |
3065 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
3066 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
3067
3068 CHECK_EQ(10.0, StrToD("012", flags, 0.0, &processed, &all_used));
3069 CHECK(all_used);
3070
3071 CHECK_EQ(0.0, StrToD("00", flags, 1.0, &processed, &all_used));
3072 CHECK(all_used);
3073
3074 CHECK_EQ(10.0, StrToD("012", flags, 1.0, &processed, &all_used));
3075 CHECK(all_used);
3076
3077 CHECK_EQ(123456789.0,
3078 StrToD("0123456789", flags, Double::NaN(), &processed, &all_used));
3079 CHECK(all_used);
3080
3081 CHECK_EQ(342391.0,
3082 StrToD("01234567", flags, Double::NaN(), &processed, &all_used));
3083 CHECK(all_used);
3084
3085 CHECK_EQ(342391.0,
3086 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
3087 CHECK(all_used);
3088
3089 CHECK_EQ(-342391.0,
3090 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
3091 CHECK(all_used);
3092
3093 CHECK_EQ(10.0, StrToD(" 012", flags, 0.0, &processed, &all_used));
3094 CHECK(all_used);
3095
3096 CHECK_EQ(10.0, StrToD("\n012", flags, 0.0, &processed, &all_used));
3097 CHECK(all_used);
3098
3099 CHECK_EQ(0.0, StrToD(" 00", flags, 1.0, &processed, &all_used));
3100 CHECK(all_used);
3101
3102 CHECK_EQ(0.0, StrToD("\t00", flags, 1.0, &processed, &all_used));
3103 CHECK(all_used);
3104
3105 CHECK_EQ(10.0, StrToD(" 012", flags, 1.0, &processed, &all_used));
3106 CHECK(all_used);
3107
3108 CHECK_EQ(10.0, StrToD("\n012", flags, 1.0, &processed, &all_used));
3109 CHECK(all_used);
3110
3111 CHECK_EQ(123456789.0,
3112 StrToD(" 0123456789", flags, Double::NaN(), &processed, &all_used));
3113 CHECK(all_used);
3114
3115 CHECK_EQ(342391.0,
3116 StrToD(" 01234567", flags, Double::NaN(), &processed, &all_used));
3117 CHECK(all_used);
3118
3119 CHECK_EQ(342391.0,
3120 StrToD("\n01234567", flags, Double::NaN(), &processed, &all_used));
3121 CHECK(all_used);
3122
3123 CHECK_EQ(342391.0,
3124 StrToD(" + 01234567", flags, Double::NaN(), &processed, &all_used));
3125 CHECK(all_used);
3126
3127 CHECK_EQ(-342391.0,
3128 StrToD(" - 01234567", flags, Double::NaN(), &processed, &all_used));
3129 CHECK(all_used);
3130
3131 CHECK_EQ(-342391.0,
3132 StrToD("\n-\t01234567", flags, Double::NaN(), &processed, &all_used));
3133 CHECK(all_used);
3134
3135 CHECK_EQ(10.0, StrToD(" 012 ", flags, 0.0, &processed, &all_used));
3136 CHECK(all_used);
3137
3138 CHECK_EQ(0.0, StrToD(" 00 ", flags, 1.0, &processed, &all_used));
3139 CHECK(all_used);
3140
3141 CHECK_EQ(10.0, StrToD(" 012 ", flags, 1.0, &processed, &all_used));
3142 CHECK(all_used);
3143
3144 CHECK_EQ(123456789.0,
3145 StrToD(" 0123456789 ", flags, Double::NaN(), &processed, &all_used));
3146 CHECK(all_used);
3147
3148 CHECK_EQ(342391.0,
3149 StrToD(" 01234567 ", flags, Double::NaN(), &processed, &all_used));
3150 CHECK(all_used);
3151
3152 CHECK_EQ(342391.0,
3153 StrToD(" + 01234567 ", flags, Double::NaN(), &processed, &all_used));
3154 CHECK(all_used);
3155
3156 CHECK_EQ(-342391.0,
3157 StrToD(" - 01234567 ", flags, Double::NaN(), &processed, &all_used));
3158 CHECK(all_used);
3159
3160 CHECK_EQ(10.0, StrToD("012 ", flags, 0.0, &processed, &all_used));
3161 CHECK(all_used);
3162
3163 CHECK_EQ(0.0, StrToD("00 ", flags, 1.0, &processed, &all_used));
3164 CHECK(all_used);
3165
3166 CHECK_EQ(10.0, StrToD("012 ", flags, 1.0, &processed, &all_used));
3167 CHECK(all_used);
3168
3169 CHECK_EQ(123456789.0,
3170 StrToD("0123456789 ", flags, Double::NaN(), &processed, &all_used));
3171 CHECK(all_used);
3172
3173 CHECK_EQ(342391.0,
3174 StrToD("01234567 ", flags, Double::NaN(), &processed, &all_used));
3175 CHECK(all_used);
3176
3177 CHECK_EQ(342391.0,
3178 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
3179 CHECK(all_used);
3180
3181 CHECK_EQ(-342391.0,
3182 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
3183 CHECK(all_used);
3184
3185 CHECK_EQ(Double::NaN(),
3186 StrToD("01234567e0", flags, Double::NaN(), &processed, &all_used));
3187 CHECK_EQ(0, processed);
3188
3189
3190 flags = StringToDoubleConverter::ALLOW_OCTALS;
3191 CHECK_EQ(10.0, StrToD("012", flags, 0.0, &processed, &all_used));
3192 CHECK(all_used);
3193
3194 CHECK_EQ(0.0, StrToD("00", flags, 1.0, &processed, &all_used));
3195 CHECK(all_used);
3196
3197 CHECK_EQ(10.0, StrToD("012", flags, 1.0, &processed, &all_used));
3198 CHECK(all_used);
3199
3200 CHECK_EQ(123456789.0,
3201 StrToD("0123456789", flags, Double::NaN(), &processed, &all_used));
3202 CHECK(all_used);
3203
3204 CHECK_EQ(342391.0,
3205 StrToD("01234567", flags, Double::NaN(), &processed, &all_used));
3206 CHECK(all_used);
3207
3208 CHECK_EQ(342391.0,
3209 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
3210 CHECK(all_used);
3211
3212 CHECK_EQ(-342391.0,
3213 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
3214 CHECK(all_used);
3215
3216 CHECK_EQ(Double::NaN(), StrToD(" 012", flags, 0.0, &processed, &all_used));
3217 CHECK_EQ(0, processed);
3218
3219 CHECK_EQ(Double::NaN(), StrToD(" 00", flags, 1.0, &processed, &all_used));
3220 CHECK_EQ(0, processed);
3221
3222 CHECK_EQ(Double::NaN(), StrToD(" 012", flags, 1.0, &processed, &all_used));
3223 CHECK_EQ(0, processed);
3224
3225 CHECK_EQ(Double::NaN(),
3226 StrToD(" 0123456789", flags, Double::NaN(), &processed, &all_used));
3227 CHECK_EQ(0, processed);
3228
3229 CHECK_EQ(Double::NaN(),
3230 StrToD(" 01234567", flags, Double::NaN(), &processed, &all_used));
3231 CHECK_EQ(0, processed);
3232
3233 CHECK_EQ(Double::NaN(),
3234 StrToD(" + 01234567", flags, Double::NaN(), &processed, &all_used));
3235 CHECK_EQ(0, processed);
3236
3237 CHECK_EQ(Double::NaN(),
3238 StrToD(" - 01234567", flags, Double::NaN(), &processed, &all_used));
3239 CHECK_EQ(0, processed);
3240
3241 CHECK_EQ(Double::NaN(), StrToD(" 012 ", flags, 0.0, &processed, &all_used));
3242 CHECK_EQ(0, processed);
3243
3244 CHECK_EQ(Double::NaN(), StrToD(" 00 ", flags, 1.0, &processed, &all_used));
3245 CHECK_EQ(0, processed);
3246
3247 CHECK_EQ(Double::NaN(), StrToD(" 012 ", flags, 1.0, &processed, &all_used));
3248 CHECK_EQ(0, processed);
3249
3250 CHECK_EQ(Double::NaN(),
3251 StrToD(" 0123456789 ", flags, Double::NaN(), &processed, &all_used));
3252 CHECK_EQ(0, processed);
3253
3254 CHECK_EQ(Double::NaN(),
3255 StrToD(" 01234567 ", flags, Double::NaN(), &processed, &all_used));
3256 CHECK_EQ(0, processed);
3257
3258 CHECK_EQ(Double::NaN(),
3259 StrToD(" + 01234567 ", flags, Double::NaN(), &processed, &all_used));
3260 CHECK_EQ(0, processed);
3261
3262 CHECK_EQ(Double::NaN(),
3263 StrToD(" - 01234567 ", flags, Double::NaN(), &processed, &all_used));
3264 CHECK_EQ(0, processed);
3265
3266 CHECK_EQ(Double::NaN(), StrToD("012 ", flags, 0.0, &processed, &all_used));
3267 CHECK_EQ(0, processed);
3268
3269 CHECK_EQ(Double::NaN(), StrToD("00 ", flags, 1.0, &processed, &all_used));
3270 CHECK_EQ(0, processed);
3271
3272 CHECK_EQ(Double::NaN(), StrToD("012 ", flags, 1.0, &processed, &all_used));
3273 CHECK_EQ(0, processed);
3274
3275 CHECK_EQ(Double::NaN(),
3276 StrToD("0123456789 ", flags, Double::NaN(), &processed, &all_used));
3277 CHECK_EQ(0, processed);
3278
3279 CHECK_EQ(Double::NaN(),
3280 StrToD("01234567 ", flags, Double::NaN(), &processed, &all_used));
3281 CHECK_EQ(0, processed);
3282
3283 CHECK_EQ(342391.0,
3284 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
3285 CHECK(all_used);
3286
3287 CHECK_EQ(-342391.0,
3288 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
3289 CHECK(all_used);
3290
3291 CHECK_EQ(Double::NaN(),
3292 StrToD("01234567e0", flags, Double::NaN(), &processed, &all_used));
3293 CHECK_EQ(0, processed);
3294
3295
3296 flags = StringToDoubleConverter::ALLOW_OCTALS |
3297 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
3298 CHECK_EQ(10.0, StrToD("012", flags, 0.0, &processed, &all_used));
3299 CHECK(all_used);
3300
3301 CHECK_EQ(0.0, StrToD("00", flags, 1.0, &processed, &all_used));
3302 CHECK(all_used);
3303
3304 CHECK_EQ(10.0, StrToD("012", flags, 1.0, &processed, &all_used));
3305 CHECK(all_used);
3306
3307 CHECK_EQ(123456789.0,
3308 StrToD("0123456789", flags, Double::NaN(), &processed, &all_used));
3309 CHECK(all_used);
3310
3311 CHECK_EQ(342391.0,
3312 StrToD("01234567", flags, Double::NaN(), &processed, &all_used));
3313 CHECK(all_used);
3314
3315 CHECK_EQ(342391.0,
3316 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
3317 CHECK(all_used);
3318
3319 CHECK_EQ(-342391.0,
3320 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
3321 CHECK(all_used);
3322
3323 CHECK_EQ(Double::NaN(), StrToD(" 012", flags, 0.0, &processed, &all_used));
3324 CHECK_EQ(0, processed);
3325
3326 CHECK_EQ(Double::NaN(), StrToD(" 00", flags, 1.0, &processed, &all_used));
3327 CHECK_EQ(0, processed);
3328
3329 CHECK_EQ(Double::NaN(), StrToD(" 012", flags, 1.0, &processed, &all_used));
3330 CHECK_EQ(0, processed);
3331
3332 CHECK_EQ(Double::NaN(),
3333 StrToD(" 0123456789", flags, Double::NaN(), &processed, &all_used));
3334 CHECK_EQ(0, processed);
3335
3336 CHECK_EQ(Double::NaN(),
3337 StrToD(" 01234567", flags, Double::NaN(), &processed, &all_used));
3338 CHECK_EQ(0, processed);
3339
3340 CHECK_EQ(Double::NaN(),
3341 StrToD(" + 01234567", flags, Double::NaN(), &processed, &all_used));
3342 CHECK_EQ(0, processed);
3343
3344 CHECK_EQ(Double::NaN(),
3345 StrToD(" - 01234567", flags, Double::NaN(), &processed, &all_used));
3346 CHECK_EQ(0, processed);
3347
3348 CHECK_EQ(Double::NaN(), StrToD(" 012 ", flags, 0.0, &processed, &all_used));
3349 CHECK_EQ(0, processed);
3350
3351 CHECK_EQ(Double::NaN(), StrToD(" 00 ", flags, 1.0, &processed, &all_used));
3352 CHECK_EQ(0, processed);
3353
3354 CHECK_EQ(Double::NaN(), StrToD(" 012 ", flags, 1.0, &processed, &all_used));
3355 CHECK_EQ(0, processed);
3356
3357 CHECK_EQ(Double::NaN(),
3358 StrToD(" 0123456789 ", flags, Double::NaN(), &processed, &all_used));
3359 CHECK_EQ(0, processed);
3360
3361 CHECK_EQ(Double::NaN(),
3362 StrToD(" 01234567 ", flags, Double::NaN(), &processed, &all_used));
3363 CHECK_EQ(0, processed);
3364
3365 CHECK_EQ(Double::NaN(),
3366 StrToD(" + 01234567 ", flags, Double::NaN(), &processed, &all_used));
3367 CHECK_EQ(0, processed);
3368
3369 CHECK_EQ(Double::NaN(),
3370 StrToD(" - 01234567 ", flags, Double::NaN(), &processed, &all_used));
3371 CHECK_EQ(0, processed);
3372
3373 CHECK_EQ(10.0, StrToD("012 ", flags, 0.0, &processed, &all_used));
3374 CHECK_EQ(3, processed);
3375
3376 CHECK_EQ(0.0, StrToD("00 ", flags, 1.0, &processed, &all_used));
3377 CHECK_EQ(2, processed);
3378
3379 CHECK_EQ(123456789.0,
3380 StrToD("0123456789 ", flags, Double::NaN(), &processed, &all_used));
3381 CHECK_EQ(10, processed);
3382
3383 CHECK_EQ(342391.0,
3384 StrToD("01234567 ", flags, Double::NaN(), &processed, &all_used));
3385 CHECK_EQ(8, processed);
3386
3387 CHECK_EQ(342391.0,
3388 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
3389 CHECK(all_used);
3390
3391 CHECK_EQ(-342391.0,
3392 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
3393 CHECK(all_used);
3394
3395 CHECK_EQ(10.0, StrToD("012foo ", flags, 0.0, &processed, &all_used));
3396 CHECK_EQ(3, processed);
3397
3398 CHECK_EQ(0.0, StrToD("00foo ", flags, 1.0, &processed, &all_used));
3399 CHECK_EQ(2, processed);
3400
3401 CHECK_EQ(123456789.0,
3402 StrToD("0123456789foo ", flags, Double::NaN(),
3403 &processed, &all_used));
3404 CHECK_EQ(10, processed);
3405
3406 CHECK_EQ(342391.0,
3407 StrToD("01234567foo ", flags, Double::NaN(), &processed, &all_used));
3408 CHECK_EQ(8, processed);
3409
3410 CHECK_EQ(342391.0,
3411 StrToD("+01234567foo", flags, Double::NaN(), &processed, &all_used));
3412 CHECK_EQ(9, processed);
3413
3414 CHECK_EQ(-342391.0,
3415 StrToD("-01234567foo", flags, Double::NaN(), &processed, &all_used));
3416 CHECK_EQ(9, processed);
3417
3418 CHECK_EQ(10.0, StrToD("012 foo ", flags, 0.0, &processed, &all_used));
3419 CHECK_EQ(3, processed);
3420
3421 CHECK_EQ(0.0, StrToD("00 foo ", flags, 1.0, &processed, &all_used));
3422 CHECK_EQ(2, processed);
3423
3424 CHECK_EQ(123456789.0,
3425 StrToD("0123456789 foo ", flags, Double::NaN(),
3426 &processed, &all_used));
3427 CHECK_EQ(10, processed);
3428
3429 CHECK_EQ(342391.0,
3430 StrToD("01234567 foo ", flags, Double::NaN(),
3431 &processed, &all_used));
3432 CHECK_EQ(8, processed);
3433
3434 CHECK_EQ(342391.0,
3435 StrToD("+01234567 foo", flags, Double::NaN(),
3436 &processed, &all_used));
3437 CHECK_EQ(9, processed);
3438
3439 CHECK_EQ(-342391.0,
3440 StrToD("-01234567 foo", flags, Double::NaN(), &processed,
3441 &all_used));
3442 CHECK_EQ(9, processed);
3443
3444 CHECK_EQ(342391.0,
3445 StrToD("01234567e0", flags, Double::NaN(), &processed, &all_used));
3446 CHECK_EQ(8, processed);
3447
3448 CHECK_EQ(342391.0,
3449 StrToD("01234567e", flags, Double::NaN(), &processed, &all_used));
3450 CHECK_EQ(8, processed);
3451
3452 flags = StringToDoubleConverter::ALLOW_OCTALS |
3453 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
3454 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
3455 CHECK_EQ(10.0, StrToD("012", flags, 0.0, &processed, &all_used));
3456 CHECK(all_used);
3457
3458 CHECK_EQ(0.0, StrToD("00", flags, 1.0, &processed, &all_used));
3459 CHECK(all_used);
3460
3461 CHECK_EQ(10.0, StrToD("012", flags, 1.0, &processed, &all_used));
3462 CHECK(all_used);
3463
3464 CHECK_EQ(123456789.0,
3465 StrToD("0123456789", flags, Double::NaN(), &processed, &all_used));
3466 CHECK(all_used);
3467
3468 CHECK_EQ(342391.0,
3469 StrToD("01234567", flags, Double::NaN(), &processed, &all_used));
3470 CHECK(all_used);
3471
3472 CHECK_EQ(342391.0,
3473 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
3474 CHECK(all_used);
3475
3476 CHECK_EQ(-342391.0,
3477 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
3478 CHECK(all_used);
3479
3480 CHECK_EQ(Double::NaN(), StrToD(" 012", flags, 0.0, &processed, &all_used));
3481 CHECK_EQ(0, processed);
3482
3483 CHECK_EQ(Double::NaN(), StrToD(" 00", flags, 1.0, &processed, &all_used));
3484 CHECK_EQ(0, processed);
3485
3486 CHECK_EQ(Double::NaN(), StrToD(" 012", flags, 1.0, &processed, &all_used));
3487 CHECK_EQ(0, processed);
3488
3489 CHECK_EQ(Double::NaN(),
3490 StrToD(" 0123456789", flags, Double::NaN(), &processed, &all_used));
3491 CHECK_EQ(0, processed);
3492
3493 CHECK_EQ(Double::NaN(),
3494 StrToD(" 01234567", flags, Double::NaN(), &processed, &all_used));
3495 CHECK_EQ(0, processed);
3496
3497 CHECK_EQ(Double::NaN(),
3498 StrToD(" + 01234567", flags, Double::NaN(), &processed, &all_used));
3499 CHECK_EQ(0, processed);
3500
3501 CHECK_EQ(Double::NaN(),
3502 StrToD(" - 01234567", flags, Double::NaN(), &processed, &all_used));
3503 CHECK_EQ(0, processed);
3504
3505 CHECK_EQ(Double::NaN(), StrToD(" 012 ", flags, 0.0, &processed, &all_used));
3506 CHECK_EQ(0, processed);
3507
3508 CHECK_EQ(Double::NaN(), StrToD(" 00 ", flags, 1.0, &processed, &all_used));
3509 CHECK_EQ(0, processed);
3510
3511 CHECK_EQ(Double::NaN(), StrToD(" 012 ", flags, 1.0, &processed, &all_used));
3512 CHECK_EQ(0, processed);
3513
3514 CHECK_EQ(Double::NaN(),
3515 StrToD(" 0123456789 ", flags, Double::NaN(), &processed, &all_used));
3516 CHECK_EQ(0, processed);
3517
3518 CHECK_EQ(Double::NaN(),
3519 StrToD(" 01234567 ", flags, Double::NaN(), &processed, &all_used));
3520 CHECK_EQ(0, processed);
3521
3522 CHECK_EQ(Double::NaN(),
3523 StrToD(" + 01234567 ", flags, Double::NaN(), &processed, &all_used));
3524 CHECK_EQ(0, processed);
3525
3526 CHECK_EQ(Double::NaN(),
3527 StrToD(" - 01234567 ", flags, Double::NaN(), &processed, &all_used));
3528 CHECK_EQ(0, processed);
3529
3530 CHECK_EQ(10.0, StrToD("012 ", flags, 0.0, &processed, &all_used));
3531 CHECK(all_used);
3532
3533 CHECK_EQ(0.0, StrToD("00 ", flags, 1.0, &processed, &all_used));
3534 CHECK(all_used);
3535
3536 CHECK_EQ(123456789.0,
3537 StrToD("0123456789 ", flags, Double::NaN(), &processed, &all_used));
3538 CHECK(all_used);
3539
3540 CHECK_EQ(342391.0,
3541 StrToD("01234567 ", flags, Double::NaN(), &processed, &all_used));
3542 CHECK(all_used);
3543
3544 CHECK_EQ(342391.0,
3545 StrToD("+01234567", flags, Double::NaN(), &processed, &all_used));
3546 CHECK(all_used);
3547
3548 CHECK_EQ(-342391.0,
3549 StrToD("-01234567", flags, Double::NaN(), &processed, &all_used));
3550 CHECK(all_used);
3551
3552 CHECK_EQ(10.0, StrToD("012foo ", flags, 0.0, &processed, &all_used));
3553 CHECK_EQ(3, processed);
3554
3555 CHECK_EQ(0.0, StrToD("00foo ", flags, 1.0, &processed, &all_used));
3556 CHECK_EQ(2, processed);
3557
3558 CHECK_EQ(123456789.0,
3559 StrToD("0123456789foo ", flags, Double::NaN(),
3560 &processed, &all_used));
3561 CHECK_EQ(10, processed);
3562
3563 CHECK_EQ(342391.0,
3564 StrToD("01234567foo ", flags, Double::NaN(), &processed, &all_used));
3565 CHECK_EQ(8, processed);
3566
3567 CHECK_EQ(342391.0,
3568 StrToD("+01234567foo", flags, Double::NaN(), &processed, &all_used));
3569 CHECK_EQ(9, processed);
3570
3571 CHECK_EQ(-342391.0,
3572 StrToD("-01234567foo", flags, Double::NaN(), &processed, &all_used));
3573 CHECK_EQ(9, processed);
3574
3575 CHECK_EQ(10.0, StrToD("012 foo ", flags, 0.0, &processed, &all_used));
3576 CHECK_EQ(4, processed);
3577
3578 CHECK_EQ(0.0, StrToD("00 foo ", flags, 1.0, &processed, &all_used));
3579 CHECK_EQ(3, processed);
3580
3581 CHECK_EQ(123456789.0,
3582 StrToD("0123456789 foo ", flags, Double::NaN(),
3583 &processed, &all_used));
3584 CHECK_EQ(11, processed);
3585
3586 CHECK_EQ(342391.0,
3587 StrToD("01234567 foo ", flags, Double::NaN(),
3588 &processed, &all_used));
3589 CHECK_EQ(9, processed);
3590
3591 CHECK_EQ(342391.0,
3592 StrToD("+01234567 foo", flags, Double::NaN(),
3593 &processed, &all_used));
3594 CHECK_EQ(10, processed);
3595
3596 CHECK_EQ(-342391.0,
3597 StrToD("-01234567 foo", flags, Double::NaN(),
3598 &processed, &all_used));
3599 CHECK_EQ(10, processed);
3600 }
3601
3602
TEST(StringToDoubleSeparator)3603 TEST(StringToDoubleSeparator) {
3604 int flags;
3605 int processed;
3606 bool all_used;
3607 uc16 separator;
3608
3609 separator = '\'';
3610 flags = StringToDoubleConverter::NO_FLAGS;
3611
3612 CHECK_EQ(1.0, StrToD("000'001.0'0", flags, 0.0,
3613 &processed, &all_used, separator));
3614 CHECK(all_used);
3615
3616 CHECK_EQ(1.0, StrToD("0'0'0'0'0'1.0'0", flags, 0.0,
3617 &processed, &all_used, separator));
3618 CHECK(all_used);
3619
3620 CHECK_EQ(Double::NaN(), StrToD("'1.0", flags, 0.0,
3621 &processed, &all_used, separator));
3622 CHECK_EQ(0, processed);
3623
3624 CHECK_EQ(Double::NaN(), StrToD("1'.0", flags, 0.0,
3625 &processed, &all_used, separator));
3626 CHECK_EQ(0, processed);
3627
3628 CHECK_EQ(Double::NaN(), StrToD("1.'0", flags, 0.0,
3629 &processed, &all_used, separator));
3630 CHECK_EQ(0, processed);
3631
3632 CHECK_EQ(Double::NaN(), StrToD("0''1.0", flags, 0.0,
3633 &processed, &all_used, separator));
3634 CHECK_EQ(0, processed);
3635
3636 CHECK_EQ(Double::NaN(), StrToD("1.0e1'0", flags, 0.0,
3637 &processed, &all_used, separator));
3638 CHECK_EQ(0, processed);
3639
3640 CHECK_EQ(Double::NaN(), StrToD("1.0e1'", flags, 0.0,
3641 &processed, &all_used, separator));
3642 CHECK_EQ(0, processed);
3643
3644 CHECK_EQ(Double::NaN(), StrToD("1.0e'1", flags, 0.0,
3645 &processed, &all_used, separator));
3646 CHECK_EQ(0, processed);
3647
3648 CHECK_EQ(Double::NaN(), StrToD("1.0'e1", flags, 0.0,
3649 &processed, &all_used, separator));
3650 CHECK_EQ(0, processed);
3651
3652 CHECK_EQ(Double::NaN(), StrToD("+'1.0e1", flags, 0.0,
3653 &processed, &all_used, separator));
3654 CHECK_EQ(0, processed);
3655
3656 CHECK_EQ(Double::NaN(), StrToD("-'1.0e1", flags, 0.0,
3657 &processed, &all_used, separator));
3658 CHECK_EQ(0, processed);
3659
3660 CHECK_EQ(Double::NaN(), StrToD("1.0e+'1", flags, 0.0,
3661 &processed, &all_used, separator));
3662 CHECK_EQ(0, processed);
3663
3664 CHECK_EQ(Double::NaN(), StrToD("1.0e-'1", flags, 0.0,
3665 &processed, &all_used, separator));
3666 CHECK_EQ(0, processed);
3667
3668 CHECK_EQ(Double::NaN(), StrToD("1.0e'+1", flags, 0.0,
3669 &processed, &all_used, separator));
3670 CHECK_EQ(0, processed);
3671
3672 CHECK_EQ(Double::NaN(), StrToD("1.0e'-1", flags, 0.0,
3673 &processed, &all_used, separator));
3674 CHECK_EQ(0, processed);
3675
3676 separator = ' ';
3677 flags = StringToDoubleConverter::NO_FLAGS;
3678
3679 CHECK_EQ(1.0, StrToD("000 001.0 0", flags, 0.0,
3680 &processed, &all_used, separator));
3681 CHECK(all_used);
3682
3683 CHECK_EQ(1.0, StrToD("0 0 0 0 0 1.0 0", flags, 0.0,
3684 &processed, &all_used, separator));
3685 CHECK(all_used);
3686
3687 CHECK_EQ(Double::NaN(), StrToD(" 1.0", flags, 0.0,
3688 &processed, &all_used, separator));
3689 CHECK_EQ(0, processed);
3690
3691 CHECK_EQ(Double::NaN(), StrToD("1 .0", flags, 0.0,
3692 &processed, &all_used, separator));
3693 CHECK_EQ(0, processed);
3694
3695 CHECK_EQ(Double::NaN(), StrToD("1. 0", flags, 0.0,
3696 &processed, &all_used, separator));
3697 CHECK_EQ(0, processed);
3698
3699 CHECK_EQ(Double::NaN(), StrToD("0 1.0", flags, 0.0,
3700 &processed, &all_used, separator));
3701 CHECK_EQ(0, processed);
3702
3703 CHECK_EQ(Double::NaN(), StrToD("1.0e1 0", flags, 0.0,
3704 &processed, &all_used, separator));
3705 CHECK_EQ(0, processed);
3706
3707 CHECK_EQ(Double::NaN(), StrToD("1.0e1 ", flags, 0.0,
3708 &processed, &all_used, separator));
3709 CHECK_EQ(0, processed);
3710
3711 CHECK_EQ(Double::NaN(), StrToD("1.0e 1", flags, 0.0,
3712 &processed, &all_used, separator));
3713 CHECK_EQ(0, processed);
3714
3715 CHECK_EQ(Double::NaN(), StrToD("1.0 e1", flags, 0.0,
3716 &processed, &all_used, separator));
3717 CHECK_EQ(0, processed);
3718
3719 CHECK_EQ(Double::NaN(), StrToD("+ 1.0e1", flags, 0.0,
3720 &processed, &all_used, separator));
3721 CHECK_EQ(0, processed);
3722
3723 CHECK_EQ(Double::NaN(), StrToD("- 1.0e1", flags, 0.0,
3724 &processed, &all_used, separator));
3725 CHECK_EQ(0, processed);
3726
3727 CHECK_EQ(Double::NaN(), StrToD("1.0e+ 1", flags, 0.0,
3728 &processed, &all_used, separator));
3729 CHECK_EQ(0, processed);
3730
3731 CHECK_EQ(Double::NaN(), StrToD("1.0e- 1", flags, 0.0,
3732 &processed, &all_used, separator));
3733 CHECK_EQ(0, processed);
3734
3735 CHECK_EQ(Double::NaN(), StrToD("1.0e +1", flags, 0.0,
3736 &processed, &all_used, separator));
3737 CHECK_EQ(0, processed);
3738
3739 CHECK_EQ(Double::NaN(), StrToD("1.0e -1", flags, 0.0,
3740 &processed, &all_used, separator));
3741 CHECK_EQ(0, processed);
3742
3743 separator = ' ';
3744 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
3745 StringToDoubleConverter::ALLOW_TRAILING_SPACES;
3746
3747 CHECK_EQ(1.0, StrToD("000 001.0 0", flags, 0.0,
3748 &processed, &all_used, separator));
3749 CHECK(all_used);
3750
3751 CHECK_EQ(1.0, StrToD("0 0 0 0 0 1.0 0", flags, 0.0,
3752 &processed, &all_used, separator));
3753 CHECK(all_used);
3754
3755 CHECK_EQ(1.0, StrToD(" 000 001.0 0 ", flags, 0.0,
3756 &processed, &all_used, separator));
3757 CHECK(all_used);
3758
3759 CHECK_EQ(1.0, StrToD(" 0 0 0 0 0 1.0 0 ", flags, 0.0,
3760 &processed, &all_used, separator));
3761 CHECK(all_used);
3762
3763 CHECK_EQ(1.0, StrToD(" 1.0", flags, 0.0,
3764 &processed, &all_used, separator));
3765 CHECK(all_used);
3766
3767 CHECK_EQ(Double::NaN(), StrToD("1 .0", flags, 0.0,
3768 &processed, &all_used, separator));
3769 CHECK_EQ(0, processed);
3770
3771 CHECK_EQ(Double::NaN(), StrToD("1. 0", flags, 0.0,
3772 &processed, &all_used, separator));
3773 CHECK_EQ(0, processed);
3774
3775 CHECK_EQ(Double::NaN(), StrToD("0 1.0", flags, 0.0,
3776 &processed, &all_used, separator));
3777 CHECK_EQ(0, processed);
3778
3779 CHECK_EQ(Double::NaN(), StrToD("1.0e1 0", flags, 0.0,
3780 &processed, &all_used, separator));
3781 CHECK_EQ(0, processed);
3782
3783 CHECK_EQ(10.0, StrToD("1.0e1 ", flags, 0.0,
3784 &processed, &all_used, separator));
3785 CHECK(all_used);
3786
3787 CHECK_EQ(Double::NaN(), StrToD("1.0e 1", flags, 0.0,
3788 &processed, &all_used, separator));
3789 CHECK_EQ(0, processed);
3790
3791 CHECK_EQ(Double::NaN(), StrToD("1.0 e1", flags, 0.0,
3792 &processed, &all_used, separator));
3793 CHECK_EQ(0, processed);
3794
3795 CHECK_EQ(Double::NaN(), StrToD("+ 1.0e1", flags, 0.0,
3796 &processed, &all_used, separator));
3797 CHECK_EQ(0, processed);
3798
3799 CHECK_EQ(Double::NaN(), StrToD("- 1.0e1", flags, 0.0,
3800 &processed, &all_used, separator));
3801 CHECK_EQ(0, processed);
3802
3803 CHECK_EQ(Double::NaN(), StrToD("1.0e+ 1", flags, 0.0,
3804 &processed, &all_used, separator));
3805 CHECK_EQ(0, processed);
3806
3807 CHECK_EQ(Double::NaN(), StrToD("1.0e- 1", flags, 0.0,
3808 &processed, &all_used, separator));
3809 CHECK_EQ(0, processed);
3810
3811 CHECK_EQ(Double::NaN(), StrToD("1.0e +1", flags, 0.0,
3812 &processed, &all_used, separator));
3813 CHECK_EQ(0, processed);
3814
3815 CHECK_EQ(Double::NaN(), StrToD("1.0e -1", flags, 0.0,
3816 &processed, &all_used, separator));
3817 CHECK_EQ(0, processed);
3818
3819 separator = ' ';
3820 flags = StringToDoubleConverter::ALLOW_HEX |
3821 StringToDoubleConverter::ALLOW_HEX_FLOATS |
3822 StringToDoubleConverter::ALLOW_LEADING_SPACES |
3823 StringToDoubleConverter::ALLOW_TRAILING_SPACES;
3824
3825 CHECK_EQ(18.0, StrToD("0x1 2", flags, 0.0, &processed, &all_used, separator));
3826 CHECK(all_used);
3827
3828 CHECK_EQ(0.0, StrToD("0x0 0", flags, 1.0, &processed, &all_used, separator));
3829 CHECK(all_used);
3830
3831 CHECK_EQ(static_cast<double>(0x123456789),
3832 StrToD("0x1 2 3 4 5 6 7 8 9", flags, Double::NaN(),
3833 &processed, &all_used, separator));
3834 CHECK(all_used);
3835
3836 CHECK_EQ(18.0, StrToD(" 0x1 2 ", flags, 0.0,
3837 &processed, &all_used, separator));
3838 CHECK(all_used);
3839
3840 CHECK_EQ(0.0, StrToD(" 0x0 ", flags, 1.0,
3841 &processed, &all_used, separator));
3842 CHECK(all_used);
3843
3844 CHECK_EQ(static_cast<double>(0x123456789),
3845 StrToD(" 0x1 2 3 4 5 6 7 8 9 ", flags, Double::NaN(),
3846 &processed, &all_used, separator));
3847 CHECK(all_used);
3848
3849 CHECK_EQ(static_cast<double>(0xabcdef),
3850 StrToD("0xa b c d e f", flags, 0.0,
3851 &processed, &all_used, separator));
3852 CHECK(all_used);
3853
3854 CHECK_EQ(Double::NaN(), StrToD("0x 1 2", flags, 0.0,
3855 &processed, &all_used, separator));
3856 CHECK_EQ(0, processed);
3857
3858 CHECK_EQ(Double::NaN(), StrToD("0 x0", flags, 1.0,
3859 &processed, &all_used, separator));
3860 CHECK_EQ(0, processed);
3861
3862 CHECK_EQ(Double::NaN(),
3863 StrToD("0x1 2 3 4 5 6 7 8 9", flags, Double::NaN(),
3864 &processed, &all_used, separator));
3865 CHECK_EQ(0, processed);
3866
3867 CHECK_EQ(Double::NaN(), StrToD(" 0 x1 2 ", flags, 0.0,
3868 &processed, &all_used, separator));
3869 CHECK_EQ(0, processed);
3870
3871 CHECK_EQ(3.0,
3872 StrToD("0x0 3p0", flags, 0.0, &processed, &all_used, separator));
3873 CHECK(all_used);
3874
3875 CHECK_EQ(0.0,
3876 StrToD("0x.0 0p0", flags, 0.0, &processed, &all_used, separator));
3877 CHECK(all_used);
3878
3879 CHECK_EQ(3.0,
3880 StrToD("0x3.0 0p0", flags, 0.0, &processed, &all_used, separator));
3881 CHECK(all_used);
3882
3883 CHECK_EQ(3.0,
3884 StrToD("0x0 3.p0", flags, 0.0, &processed, &all_used, separator));
3885 CHECK(all_used);
3886
3887 CHECK_EQ(Double::NaN(),
3888 StrToD("0x 3p0", flags, 0.0, &processed, &all_used));
3889 CHECK_EQ(0, processed);
3890
3891 CHECK_EQ(Double::NaN(),
3892 StrToD("0x.0 p0", flags, 0.0, &processed, &all_used));
3893 CHECK_EQ(0, processed);
3894
3895 CHECK_EQ(Double::NaN(),
3896 StrToD("0x3.0p0 0", flags, 0.0, &processed, &all_used));
3897 CHECK_EQ(0, processed);
3898
3899 CHECK_EQ(Double::NaN(),
3900 StrToD("0x0 3.p 0", flags, 0.0, &processed, &all_used));
3901 CHECK_EQ(0, processed);
3902
3903 CHECK_EQ(Double::NaN(),
3904 StrToD("0x3p+ 0", flags, 0.0, &processed, &all_used));
3905 CHECK_EQ(0, processed);
3906
3907 CHECK_EQ(Double::NaN(),
3908 StrToD("0x.0p- 0", flags, 0.0, &processed, &all_used));
3909 CHECK_EQ(0, processed);
3910
3911 CHECK_EQ(Double::NaN(),
3912 StrToD("0x3.0p +0", flags, 0.0, &processed, &all_used));
3913 CHECK_EQ(0, processed);
3914
3915 CHECK_EQ(Double::NaN(),
3916 StrToD("0x0 3.p -0", flags, 0.0, &processed, &all_used));
3917 CHECK_EQ(0, processed);
3918
3919 separator = 0x202F;
3920 char char_separator = '@';
3921 flags = StringToDoubleConverter::ALLOW_HEX |
3922 StringToDoubleConverter::ALLOW_HEX_FLOATS |
3923 StringToDoubleConverter::ALLOW_LEADING_SPACES |
3924 StringToDoubleConverter::ALLOW_TRAILING_SPACES;
3925
3926 CHECK_EQ(18.0,
3927 StrToD16("0x1@2", flags, 0.0, &processed, &all_used,
3928 char_separator, separator));
3929 CHECK(all_used);
3930
3931 CHECK_EQ(0.0, StrToD16("0x0@0", flags, 1.0, &processed, &all_used,
3932 char_separator, separator));
3933 CHECK(all_used);
3934
3935 CHECK_EQ(static_cast<double>(0x123456789),
3936 StrToD16("0x1@2@3@4@5@6@7@8@9", flags, Double::NaN(),
3937 &processed, &all_used, char_separator, separator));
3938 CHECK(all_used);
3939
3940 CHECK_EQ(18.0, StrToD16(" 0x1@2 ", flags, 0.0,
3941 &processed, &all_used, char_separator, separator));
3942 CHECK(all_used);
3943
3944 CHECK_EQ(static_cast<double>(0xabcdef),
3945 StrToD16("0xa@b@c@d@e@f", flags, 0.0,
3946 &processed, &all_used, char_separator, separator));
3947 CHECK(all_used);
3948
3949 CHECK_EQ(Double::NaN(),
3950 StrToD16("0x@1@2", flags, 0.0,
3951 &processed, &all_used, char_separator, separator));
3952 CHECK_EQ(0, processed);
3953
3954 CHECK_EQ(Double::NaN(),
3955 StrToD16("0@x0", flags, 1.0,
3956 &processed, &all_used, char_separator, separator));
3957 CHECK_EQ(0, processed);
3958
3959 CHECK_EQ(Double::NaN(),
3960 StrToD16("0x1@2@@3@4@5@6@7@8@9", flags, Double::NaN(),
3961 &processed, &all_used, char_separator, separator));
3962 CHECK_EQ(0, processed);
3963
3964 CHECK_EQ(3.0,
3965 StrToD16("0x0@3p0", flags, 0.0, &processed, &all_used,
3966 char_separator, separator));
3967 CHECK(all_used);
3968
3969 CHECK_EQ(0.0,
3970 StrToD16("0x.0@0p0", flags, 0.0, &processed, &all_used,
3971 char_separator, separator));
3972 CHECK(all_used);
3973
3974 CHECK_EQ(3.0,
3975 StrToD16("0x3.0@0p0", flags, 0.0, &processed, &all_used,
3976 char_separator, separator));
3977 CHECK(all_used);
3978
3979 CHECK_EQ(3.0,
3980 StrToD16("0x0@3.p0", flags, 0.0, &processed, &all_used,
3981 char_separator, separator));
3982 CHECK(all_used);
3983 }
3984
TEST(StringToDoubleSpecialValues)3985 TEST(StringToDoubleSpecialValues) {
3986 int processed;
3987 int flags = StringToDoubleConverter::NO_FLAGS;
3988
3989 {
3990 // Use 1.0 as junk_string_value.
3991 StringToDoubleConverter converter(flags, 0.0, 1.0, "infinity", "NaN");
3992
3993 CHECK_EQ(Double::NaN(), converter.StringToDouble("+NaN", 4, &processed));
3994 CHECK_EQ(4, processed);
3995
3996 CHECK_EQ(-Double::Infinity(),
3997 converter.StringToDouble("-infinity", 9, &processed));
3998 CHECK_EQ(9, processed);
3999
4000 CHECK_EQ(1.0, converter.StringToDouble("Infinity", 8, &processed));
4001 CHECK_EQ(0, processed);
4002
4003 CHECK_EQ(1.0, converter.StringToDouble("++NaN", 5, &processed));
4004 CHECK_EQ(0, processed);
4005 }
4006
4007 {
4008 // Use 1.0 as junk_string_value.
4009 StringToDoubleConverter converter(flags, 0.0, 1.0, "+infinity", "1NaN");
4010
4011 // The '+' is consumed before trying to match the infinity string.
4012 CHECK_EQ(1.0, converter.StringToDouble("+infinity", 9, &processed));
4013 CHECK_EQ(0, processed);
4014
4015 // The match for "1NaN" triggers, and doesn't let the 1234.0 complete.
4016 CHECK_EQ(1.0, converter.StringToDouble("1234.0", 6, &processed));
4017 CHECK_EQ(0, processed);
4018 }
4019 }
4020
4021
TEST(StringToDoubleCommentExamples)4022 TEST(StringToDoubleCommentExamples) {
4023 // Make sure the examples in the comments are correct.
4024 int flags;
4025 int processed;
4026 bool all_used;
4027
4028 flags = StringToDoubleConverter::ALLOW_HEX;
4029
4030 CHECK_EQ(4660.0, StrToD("0x1234", flags, 0.0, &processed, &all_used));
4031 CHECK(all_used);
4032
4033 CHECK_EQ(Double::NaN(),
4034 StrToD("0x1234.56", flags, 0.0, &processed, &all_used));
4035 CHECK_EQ(0, processed);
4036
4037 flags |= StringToDoubleConverter::ALLOW_TRAILING_JUNK;
4038 CHECK_EQ(4660.0,
4039 StrToD("0x1234.56", flags, 0.0, &processed, &all_used));
4040 CHECK_EQ(6, processed);
4041
4042 flags = StringToDoubleConverter::ALLOW_OCTALS;
4043 CHECK_EQ(668.0, StrToD("01234", flags, 0.0, &processed, &all_used));
4044 CHECK(all_used);
4045
4046 CHECK_EQ(12349.0, StrToD("012349", flags, 0.0, &processed, &all_used));
4047 CHECK(all_used);
4048
4049 CHECK_EQ(Double::NaN(),
4050 StrToD("01234.56", flags, 0.0, &processed, &all_used));
4051 CHECK_EQ(processed, 0);
4052
4053 flags |= StringToDoubleConverter::ALLOW_TRAILING_JUNK;
4054 CHECK_EQ(668.0,
4055 StrToD("01234.56", flags, 0.0, &processed, &all_used));
4056 CHECK_EQ(processed, 5);
4057
4058 flags = StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
4059 CHECK_EQ(-123.2, StrToD("- 123.2", flags, 0.0, &processed, &all_used));
4060 CHECK(all_used);
4061
4062 flags = StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
4063 CHECK_EQ(123.2, StrToD("+ 123.2", flags, 0.0, &processed, &all_used));
4064 CHECK(all_used);
4065
4066 flags = StringToDoubleConverter::ALLOW_HEX |
4067 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
4068
4069 CHECK_EQ(4660.0, StrToD("0x1234", flags, 0.0, &processed, &all_used));
4070 CHECK(all_used);
4071
4072 CHECK_EQ(4660.0, StrToD("0x1234K", flags, 0.0, &processed, &all_used));
4073 CHECK_EQ(processed, 6);
4074
4075 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
4076 CHECK(all_used);
4077
4078 CHECK_EQ(Double::NaN(), StrToD(" ", flags, 0.0, &processed, &all_used));
4079 CHECK_EQ(processed, 0);
4080
4081 CHECK_EQ(Double::NaN(), StrToD(" 1", flags, 0.0, &processed, &all_used));
4082 CHECK_EQ(processed, 0);
4083
4084 CHECK_EQ(Double::NaN(), StrToD("0x", flags, 0.0, &processed, &all_used));
4085 CHECK_EQ(processed, 0);
4086
4087 CHECK_EQ(-123.45, StrToD("-123.45", flags, 0.0, &processed, &all_used));
4088 CHECK(all_used);
4089
4090 CHECK_EQ(Double::NaN(),
4091 StrToD("--123.45", flags, 0.0, &processed, &all_used));
4092 CHECK_EQ(processed, 0);
4093
4094 CHECK_EQ(123e45, StrToD("123e45", flags, 0.0, &processed, &all_used));
4095 CHECK(all_used);
4096
4097 CHECK_EQ(123e45, StrToD("123E45", flags, 0.0, &processed, &all_used));
4098 CHECK(all_used);
4099
4100 CHECK_EQ(123e45, StrToD("123e+45", flags, 0.0, &processed, &all_used));
4101 CHECK(all_used);
4102
4103 CHECK_EQ(123e-45, StrToD("123e-45", flags, 0.0, &processed, &all_used));
4104 CHECK(all_used);
4105
4106 CHECK_EQ(123.0, StrToD("123e", flags, 0.0, &processed, &all_used));
4107 CHECK_EQ(processed, 3);
4108
4109 CHECK_EQ(123.0, StrToD("123e-", flags, 0.0, &processed, &all_used));
4110 CHECK_EQ(processed, 3);
4111
4112 {
4113 StringToDoubleConverter converter(flags, 0.0, 1.0, "infinity", "NaN");
4114 CHECK_EQ(Double::NaN(), converter.StringToDouble("+NaN", 4, &processed));
4115 CHECK_EQ(4, processed);
4116
4117 CHECK_EQ(-Double::Infinity(),
4118 converter.StringToDouble("-infinity", 9, &processed));
4119 CHECK_EQ(9, processed);
4120
4121 CHECK_EQ(1.0, converter.StringToDouble("Infinity", 9, &processed));
4122 CHECK_EQ(0, processed);
4123 }
4124
4125 flags = StringToDoubleConverter::ALLOW_OCTALS |
4126 StringToDoubleConverter::ALLOW_LEADING_SPACES;
4127
4128 CHECK_EQ(Double::NaN(), StrToD("0x1234", flags, 0.0, &processed, &all_used));
4129 CHECK_EQ(0, processed);
4130
4131 CHECK_EQ(668.0, StrToD("01234", flags, 0.0, &processed, &all_used));
4132 CHECK(all_used);
4133
4134 CHECK_EQ(0.0, StrToD("", flags, 0.0, &processed, &all_used));
4135 CHECK(all_used);
4136
4137 CHECK_EQ(0.0, StrToD(" ", flags, 0.0, &processed, &all_used));
4138 CHECK(all_used);
4139
4140 CHECK_EQ(1.0, StrToD(" 1", flags, 0.0, &processed, &all_used));
4141 CHECK(all_used);
4142
4143 CHECK_EQ(Double::NaN(), StrToD("0x", flags, 0.0, &processed, &all_used));
4144 CHECK_EQ(0, processed);
4145
4146 CHECK_EQ(Double::NaN(), StrToD("0123e45", flags, 0.0, &processed, &all_used));
4147 CHECK_EQ(0, processed);
4148
4149 CHECK_EQ(1239e45, StrToD("01239e45", flags, 0.0, &processed, &all_used));
4150 CHECK(all_used);
4151
4152 CHECK_EQ(Double::NaN(),
4153 StrToD("-infinity", flags, 0.0, &processed, &all_used));
4154 CHECK_EQ(0, processed);
4155
4156 CHECK_EQ(Double::NaN(), StrToD("NaN", flags, 0.0, &processed, &all_used));
4157 CHECK_EQ(0, processed);
4158
4159 flags = StringToDoubleConverter::NO_FLAGS;
4160 char separator = ' ';
4161 CHECK_EQ(1234.0,
4162 StrToD("1 2 3 4", flags, 0.0, &processed, &all_used, separator));
4163 CHECK(all_used);
4164
4165 CHECK_EQ(Double::NaN(),
4166 StrToD("1 2", flags, 0.0, &processed, &all_used, separator));
4167 CHECK_EQ(0, processed);
4168
4169 CHECK_EQ(1000000.0,
4170 StrToD("1 000 000.0", flags, 0.0, &processed, &all_used, separator));
4171 CHECK(all_used);
4172
4173 CHECK_EQ(1.0,
4174 StrToD("1.000 000", flags, 0.0, &processed, &all_used, separator));
4175 CHECK(all_used);
4176
4177 CHECK_EQ(Double::NaN(),
4178 StrToD("1.0e1 000", flags, 0.0, &processed, &all_used, separator));
4179 CHECK_EQ(0, processed);
4180 }
4181
4182
StrToF16(const uc16 * str16,int length,int flags,double empty_string_value,int * processed_characters_count,bool * processed_all)4183 static float StrToF16(const uc16* str16, int length, int flags,
4184 double empty_string_value,
4185 int* processed_characters_count,
4186 bool* processed_all) {
4187 StringToDoubleConverter converter(flags, empty_string_value, Double::NaN(),
4188 NULL, NULL);
4189 double result =
4190 converter.StringToFloat(str16, length, processed_characters_count);
4191 *processed_all = (length == *processed_characters_count);
4192 return result;
4193 }
4194
4195
StrToF(const char * str,int flags,double empty_string_value,int * processed_characters_count,bool * processed_all)4196 static double StrToF(const char* str, int flags, double empty_string_value,
4197 int* processed_characters_count, bool* processed_all) {
4198 StringToDoubleConverter converter(flags, empty_string_value, Single::NaN(),
4199 NULL, NULL);
4200 float result = converter.StringToFloat(str, strlen(str),
4201 processed_characters_count);
4202 *processed_all =
4203 ((strlen(str) == static_cast<unsigned>(*processed_characters_count)));
4204
4205 uc16 buffer16[256];
4206 DOUBLE_CONVERSION_ASSERT(strlen(str) < DOUBLE_CONVERSION_ARRAY_SIZE(buffer16));
4207 int len = strlen(str);
4208 for (int i = 0; i < len; i++) {
4209 buffer16[i] = str[i];
4210 }
4211 int processed_characters_count16;
4212 bool processed_all16;
4213 float result16 = StrToF16(buffer16, len, flags, empty_string_value,
4214 &processed_characters_count16,
4215 &processed_all16);
4216 CHECK_EQ(result, result16);
4217 CHECK_EQ(*processed_characters_count, processed_characters_count16);
4218 return result;
4219 }
4220
4221
TEST(StringToFloatVarious)4222 TEST(StringToFloatVarious) {
4223 int flags;
4224 int processed;
4225 bool all_used;
4226
4227 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
4228 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN |
4229 StringToDoubleConverter::ALLOW_TRAILING_SPACES;
4230
4231 CHECK_EQ(0.0f, StrToF("", flags, 0.0f, &processed, &all_used));
4232 CHECK(all_used);
4233
4234 CHECK_EQ(1.0f, StrToF("", flags, 1.0f, &processed, &all_used));
4235 CHECK(all_used);
4236
4237 CHECK_EQ(0.0f, StrToF(" ", flags, 0.0f, &processed, &all_used));
4238 CHECK(all_used);
4239
4240 CHECK_EQ(1.0f, StrToF(" ", flags, 1.0f, &processed, &all_used));
4241 CHECK(all_used);
4242
4243 CHECK_EQ(42.0f, StrToF("42", flags, 0.0f, &processed, &all_used));
4244 CHECK(all_used);
4245
4246 CHECK_EQ(42.0f, StrToF(" + 42 ", flags, 0.0f, &processed, &all_used));
4247 CHECK(all_used);
4248
4249 CHECK_EQ(-42.0f, StrToF(" - 42 ", flags, 0.0f, &processed, &all_used));
4250 CHECK(all_used);
4251
4252 CHECK_EQ(Double::NaN(), StrToF("x", flags, 1.0f, &processed, &all_used));
4253 CHECK_EQ(0, processed);
4254
4255 CHECK_EQ(Double::NaN(), StrToF(" x", flags, 1.0f, &processed, &all_used));
4256 CHECK_EQ(0, processed);
4257
4258 CHECK_EQ(Double::NaN(), StrToF("42x", flags, 0.0f, &processed, &all_used));
4259 CHECK_EQ(0, processed);
4260
4261 CHECK_EQ(Double::NaN(), StrToF("42 x", flags, 0.0f, &processed, &all_used));
4262 CHECK_EQ(0, processed);
4263
4264 CHECK_EQ(Double::NaN(), StrToF(" + 42 x", flags, 0.0f, &processed, &all_used));
4265 CHECK_EQ(0, processed);
4266
4267 CHECK_EQ(Double::NaN(), StrToF(" - 42 x", flags, 0.0f, &processed, &all_used));
4268 CHECK_EQ(0, processed);
4269
4270
4271 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
4272 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN |
4273 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
4274 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
4275
4276 CHECK_EQ(0.0f, StrToF("", flags, 0.0f, &processed, &all_used));
4277 CHECK(all_used);
4278
4279 CHECK_EQ(1.0f, StrToF("", flags, 1.0f, &processed, &all_used));
4280 CHECK(all_used);
4281
4282 CHECK_EQ(0.0f, StrToF(" ", flags, 0.0f, &processed, &all_used));
4283 CHECK(all_used);
4284
4285 CHECK_EQ(1.0f, StrToF(" ", flags, 1.0f, &processed, &all_used));
4286 CHECK(all_used);
4287
4288 CHECK_EQ(42.0f, StrToF("42", flags, 0.0f, &processed, &all_used));
4289 CHECK(all_used);
4290
4291 CHECK_EQ(42.0f, StrToF(" + 42 ", flags, 0.0f, &processed, &all_used));
4292 CHECK(all_used);
4293
4294 CHECK_EQ(-42.0f, StrToF(" - 42 ", flags, 0.0f, &processed, &all_used));
4295 CHECK(all_used);
4296
4297 CHECK_EQ(Double::NaN(), StrToF("x", flags, 1.0f, &processed, &all_used));
4298 CHECK_EQ(0, processed);
4299
4300 CHECK_EQ(Double::NaN(), StrToF(" x", flags, 1.0f, &processed, &all_used));
4301 CHECK_EQ(0, processed);
4302
4303 CHECK_EQ(42.0f, StrToF("42x", flags, 0.0f, &processed, &all_used));
4304 CHECK_EQ(2, processed);
4305
4306 CHECK_EQ(42.0f, StrToF("42 x", flags, 0.0f, &processed, &all_used));
4307 CHECK_EQ(3, processed);
4308
4309 CHECK_EQ(42.0f, StrToF(" + 42 x", flags, 0.0f, &processed, &all_used));
4310 CHECK_EQ(6, processed);
4311
4312 CHECK_EQ(-42.0f, StrToF(" - 42 x", flags, 0.0f, &processed, &all_used));
4313 CHECK_EQ(6, processed);
4314
4315
4316 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
4317 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN |
4318 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
4319
4320 CHECK_EQ(0.0f, StrToF("", flags, 0.0f, &processed, &all_used));
4321 CHECK(all_used);
4322
4323 CHECK_EQ(1.0f, StrToF("", flags, 1.0f, &processed, &all_used));
4324 CHECK(all_used);
4325
4326 CHECK_EQ(0.0f, StrToF(" ", flags, 0.0f, &processed, &all_used));
4327 CHECK(all_used);
4328
4329 CHECK_EQ(1.0f, StrToF(" ", flags, 1.0f, &processed, &all_used));
4330 CHECK(all_used);
4331
4332 CHECK_EQ(42.0f, StrToF("42", flags, 0.0f, &processed, &all_used));
4333 CHECK(all_used);
4334
4335 CHECK_EQ(42.0f, StrToF(" + 42 ", flags, 0.0f, &processed, &all_used));
4336 CHECK_EQ(5, processed);
4337
4338 CHECK_EQ(-42.0f, StrToF(" - 42 ", flags, 0.0f, &processed, &all_used));
4339 CHECK_EQ(5, processed);
4340
4341 CHECK_EQ(Double::NaN(), StrToF("x", flags, 1.0f, &processed, &all_used));
4342 CHECK_EQ(0, processed);
4343
4344 CHECK_EQ(Double::NaN(), StrToF(" x", flags, 1.0f, &processed, &all_used));
4345 CHECK_EQ(0, processed);
4346
4347 CHECK_EQ(42.0f, StrToF("42x", flags, 0.0f, &processed, &all_used));
4348 CHECK_EQ(2, processed);
4349
4350 CHECK_EQ(42.0f, StrToF("42 x", flags, 0.0f, &processed, &all_used));
4351 CHECK_EQ(2, processed);
4352
4353 CHECK_EQ(42.0f, StrToF(" + 42 x", flags, 0.0f, &processed, &all_used));
4354 CHECK_EQ(5, processed);
4355
4356 CHECK_EQ(-42.0f, StrToF(" - 42 x", flags, 0.0f, &processed, &all_used));
4357 CHECK_EQ(5, processed);
4358
4359 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
4360 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
4361
4362 CHECK_EQ(42.0f, StrToF(" +42 ", flags, 0.0f, &processed, &all_used));
4363 CHECK_EQ(4, processed);
4364
4365 CHECK_EQ(-42.0f, StrToF(" -42 ", flags, 0.0f, &processed, &all_used));
4366 CHECK_EQ(4, processed);
4367
4368 CHECK_EQ(Double::NaN(), StrToF(" + 42 ", flags, 0.0f, &processed, &all_used));
4369 CHECK_EQ(0, processed);
4370
4371 CHECK_EQ(Double::NaN(), StrToF(" - 42 ", flags, 0.0f, &processed, &all_used));
4372 CHECK_EQ(0, processed);
4373
4374
4375 flags = StringToDoubleConverter::NO_FLAGS;
4376
4377 CHECK_EQ(0.0f, StrToF("", flags, 0.0f, &processed, &all_used));
4378 CHECK(all_used);
4379
4380 CHECK_EQ(1.0f, StrToF("", flags, 1.0f, &processed, &all_used));
4381 CHECK(all_used);
4382
4383 CHECK_EQ(Double::NaN(), StrToF(" ", flags, 0.0f, &processed, &all_used));
4384 CHECK_EQ(0, processed);
4385
4386 CHECK_EQ(Double::NaN(), StrToF(" ", flags, 1.0f, &processed, &all_used));
4387 CHECK_EQ(0, processed);
4388
4389 CHECK_EQ(42.0f, StrToF("42", flags, 0.0f, &processed, &all_used));
4390 CHECK(all_used);
4391
4392 CHECK_EQ(Double::NaN(), StrToF(" + 42 ", flags, 0.0f, &processed, &all_used));
4393 CHECK_EQ(0, processed);
4394
4395 CHECK_EQ(Double::NaN(), StrToF(" - 42 ", flags, 0.0f, &processed, &all_used));
4396 CHECK_EQ(0, processed);
4397
4398 CHECK_EQ(Double::NaN(), StrToF("x", flags, 1.0f, &processed, &all_used));
4399 CHECK_EQ(0, processed);
4400
4401 CHECK_EQ(Double::NaN(), StrToF(" x", flags, 1.0f, &processed, &all_used));
4402 CHECK_EQ(0, processed);
4403
4404 CHECK_EQ(Double::NaN(), StrToF("42x", flags, 0.0f, &processed, &all_used));
4405 CHECK_EQ(0, processed);
4406
4407 CHECK_EQ(Double::NaN(), StrToF("42 x", flags, 0.0f, &processed, &all_used));
4408 CHECK_EQ(0, processed);
4409
4410 CHECK_EQ(Double::NaN(), StrToF(" + 42 x", flags, 0.0f, &processed, &all_used));
4411 CHECK_EQ(0, processed);
4412
4413 CHECK_EQ(Double::NaN(), StrToF(" - 42 x", flags, 0.0f, &processed, &all_used));
4414 CHECK_EQ(0, processed);
4415
4416
4417 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES;
4418
4419 CHECK_EQ(0.0f, StrToF(" ", flags, 0.0f, &processed, &all_used));
4420 CHECK(all_used);
4421
4422 CHECK_EQ(1.0f, StrToF(" ", flags, 1.0f, &processed, &all_used));
4423 CHECK(all_used);
4424
4425 CHECK_EQ(42.0f, StrToF(" 42", flags, 0.0f, &processed, &all_used));
4426 CHECK(all_used);
4427
4428 CHECK_EQ(Double::NaN(), StrToF("42 ", flags, 0.0f, &processed, &all_used));
4429 CHECK_EQ(0, processed);
4430
4431
4432 flags = StringToDoubleConverter::ALLOW_TRAILING_SPACES;
4433
4434 CHECK_EQ(0.0f, StrToF(" ", flags, 0.0f, &processed, &all_used));
4435 CHECK(all_used);
4436
4437 CHECK_EQ(1.0f, StrToF(" ", flags, 1.0f, &processed, &all_used));
4438 CHECK(all_used);
4439
4440 CHECK_EQ(42.0f, StrToF("42 ", flags, 0.0f, &processed, &all_used));
4441 CHECK(all_used);
4442
4443 CHECK_EQ(Double::NaN(), StrToF(" 42", flags, 0.0f, &processed, &all_used));
4444 CHECK_EQ(0, processed);
4445 }
4446
TEST(StringToFloatEmptyString)4447 TEST(StringToFloatEmptyString) {
4448 int flags;
4449 int processed;
4450 bool all_used;
4451
4452 flags = StringToDoubleConverter::NO_FLAGS;
4453 CHECK_EQ(0.0f, StrToF("", flags, 0.0f, &processed, &all_used));
4454 CHECK(all_used);
4455
4456 CHECK_EQ(1.0f, StrToF("", flags, 1.0f, &processed, &all_used));
4457 CHECK(all_used);
4458
4459 CHECK_EQ(Single::NaN(), StrToF("", flags, Single::NaN(),
4460 &processed, &all_used));
4461 CHECK(all_used);
4462
4463 CHECK_EQ(Single::NaN(), StrToF(" ", flags, 0.0f, &processed, &all_used));
4464 CHECK_EQ(0, processed);
4465
4466 CHECK_EQ(Single::NaN(), StrToF(" ", flags, 1.0f, &processed, &all_used));
4467 CHECK_EQ(0, processed);
4468
4469 CHECK_EQ(Single::NaN(), StrToF(" ", flags, Single::NaN(),
4470 &processed, &all_used));
4471 CHECK_EQ(0, processed);
4472
4473 flags = StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
4474 CHECK_EQ(0.0f, StrToF("", flags, 0.0f, &processed, &all_used));
4475 CHECK(all_used);
4476
4477 CHECK_EQ(1.0f, StrToF("", flags, 1.0f, &processed, &all_used));
4478 CHECK(all_used);
4479
4480 CHECK_EQ(Single::NaN(), StrToF("", flags, Single::NaN(),
4481 &processed, &all_used));
4482 CHECK(all_used);
4483
4484 CHECK_EQ(Single::NaN(), StrToF(" ", flags, 0.0f, &processed, &all_used));
4485 CHECK_EQ(0, processed);
4486
4487 CHECK_EQ(Single::NaN(), StrToF(" ", flags, 1.0f, &processed, &all_used));
4488 CHECK_EQ(0, processed);
4489
4490 CHECK_EQ(Single::NaN(), StrToF(" ", flags, Single::NaN(),
4491 &processed, &all_used));
4492 CHECK_EQ(0, processed);
4493
4494 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES;
4495 CHECK_EQ(0.0f, StrToF("", flags, 0.0f, &processed, &all_used));
4496 CHECK(all_used);
4497
4498 CHECK_EQ(1.0f, StrToF("", flags, 1.0f, &processed, &all_used));
4499 CHECK(all_used);
4500
4501 CHECK_EQ(Single::NaN(), StrToF("", flags, Single::NaN(),
4502 &processed, &all_used));
4503 CHECK(all_used);
4504
4505 CHECK_EQ(0.0f, StrToF(" ", flags, 0.0f, &processed, &all_used));
4506 CHECK(all_used);
4507
4508 CHECK_EQ(1.0f, StrToF(" ", flags, 1.0f, &processed, &all_used));
4509 CHECK(all_used);
4510
4511 CHECK_EQ(Single::NaN(), StrToF(" ", flags, Single::NaN(),
4512 &processed, &all_used));
4513 CHECK(all_used);
4514
4515 flags = StringToDoubleConverter::ALLOW_TRAILING_SPACES;
4516 CHECK_EQ(0.0f, StrToF("", flags, 0.0f, &processed, &all_used));
4517 CHECK(all_used);
4518
4519 CHECK_EQ(1.0f, StrToF("", flags, 1.0f, &processed, &all_used));
4520 CHECK(all_used);
4521
4522 CHECK_EQ(Single::NaN(), StrToF("", flags, Single::NaN(),
4523 &processed, &all_used));
4524 CHECK(all_used);
4525
4526 CHECK_EQ(0.0f, StrToF(" ", flags, 0.0f, &processed, &all_used));
4527 CHECK(all_used);
4528
4529 CHECK_EQ(1.0f, StrToF(" ", flags, 1.0f, &processed, &all_used));
4530 CHECK(all_used);
4531
4532 CHECK_EQ(Single::NaN(), StrToF(" ", flags, Single::NaN(),
4533 &processed, &all_used));
4534 CHECK(all_used);
4535
4536 flags = StringToDoubleConverter::ALLOW_TRAILING_JUNK;
4537 CHECK_EQ(0.0f, StrToF("", flags, 0.0f, &processed, &all_used));
4538 CHECK(all_used);
4539
4540 CHECK_EQ(1.0f, StrToF("", flags, 1.0f, &processed, &all_used));
4541 CHECK(all_used);
4542
4543 CHECK_EQ(Single::NaN(), StrToF("", flags, Single::NaN(),
4544 &processed, &all_used));
4545 CHECK(all_used);
4546
4547 CHECK_EQ(Single::NaN(), StrToF(" ", flags, 0.0f, &processed, &all_used));
4548 CHECK_EQ(0, processed);
4549
4550 CHECK_EQ(Single::NaN(), StrToF(" ", flags, 1.0f, &processed, &all_used));
4551 CHECK_EQ(0, processed);
4552
4553 CHECK_EQ(Single::NaN(), StrToF(" ", flags, Single::NaN(),
4554 &processed, &all_used));
4555 CHECK_EQ(0, processed);
4556
4557 CHECK_EQ(Single::NaN(), StrToF("x", flags, 0.0f, &processed, &all_used));
4558 CHECK_EQ(0, processed);
4559
4560 CHECK_EQ(Single::NaN(), StrToF(" x", flags, 0.0f, &processed, &all_used));
4561 CHECK_EQ(0, processed);
4562 }
4563
TEST(StringToFloatHexString)4564 TEST(StringToFloatHexString) {
4565 int flags;
4566 int processed;
4567 bool all_used;
4568 double d;
4569 float f;
4570
4571 flags = StringToDoubleConverter::ALLOW_HEX |
4572 StringToDoubleConverter::ALLOW_LEADING_SPACES |
4573 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
4574 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
4575
4576 // Check that no double rounding occurs:
4577 const char* double_rounding_example1 = "0x100000100000008";
4578 d = StrToD(double_rounding_example1, flags, 0.0, &processed, &all_used);
4579 f = StrToF(double_rounding_example1, flags, 0.0f, &processed, &all_used);
4580 CHECK(f != static_cast<float>(d));
4581 CHECK_EQ(72057602627862528.0f, StrToF(double_rounding_example1,
4582 flags, 0.0f, &processed, &all_used));
4583 CHECK(all_used);
4584
4585 const char* double_rounding_example2 = "0x1000002FFFFFFF8";
4586 d = StrToD(double_rounding_example2, flags, 0.0, &processed, &all_used);
4587 f = StrToF(double_rounding_example2, flags, 0.0f, &processed, &all_used);
4588 CHECK(f != static_cast<float>(d));
4589 CHECK_EQ(72057602627862528.0f, StrToF(double_rounding_example2,
4590 flags, 0.0f, &processed, &all_used));
4591 CHECK(all_used);
4592
4593 CHECK_EQ(18.0f, StrToF("0x12", flags, 0.0f, &processed, &all_used));
4594 CHECK(all_used);
4595
4596 CHECK_EQ(0.0f, StrToF("0x0", flags, 1.0f, &processed, &all_used));
4597 CHECK(all_used);
4598
4599 CHECK_EQ(static_cast<float>(0x123456789),
4600 StrToF("0x123456789", flags, Single::NaN(), &processed, &all_used));
4601 CHECK(all_used);
4602
4603 CHECK_EQ(18.0f, StrToF(" 0x12 ", flags, 0.0f, &processed, &all_used));
4604 CHECK(all_used);
4605
4606 CHECK_EQ(0.0f, StrToF(" 0x0 ", flags, 1.0f, &processed, &all_used));
4607 CHECK(all_used);
4608
4609 CHECK_EQ(static_cast<float>(0x123456789),
4610 StrToF(" 0x123456789 ", flags, Single::NaN(),
4611 &processed, &all_used));
4612 CHECK(all_used);
4613
4614 CHECK_EQ(static_cast<float>(0xabcdef),
4615 StrToF("0xabcdef", flags, 0.0f, &processed, &all_used));
4616 CHECK(all_used);
4617
4618 CHECK_EQ(static_cast<float>(0xabcdef),
4619 StrToF("0xABCDEF", flags, 0.0f, &processed, &all_used));
4620 CHECK(all_used);
4621
4622 CHECK_EQ(static_cast<float>(0xabcdef),
4623 StrToF(" 0xabcdef ", flags, 0.0f, &processed, &all_used));
4624 CHECK(all_used);
4625
4626 CHECK_EQ(static_cast<float>(0xabcdef),
4627 StrToF(" 0xABCDEF ", flags, 0.0f, &processed, &all_used));
4628 CHECK(all_used);
4629
4630 CHECK_EQ(Single::NaN(), StrToF(" ", flags, Single::NaN(),
4631 &processed, &all_used));
4632 CHECK(all_used);
4633
4634 CHECK_EQ(Single::NaN(), StrToF("0x", flags, 0.0f,
4635 &processed, &all_used));
4636 CHECK_EQ(0, processed);
4637
4638 CHECK_EQ(Single::NaN(), StrToF(" 0x ", flags, 0.0f,
4639 &processed, &all_used));
4640 CHECK_EQ(0, processed);
4641
4642 CHECK_EQ(Single::NaN(), StrToF(" 0x 3", flags, 0.0f,
4643 &processed, &all_used));
4644 CHECK_EQ(0, processed);
4645
4646 CHECK_EQ(Single::NaN(), StrToF("0x3g", flags, 0.0f,
4647 &processed, &all_used));
4648 CHECK_EQ(0, processed);
4649
4650 CHECK_EQ(Single::NaN(), StrToF("0x3.23", flags, 0.0f,
4651 &processed, &all_used));
4652 CHECK_EQ(0, processed);
4653
4654 CHECK_EQ(Single::NaN(), StrToF("x3", flags, 0.0f,
4655 &processed, &all_used));
4656 CHECK_EQ(0, processed);
4657
4658 CHECK_EQ(Single::NaN(), StrToF("0x3 foo", flags, 0.0f,
4659 &processed, &all_used));
4660 CHECK_EQ(0, processed);
4661
4662 CHECK_EQ(Single::NaN(), StrToF(" 0x3 foo", flags, 0.0f,
4663 &processed, &all_used));
4664 CHECK_EQ(0, processed);
4665
4666 CHECK_EQ(Single::NaN(), StrToF("+ 0x3 foo", flags, 0.0f,
4667 &processed, &all_used));
4668 CHECK_EQ(0, processed);
4669
4670 CHECK_EQ(Single::NaN(), StrToF("+", flags, 0.0f, &processed, &all_used));
4671 CHECK_EQ(0, processed);
4672
4673 CHECK_EQ(Single::NaN(), StrToF("-", flags, 0.0f, &processed, &all_used));
4674 CHECK_EQ(0, processed);
4675
4676 CHECK_EQ(-5.0f, StrToF("-0x5", flags, 0.0f, &processed, &all_used));
4677 CHECK(all_used);
4678
4679 CHECK_EQ(-5.0f, StrToF(" - 0x5 ", flags, 0.0f, &processed, &all_used));
4680 CHECK(all_used);
4681
4682 CHECK_EQ(5.0f, StrToF(" + 0x5 ", flags, 0.0f, &processed, &all_used));
4683 CHECK(all_used);
4684
4685 CHECK_EQ(Single::NaN(), StrToF("- -0x5", flags, 0.0f,
4686 &processed, &all_used));
4687 CHECK_EQ(0, processed);
4688
4689 CHECK_EQ(Single::NaN(), StrToF("- +0x5", flags, 0.0f,
4690 &processed, &all_used));
4691 CHECK_EQ(0, processed);
4692
4693 CHECK_EQ(Single::NaN(), StrToF("+ +0x5", flags, 0.0f,
4694 &processed, &all_used));
4695 CHECK_EQ(0, processed);
4696
4697 CHECK_EQ(Single::NaN(), StrToF("0x3p0", flags, 0.0f, &processed, &all_used));
4698 CHECK_EQ(0, processed);
4699
4700 CHECK_EQ(Single::NaN(), StrToF("0x.0p0", flags, 0.0f, &processed, &all_used));
4701 CHECK_EQ(0, processed);
4702
4703 CHECK_EQ(Single::NaN(), StrToF("0x3.0p0", flags, 0.0f,
4704 &processed, &all_used));
4705 CHECK_EQ(0, processed);
4706
4707 CHECK_EQ(Single::NaN(), StrToF("0x3.p0", flags, 0.0f,
4708 &processed, &all_used));
4709 CHECK_EQ(0, processed);
4710
4711 flags = StringToDoubleConverter::ALLOW_HEX;
4712
4713 CHECK_EQ(18.0f, StrToF("0x12", flags, 0.0f, &processed, &all_used));
4714 CHECK(all_used);
4715
4716 CHECK_EQ(0.0f, StrToF("0x0", flags, 1.0f, &processed, &all_used));
4717 CHECK(all_used);
4718
4719 CHECK_EQ(static_cast<float>(0x123456789),
4720 StrToF("0x123456789", flags, Single::NaN(), &processed, &all_used));
4721 CHECK(all_used);
4722
4723 CHECK_EQ(Single::NaN(), StrToF(" 0x12 ", flags, 0.0f, &processed, &all_used));
4724 CHECK_EQ(0, processed);
4725
4726 CHECK_EQ(Single::NaN(), StrToF(" 0x0 ", flags, 1.0f, &processed, &all_used));
4727 CHECK_EQ(0, processed);
4728
4729 CHECK_EQ(Single::NaN(), StrToF(" 0x123456789 ", flags, Single::NaN(),
4730 &processed, &all_used));
4731 CHECK_EQ(0, processed);
4732
4733 CHECK_EQ(static_cast<float>(0xabcdef),
4734 StrToF("0xabcdef", flags, 0.0f, &processed, &all_used));
4735 CHECK(all_used);
4736
4737 CHECK_EQ(static_cast<float>(0xabcdef),
4738 StrToF("0xABCDEF", flags, 0.0f, &processed, &all_used));
4739 CHECK(all_used);
4740
4741 CHECK_EQ(Single::NaN(),
4742 StrToF(" 0xabcdef ", flags, 0.0f, &processed, &all_used));
4743 CHECK_EQ(0, processed);
4744
4745 CHECK_EQ(Single::NaN(),
4746 StrToF(" 0xABCDEF ", flags, 0.0f, &processed, &all_used));
4747 CHECK_EQ(0, processed);
4748
4749 CHECK_EQ(Single::NaN(),
4750 StrToF(" ", flags, 0.0f, &processed, &all_used));
4751 CHECK_EQ(0, processed);
4752
4753 CHECK_EQ(Single::NaN(), StrToF("0x", flags, 0.0f,
4754 &processed, &all_used));
4755 CHECK_EQ(0, processed);
4756
4757 CHECK_EQ(Single::NaN(), StrToF(" 0x ", flags, 0.0f,
4758 &processed, &all_used));
4759 CHECK_EQ(0, processed);
4760
4761 CHECK_EQ(Single::NaN(), StrToF(" 0x 3", flags, 0.0f,
4762 &processed, &all_used));
4763 CHECK_EQ(0, processed);
4764
4765 CHECK_EQ(Single::NaN(), StrToF("0x3g", flags, 0.0f,
4766 &processed, &all_used));
4767 CHECK_EQ(0, processed);
4768
4769 CHECK_EQ(Single::NaN(), StrToF("0x3.23", flags, 0.0f,
4770 &processed, &all_used));
4771 CHECK_EQ(0, processed);
4772
4773 CHECK_EQ(Single::NaN(), StrToF("x3", flags, 0.0f,
4774 &processed, &all_used));
4775 CHECK_EQ(0, processed);
4776
4777 CHECK_EQ(Single::NaN(), StrToF("+ 0x3 foo", flags, 0.0f,
4778 &processed, &all_used));
4779 CHECK_EQ(0, processed);
4780
4781 CHECK_EQ(Single::NaN(), StrToF("+", flags, 0.0f, &processed, &all_used));
4782 CHECK_EQ(0, processed);
4783
4784 CHECK_EQ(Single::NaN(), StrToF("-", flags, 0.0f, &processed, &all_used));
4785 CHECK_EQ(0, processed);
4786
4787 CHECK_EQ(-5.0f, StrToF("-0x5", flags, 0.0f, &processed, &all_used));
4788 CHECK(all_used);
4789
4790 CHECK_EQ(Single::NaN(), StrToF(" - 0x5 ", flags, 0.0f, &processed, &all_used));
4791 CHECK_EQ(0, processed);
4792
4793 CHECK_EQ(Single::NaN(), StrToF(" + 0x5 ", flags, 0.0f, &processed, &all_used));
4794 CHECK_EQ(0, processed);
4795
4796 CHECK_EQ(Single::NaN(), StrToF("- -0x5", flags, 0.0f, &processed, &all_used));
4797 CHECK_EQ(0, processed);
4798
4799 CHECK_EQ(Single::NaN(), StrToF("- +0x5", flags, 0.0f, &processed, &all_used));
4800 CHECK_EQ(0, processed);
4801
4802 CHECK_EQ(Single::NaN(), StrToF("+ +0x5", flags, 0.0f, &processed, &all_used));
4803 CHECK_EQ(0, processed);
4804
4805 CHECK_EQ(Single::NaN(), StrToF("0x3p0", flags, 0.0f, &processed, &all_used));
4806 CHECK_EQ(0, processed);
4807
4808 CHECK_EQ(Single::NaN(), StrToF("0x.0p0", flags, 0.0f, &processed, &all_used));
4809 CHECK_EQ(0, processed);
4810
4811 CHECK_EQ(Single::NaN(), StrToF("0x3.0p0", flags, 0.0f,
4812 &processed, &all_used));
4813 CHECK_EQ(0, processed);
4814
4815 CHECK_EQ(Single::NaN(), StrToF("0x3.p0", flags, 0.0f,
4816 &processed, &all_used));
4817 CHECK_EQ(0, processed);
4818
4819 flags = StringToDoubleConverter::ALLOW_TRAILING_JUNK |
4820 StringToDoubleConverter::ALLOW_HEX;
4821
4822 CHECK_EQ(18.0f, StrToF("0x12", flags, 0.0f, &processed, &all_used));
4823 CHECK(all_used);
4824
4825 CHECK_EQ(0.0f, StrToF("0x0", flags, 1.0f, &processed, &all_used));
4826 CHECK(all_used);
4827
4828 CHECK_EQ(static_cast<float>(0x123456789),
4829 StrToF("0x123456789", flags, Single::NaN(), &processed, &all_used));
4830 CHECK(all_used);
4831
4832 CHECK_EQ(Single::NaN(), StrToF(" 0x12 ", flags, 0.0f, &processed, &all_used));
4833 CHECK_EQ(0, processed);
4834
4835 CHECK_EQ(Single::NaN(), StrToF(" 0x0 ", flags, 1.0f, &processed, &all_used));
4836 CHECK_EQ(0, processed);
4837
4838 CHECK_EQ(18.0f, StrToF("0x12 ", flags, 0.0f, &processed, &all_used));
4839 CHECK_EQ(4, processed);
4840
4841 CHECK_EQ(0.0f, StrToF("0x0 ", flags, 1.0f, &processed, &all_used));
4842 CHECK_EQ(3, processed);
4843
4844 CHECK_EQ(Single::NaN(),
4845 StrToF(" 0x123456789 ", flags, Single::NaN(),
4846 &processed, &all_used));
4847 CHECK_EQ(0, processed);
4848
4849 CHECK_EQ(static_cast<float>(0xabcdef),
4850 StrToF("0xabcdef", flags, 0.0f, &processed, &all_used));
4851 CHECK(all_used);
4852
4853 CHECK_EQ(static_cast<float>(0xabcdef),
4854 StrToF("0xABCDEF", flags, 0.0f, &processed, &all_used));
4855 CHECK(all_used);
4856
4857 CHECK_EQ(Single::NaN(),
4858 StrToF(" 0xabcdef ", flags, 0.0f, &processed, &all_used));
4859 CHECK_EQ(0, processed);
4860
4861 CHECK_EQ(Single::NaN(),
4862 StrToF(" 0xABCDEF ", flags, 0.0f, &processed, &all_used));
4863 CHECK_EQ(0, processed);
4864
4865 CHECK_EQ(static_cast<float>(0xabcdef),
4866 StrToF("0xabcdef ", flags, 0.0f, &processed, &all_used));
4867 CHECK_EQ(8, processed);
4868
4869 CHECK_EQ(static_cast<float>(0xabcdef),
4870 StrToF("0xABCDEF ", flags, 0.0f, &processed, &all_used));
4871 CHECK_EQ(8, processed);
4872
4873 CHECK_EQ(Single::NaN(),
4874 StrToF(" 0xabcdef", flags, 0.0f, &processed, &all_used));
4875 CHECK_EQ(0, processed);
4876
4877 CHECK_EQ(Single::NaN(),
4878 StrToF(" 0xABCDEF", flags, 0.0f, &processed, &all_used));
4879 CHECK_EQ(0, processed);
4880
4881 CHECK_EQ(Single::NaN(), StrToF(" ", flags, 0.0f, &processed, &all_used));
4882 CHECK_EQ(0, processed);
4883
4884 CHECK_EQ(Single::NaN(), StrToF("0x", flags, 0.0f,
4885 &processed, &all_used));
4886 CHECK_EQ(0, processed);
4887
4888 CHECK_EQ(Single::NaN(), StrToF(" 0x ", flags, 0.0f,
4889 &processed, &all_used));
4890 CHECK_EQ(0, processed);
4891
4892 CHECK_EQ(Single::NaN(), StrToF(" 0x 3", flags, 0.0f,
4893 &processed, &all_used));
4894 CHECK_EQ(0, processed);
4895
4896 CHECK_EQ(3.0f, StrToF("0x3g", flags, 0.0f, &processed, &all_used));
4897 CHECK_EQ(3, processed);
4898
4899 CHECK_EQ(3.0f, StrToF("0x3.234", flags, 0.0f, &processed, &all_used));
4900 CHECK_EQ(3, processed);
4901
4902 CHECK_EQ(Single::NaN(), StrToF(" 0x3g", flags, 0.0f, &processed, &all_used));
4903 CHECK_EQ(0, processed);
4904
4905 CHECK_EQ(Single::NaN(),
4906 StrToF(" 0x3.234", flags, 0.0f, &processed, &all_used));
4907 CHECK_EQ(0, processed);
4908
4909 CHECK_EQ(Single::NaN(), StrToF("x3", flags, 0.0f,
4910 &processed, &all_used));
4911 CHECK_EQ(0, processed);
4912
4913 CHECK_EQ(Single::NaN(), StrToF("+ 0x3 foo", flags, 0.0f,
4914 &processed, &all_used));
4915 CHECK_EQ(0, processed);
4916
4917 CHECK_EQ(Single::NaN(), StrToF("+", flags, 0.0f, &processed, &all_used));
4918 CHECK_EQ(0, processed);
4919
4920 CHECK_EQ(Single::NaN(), StrToF("-", flags, 0.0f, &processed, &all_used));
4921 CHECK_EQ(0, processed);
4922
4923 CHECK_EQ(-5.0f, StrToF("-0x5", flags, 0.0f, &processed, &all_used));
4924 CHECK(all_used);
4925
4926 CHECK_EQ(Single::NaN(), StrToF(" - 0x5 ", flags, 0.0f, &processed, &all_used));
4927 CHECK_EQ(0, processed);
4928
4929 CHECK_EQ(Single::NaN(), StrToF(" + 0x5 ", flags, 0.0f, &processed, &all_used));
4930 CHECK_EQ(0, processed);
4931
4932 CHECK_EQ(Single::NaN(), StrToF("- -0x5", flags, 0.0f, &processed, &all_used));
4933 CHECK_EQ(0, processed);
4934
4935 CHECK_EQ(Single::NaN(), StrToF("- +0x5", flags, 0.0f, &processed, &all_used));
4936 CHECK_EQ(0, processed);
4937
4938 CHECK_EQ(Single::NaN(), StrToF("+ +0x5", flags, 0.0f, &processed, &all_used));
4939 CHECK_EQ(0, processed);
4940
4941 CHECK_EQ(3.0f, StrToF("0x3p0", flags, 0.0f, &processed, &all_used));
4942 CHECK_EQ(3, processed);
4943
4944 CHECK_EQ(Single::NaN(), StrToF("0x.0p0", flags, 0.0f, &processed, &all_used));
4945 CHECK_EQ(0, processed);
4946
4947 CHECK_EQ(3.0f, StrToF("0x3.0p0", flags, 0.0f, &processed, &all_used));
4948 CHECK_EQ(3, processed);
4949
4950 CHECK_EQ(3.0f, StrToF("0x3.p0", flags, 0.0f, &processed, &all_used));
4951 CHECK_EQ(3, processed);
4952
4953
4954 flags = StringToDoubleConverter::ALLOW_TRAILING_JUNK |
4955 StringToDoubleConverter::ALLOW_LEADING_SPACES |
4956 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
4957 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN |
4958 StringToDoubleConverter::ALLOW_HEX;
4959
4960 CHECK_EQ(18.0f, StrToF("0x12", flags, 0.0f, &processed, &all_used));
4961 CHECK(all_used);
4962
4963 CHECK_EQ(0.0f, StrToF("0x0", flags, 1.0f, &processed, &all_used));
4964 CHECK(all_used);
4965
4966 CHECK_EQ(static_cast<float>(0x123456789),
4967 StrToF("0x123456789", flags, Single::NaN(), &processed, &all_used));
4968 CHECK(all_used);
4969
4970 CHECK_EQ(18.0f, StrToF(" 0x12 ", flags, 0.0f, &processed, &all_used));
4971 CHECK(all_used);
4972
4973 CHECK_EQ(0.0f, StrToF(" 0x0 ", flags, 1.0f, &processed, &all_used));
4974 CHECK(all_used);
4975
4976 CHECK_EQ(static_cast<float>(0x123456789),
4977 StrToF(" 0x123456789 ", flags, Single::NaN(),
4978 &processed, &all_used));
4979 CHECK(all_used);
4980
4981 CHECK_EQ(static_cast<float>(0xabcdef),
4982 StrToF("0xabcdef", flags, 0.0f, &processed, &all_used));
4983 CHECK(all_used);
4984
4985 CHECK_EQ(static_cast<float>(0xabcdef),
4986 StrToF("0xABCDEF", flags, 0.0f, &processed, &all_used));
4987 CHECK(all_used);
4988
4989 CHECK_EQ(static_cast<float>(0xabcdef),
4990 StrToF(" 0xabcdef ", flags, 0.0f, &processed, &all_used));
4991 CHECK(all_used);
4992
4993 CHECK_EQ(static_cast<float>(0xabcdef),
4994 StrToF(" 0xABCDEF ", flags, 0.0f, &processed, &all_used));
4995 CHECK(all_used);
4996
4997 CHECK_EQ(static_cast<float>(0xabc),
4998 StrToF(" 0xabc def ", flags, 0.0f, &processed, &all_used));
4999 CHECK_EQ(7, processed);
5000
5001 CHECK_EQ(static_cast<float>(0xabc),
5002 StrToF(" 0xABC DEF ", flags, 0.0f, &processed, &all_used));
5003 CHECK_EQ(7, processed);
5004
5005 CHECK_EQ(static_cast<float>(0x12),
5006 StrToF(" 0x12 ", flags, 0.0f, &processed, &all_used));
5007 CHECK(all_used);
5008
5009 CHECK_EQ(0.0f, StrToF(" 0x0 ", flags, 1.0f, &processed, &all_used));
5010 CHECK(all_used);
5011
5012 CHECK_EQ(static_cast<float>(0x123456789),
5013 StrToF(" 0x123456789 ", flags, Single::NaN(),
5014 &processed, &all_used));
5015 CHECK(all_used);
5016
5017 CHECK_EQ(Single::NaN(), StrToF(" ", flags, Single::NaN(),
5018 &processed, &all_used));
5019 CHECK(all_used);
5020
5021 CHECK_EQ(Single::NaN(), StrToF("0x", flags, 0.0f,
5022 &processed, &all_used));
5023 CHECK_EQ(0, processed);
5024
5025 CHECK_EQ(Single::NaN(), StrToF(" 0x ", flags, 0.0f,
5026 &processed, &all_used));
5027 CHECK_EQ(0, processed);
5028
5029 CHECK_EQ(Single::NaN(), StrToF(" 0x 3", flags, 0.0f,
5030 &processed, &all_used));
5031 CHECK_EQ(0, processed);
5032
5033 CHECK_EQ((float)0x3, StrToF("0x3g", flags, 0.0f, &processed, &all_used));
5034 CHECK_EQ(3, processed);
5035
5036 CHECK_EQ((float)0x3, StrToF("0x3.234", flags, 0.0f, &processed, &all_used));
5037 CHECK_EQ(3, processed);
5038
5039 CHECK_EQ(Single::NaN(), StrToF("x3", flags, 0.0f,
5040 &processed, &all_used));
5041 CHECK_EQ(0, processed);
5042
5043 flags = StringToDoubleConverter::ALLOW_HEX_FLOATS;
5044
5045 CHECK_EQ(3.0f, StrToF("0x3p0", flags, 0.0, &processed, &all_used));
5046 CHECK(all_used);
5047
5048 CHECK_EQ(0.0f, StrToF("0x.0p0", flags, 0.0, &processed, &all_used));
5049 CHECK(all_used);
5050
5051 CHECK_EQ(3.0f, StrToF("0x3.0p0", flags, 0.0, &processed, &all_used));
5052 CHECK(all_used);
5053
5054 CHECK_EQ(3.0f, StrToF("0x3.p0", flags, 0.0, &processed, &all_used));
5055 CHECK(all_used);
5056
5057 CHECK_EQ(-5634002804104940178441764864.0f, StrToF("-0x123456789012345678901234p0",
5058 flags, 0.0,
5059 &processed, &all_used));
5060 CHECK(all_used);
5061
5062 CHECK_EQ(134217728.0f, StrToF("0x8000001p0", flags, 0.0,
5063 &processed, &all_used));
5064 CHECK(all_used);
5065
5066 CHECK_EQ(134217728.0f, StrToF("0x8000000p0", flags, 0.0,
5067 &processed, &all_used));
5068 CHECK(all_used);
5069
5070 CHECK_EQ(549755813888.0f, StrToF("0x8000000001p0", flags, 0.0,
5071 &processed, &all_used));
5072 CHECK(all_used);
5073
5074 CHECK_EQ(549755813888.0f, StrToF("0x8000000000p0", flags, 0.0,
5075 &processed, &all_used));
5076 CHECK(all_used);
5077
5078 CHECK_EQ(549755879424.0f, StrToF("0x8000008001p0", flags, 0.0,
5079 &processed, &all_used));
5080 CHECK(all_used);
5081
5082 CHECK_EQ(549755813888.0f, StrToF("0x8000008000p0", flags, 0.0,
5083 &processed, &all_used));
5084 CHECK(all_used);
5085
5086 CHECK_EQ(549755944960.0f, StrToF("0x8000018001p0", flags, 0.0,
5087 &processed, &all_used));
5088 CHECK(all_used);
5089
5090 CHECK_EQ(549755944960.0f, StrToF("0x8000018000p0", flags, 0.0,
5091 &processed, &all_used));
5092 CHECK(all_used);
5093
5094 CHECK_EQ(8796093022208.0f, StrToF("0x8000000001p4", flags, 0.0,
5095 &processed, &all_used));
5096 CHECK(all_used);
5097
5098 CHECK_EQ(8796093022208.0f, StrToF("0x8000000000p+4", flags, 0.0,
5099 &processed, &all_used));
5100 CHECK(all_used);
5101
5102 CHECK_EQ(8796094070784.0f, StrToF("0x8000008001p04", flags, 0.0,
5103 &processed, &all_used));
5104 CHECK(all_used);
5105
5106 CHECK_EQ(34359738368.0f, StrToF("0x8000008000p-4", flags, 0.0,
5107 &processed, &all_used));
5108 CHECK(all_used);
5109
5110 CHECK_EQ(34359746560.0f, StrToF("0x8000018001p-04", flags, 0.0,
5111 &processed, &all_used));
5112 CHECK(all_used);
5113
5114 CHECK_EQ(8796095119360.0f, StrToF("0x8000018000p4", flags, 0.0,
5115 &processed, &all_used));
5116 CHECK(all_used);
5117
5118 CHECK_EQ(Single::Infinity(), StrToF("0x1p2000", flags, 0.0,
5119 &processed, &all_used));
5120 CHECK(all_used);
5121
5122 CHECK_EQ(0.0f, StrToF("0x1p-2000", flags, 0.0, &processed, &all_used));
5123 CHECK(all_used);
5124
5125 CHECK_EQ(-0.0f, StrToF("-0x1p-2000", flags, 0.0, &processed, &all_used));
5126 CHECK(all_used);
5127
5128 CHECK_EQ(Single::NaN(), StrToF(" ", flags, Single::NaN(),
5129 &processed, &all_used));
5130 CHECK_EQ(0, processed);
5131
5132 CHECK_EQ(Single::NaN(), StrToF("0x", flags, 0.0,
5133 &processed, &all_used));
5134 CHECK_EQ(0, processed);
5135
5136 CHECK_EQ(Single::NaN(), StrToF(" 0x ", flags, 0.0,
5137 &processed, &all_used));
5138 CHECK_EQ(0, processed);
5139
5140 CHECK_EQ(Single::NaN(), StrToF(" 0x 3", flags, 0.0,
5141 &processed, &all_used));
5142 CHECK_EQ(0, processed);
5143
5144 CHECK_EQ(Single::NaN(), StrToF("0x3g", flags, 0.0,
5145 &processed, &all_used));
5146 CHECK_EQ(0, processed);
5147
5148 CHECK_EQ(Single::NaN(), StrToF("x3", flags, 0.0,
5149 &processed, &all_used));
5150 CHECK_EQ(0, processed);
5151
5152 CHECK_EQ(Single::NaN(), StrToF("0x3 foo", flags, 0.0,
5153 &processed, &all_used));
5154 CHECK_EQ(0, processed);
5155
5156 CHECK_EQ(Single::NaN(), StrToF(" 0x3 foo", flags, 0.0,
5157 &processed, &all_used));
5158 CHECK_EQ(0, processed);
5159
5160 CHECK_EQ(Single::NaN(), StrToF("+ 0x3 foo", flags, 0.0,
5161 &processed, &all_used));
5162 CHECK_EQ(0, processed);
5163
5164 CHECK_EQ(Single::NaN(), StrToF("+", flags, 0.0, &processed, &all_used));
5165 CHECK_EQ(0, processed);
5166
5167 CHECK_EQ(Single::NaN(), StrToF("-", flags, 0.0, &processed, &all_used));
5168 CHECK_EQ(0, processed);
5169
5170 CHECK_EQ(Single::NaN(), StrToF("- -0x5", flags, 0.0, &processed, &all_used));
5171 CHECK_EQ(0, processed);
5172
5173 CHECK_EQ(Single::NaN(), StrToF("- +0x5", flags, 0.0, &processed, &all_used));
5174 CHECK_EQ(0, processed);
5175
5176 CHECK_EQ(Single::NaN(), StrToF("+ +0x5", flags, 0.0, &processed, &all_used));
5177 CHECK_EQ(0, processed);
5178
5179 CHECK_EQ(Single::NaN(), StrToF("0xp1", flags, 0.0, &processed, &all_used));
5180 CHECK_EQ(0, processed);
5181
5182 CHECK_EQ(Single::NaN(), StrToF("0x.p1", flags, 0.0, &processed, &all_used));
5183 CHECK_EQ(0, processed);
5184
5185 CHECK_EQ(Single::Infinity(), StrToF("0x1.p10000000000000000", flags, 0.0,
5186 &processed, &all_used));
5187 CHECK(all_used);
5188
5189 CHECK_EQ(0.0f, StrToF("0x1.p-10000000000000000", flags, 0.0,
5190 &processed, &all_used));
5191 CHECK(all_used);
5192 }
5193
5194
TEST(StringToFloatOctalString)5195 TEST(StringToFloatOctalString) {
5196 int flags;
5197 int processed;
5198 bool all_used;
5199 double d;
5200 float f;
5201
5202 flags = StringToDoubleConverter::ALLOW_OCTALS |
5203 StringToDoubleConverter::ALLOW_LEADING_SPACES |
5204 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
5205 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
5206
5207 // Check that no double rounding occurs:
5208 const char* double_rounding_example1 = "04000000040000000010";
5209 d = StrToD(double_rounding_example1, flags, 0.0, &processed, &all_used);
5210 f = StrToF(double_rounding_example1, flags, 0.0f, &processed, &all_used);
5211 CHECK(f != static_cast<float>(d));
5212 CHECK_EQ(72057602627862528.0f, StrToF(double_rounding_example1,
5213 flags, 0.0f, &processed, &all_used));
5214 CHECK(all_used);
5215
5216 const char* double_rounding_example2 = "04000000137777777770";
5217 d = StrToD(double_rounding_example2, flags, 0.0, &processed, &all_used);
5218 f = StrToF(double_rounding_example2, flags, 0.0f, &processed, &all_used);
5219 CHECK(f != static_cast<float>(d));
5220 CHECK_EQ(72057602627862528.0f, StrToF(double_rounding_example2,
5221 flags, 0.0f, &processed, &all_used));
5222 CHECK(all_used);
5223
5224 CHECK_EQ(10.0f, StrToF("012", flags, 0.0f, &processed, &all_used));
5225 CHECK(all_used);
5226
5227 CHECK_EQ(0.0f, StrToF("00", flags, 1.0f, &processed, &all_used));
5228 CHECK(all_used);
5229
5230 CHECK_EQ(10.0f, StrToF("012", flags, 1.0f, &processed, &all_used));
5231 CHECK(all_used);
5232
5233 CHECK_EQ(123456789.0f,
5234 StrToF("0123456789", flags, Single::NaN(), &processed, &all_used));
5235 CHECK(all_used);
5236
5237 CHECK_EQ(342391.0f,
5238 StrToF("01234567", flags, Single::NaN(), &processed, &all_used));
5239 CHECK(all_used);
5240
5241 CHECK_EQ(342391.0f,
5242 StrToF("+01234567", flags, Single::NaN(), &processed, &all_used));
5243 CHECK(all_used);
5244
5245 CHECK_EQ(-342391.0f,
5246 StrToF("-01234567", flags, Single::NaN(), &processed, &all_used));
5247 CHECK(all_used);
5248
5249 CHECK_EQ(10.0f, StrToF(" 012", flags, 0.0f, &processed, &all_used));
5250 CHECK(all_used);
5251
5252 CHECK_EQ(0.0f, StrToF(" 00", flags, 1.0f, &processed, &all_used));
5253 CHECK(all_used);
5254
5255 CHECK_EQ(10.0f, StrToF(" 012", flags, 1.0f, &processed, &all_used));
5256 CHECK(all_used);
5257
5258 CHECK_EQ(123456789.0f,
5259 StrToF(" 0123456789", flags, Single::NaN(), &processed, &all_used));
5260 CHECK(all_used);
5261
5262 CHECK_EQ(342391.0f,
5263 StrToF(" 01234567", flags, Single::NaN(), &processed, &all_used));
5264 CHECK(all_used);
5265
5266 CHECK_EQ(342391.0f,
5267 StrToF(" + 01234567", flags, Single::NaN(), &processed, &all_used));
5268 CHECK(all_used);
5269
5270 CHECK_EQ(-342391.0f,
5271 StrToF(" - 01234567", flags, Single::NaN(), &processed, &all_used));
5272 CHECK(all_used);
5273
5274 CHECK_EQ(10.0f, StrToF(" 012 ", flags, 0.0f, &processed, &all_used));
5275 CHECK(all_used);
5276
5277 CHECK_EQ(0.0f, StrToF(" 00 ", flags, 1.0f, &processed, &all_used));
5278 CHECK(all_used);
5279
5280 CHECK_EQ(10.0f, StrToF(" 012 ", flags, 1.0f, &processed, &all_used));
5281 CHECK(all_used);
5282
5283 CHECK_EQ(123456789.0f,
5284 StrToF(" 0123456789 ", flags, Single::NaN(), &processed, &all_used));
5285 CHECK(all_used);
5286
5287 CHECK_EQ(342391.0f,
5288 StrToF(" 01234567 ", flags, Single::NaN(), &processed, &all_used));
5289 CHECK(all_used);
5290
5291 CHECK_EQ(342391.0f,
5292 StrToF(" + 01234567 ", flags, Single::NaN(), &processed, &all_used));
5293 CHECK(all_used);
5294
5295 CHECK_EQ(-342391.0f,
5296 StrToF(" - 01234567 ", flags, Single::NaN(), &processed, &all_used));
5297 CHECK(all_used);
5298
5299 CHECK_EQ(10.0f, StrToF("012 ", flags, 0.0f, &processed, &all_used));
5300 CHECK(all_used);
5301
5302 CHECK_EQ(0.0f, StrToF("00 ", flags, 1.0f, &processed, &all_used));
5303 CHECK(all_used);
5304
5305 CHECK_EQ(10.0f, StrToF("012 ", flags, 1.0f, &processed, &all_used));
5306 CHECK(all_used);
5307
5308 CHECK_EQ(123456789.0f,
5309 StrToF("0123456789 ", flags, Single::NaN(), &processed, &all_used));
5310 CHECK(all_used);
5311
5312 CHECK_EQ(342391.0f,
5313 StrToF("01234567 ", flags, Single::NaN(), &processed, &all_used));
5314 CHECK(all_used);
5315
5316 CHECK_EQ(342391.0f,
5317 StrToF("+01234567", flags, Single::NaN(), &processed, &all_used));
5318 CHECK(all_used);
5319
5320 CHECK_EQ(-342391.0f,
5321 StrToF("-01234567", flags, Single::NaN(), &processed, &all_used));
5322 CHECK(all_used);
5323
5324 CHECK_EQ(Single::NaN(),
5325 StrToF("01234567e0", flags, Single::NaN(), &processed, &all_used));
5326 CHECK_EQ(0, processed);
5327
5328
5329 flags = StringToDoubleConverter::ALLOW_OCTALS;
5330 CHECK_EQ(10.0f, StrToF("012", flags, 0.0f, &processed, &all_used));
5331 CHECK(all_used);
5332
5333 CHECK_EQ(0.0f, StrToF("00", flags, 1.0f, &processed, &all_used));
5334 CHECK(all_used);
5335
5336 CHECK_EQ(10.0f, StrToF("012", flags, 1.0f, &processed, &all_used));
5337 CHECK(all_used);
5338
5339 CHECK_EQ(123456789.0f,
5340 StrToF("0123456789", flags, Single::NaN(), &processed, &all_used));
5341 CHECK(all_used);
5342
5343 CHECK_EQ(342391.0f,
5344 StrToF("01234567", flags, Single::NaN(), &processed, &all_used));
5345 CHECK(all_used);
5346
5347 CHECK_EQ(342391.0f,
5348 StrToF("+01234567", flags, Single::NaN(), &processed, &all_used));
5349 CHECK(all_used);
5350
5351 CHECK_EQ(-342391.0f,
5352 StrToF("-01234567", flags, Single::NaN(), &processed, &all_used));
5353 CHECK(all_used);
5354
5355 CHECK_EQ(Single::NaN(), StrToF(" 012", flags, 0.0f, &processed, &all_used));
5356 CHECK_EQ(0, processed);
5357
5358 CHECK_EQ(Single::NaN(), StrToF(" 00", flags, 1.0f, &processed, &all_used));
5359 CHECK_EQ(0, processed);
5360
5361 CHECK_EQ(Single::NaN(), StrToF(" 012", flags, 1.0f, &processed, &all_used));
5362 CHECK_EQ(0, processed);
5363
5364 CHECK_EQ(Single::NaN(),
5365 StrToF(" 0123456789", flags, Single::NaN(), &processed, &all_used));
5366 CHECK_EQ(0, processed);
5367
5368 CHECK_EQ(Single::NaN(),
5369 StrToF(" 01234567", flags, Single::NaN(), &processed, &all_used));
5370 CHECK_EQ(0, processed);
5371
5372 CHECK_EQ(Single::NaN(),
5373 StrToF(" + 01234567", flags, Single::NaN(), &processed, &all_used));
5374 CHECK_EQ(0, processed);
5375
5376 CHECK_EQ(Single::NaN(),
5377 StrToF(" - 01234567", flags, Single::NaN(), &processed, &all_used));
5378 CHECK_EQ(0, processed);
5379
5380 CHECK_EQ(Single::NaN(), StrToF(" 012 ", flags, 0.0f, &processed, &all_used));
5381 CHECK_EQ(0, processed);
5382
5383 CHECK_EQ(Single::NaN(), StrToF(" 00 ", flags, 1.0f, &processed, &all_used));
5384 CHECK_EQ(0, processed);
5385
5386 CHECK_EQ(Single::NaN(), StrToF(" 012 ", flags, 1.0f, &processed, &all_used));
5387 CHECK_EQ(0, processed);
5388
5389 CHECK_EQ(Single::NaN(),
5390 StrToF(" 0123456789 ", flags, Single::NaN(), &processed, &all_used));
5391 CHECK_EQ(0, processed);
5392
5393 CHECK_EQ(Single::NaN(),
5394 StrToF(" 01234567 ", flags, Single::NaN(), &processed, &all_used));
5395 CHECK_EQ(0, processed);
5396
5397 CHECK_EQ(Single::NaN(),
5398 StrToF(" + 01234567 ", flags, Single::NaN(), &processed, &all_used));
5399 CHECK_EQ(0, processed);
5400
5401 CHECK_EQ(Single::NaN(),
5402 StrToF(" - 01234567 ", flags, Single::NaN(), &processed, &all_used));
5403 CHECK_EQ(0, processed);
5404
5405 CHECK_EQ(Single::NaN(), StrToF("012 ", flags, 0.0f, &processed, &all_used));
5406 CHECK_EQ(0, processed);
5407
5408 CHECK_EQ(Single::NaN(), StrToF("00 ", flags, 1.0f, &processed, &all_used));
5409 CHECK_EQ(0, processed);
5410
5411 CHECK_EQ(Single::NaN(), StrToF("012 ", flags, 1.0f, &processed, &all_used));
5412 CHECK_EQ(0, processed);
5413
5414 CHECK_EQ(Single::NaN(),
5415 StrToF("0123456789 ", flags, Single::NaN(), &processed, &all_used));
5416 CHECK_EQ(0, processed);
5417
5418 CHECK_EQ(Single::NaN(),
5419 StrToF("01234567 ", flags, Single::NaN(), &processed, &all_used));
5420 CHECK_EQ(0, processed);
5421
5422 CHECK_EQ(342391.0f,
5423 StrToF("+01234567", flags, Single::NaN(), &processed, &all_used));
5424 CHECK(all_used);
5425
5426 CHECK_EQ(-342391.0f,
5427 StrToF("-01234567", flags, Single::NaN(), &processed, &all_used));
5428 CHECK(all_used);
5429
5430 CHECK_EQ(Single::NaN(),
5431 StrToF("01234567e0", flags, Single::NaN(), &processed, &all_used));
5432 CHECK_EQ(0, processed);
5433
5434
5435 flags = StringToDoubleConverter::ALLOW_OCTALS |
5436 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
5437 CHECK_EQ(10.0f, StrToF("012", flags, 0.0f, &processed, &all_used));
5438 CHECK(all_used);
5439
5440 CHECK_EQ(0.0f, StrToF("00", flags, 1.0f, &processed, &all_used));
5441 CHECK(all_used);
5442
5443 CHECK_EQ(10.0f, StrToF("012", flags, 1.0f, &processed, &all_used));
5444 CHECK(all_used);
5445
5446 CHECK_EQ(123456789.0f,
5447 StrToF("0123456789", flags, Single::NaN(), &processed, &all_used));
5448 CHECK(all_used);
5449
5450 CHECK_EQ(342391.0f,
5451 StrToF("01234567", flags, Single::NaN(), &processed, &all_used));
5452 CHECK(all_used);
5453
5454 CHECK_EQ(342391.0f,
5455 StrToF("+01234567", flags, Single::NaN(), &processed, &all_used));
5456 CHECK(all_used);
5457
5458 CHECK_EQ(-342391.0f,
5459 StrToF("-01234567", flags, Single::NaN(), &processed, &all_used));
5460 CHECK(all_used);
5461
5462 CHECK_EQ(Single::NaN(), StrToF(" 012", flags, 0.0f, &processed, &all_used));
5463 CHECK_EQ(0, processed);
5464
5465 CHECK_EQ(Single::NaN(), StrToF(" 00", flags, 1.0f, &processed, &all_used));
5466 CHECK_EQ(0, processed);
5467
5468 CHECK_EQ(Single::NaN(), StrToF(" 012", flags, 1.0f, &processed, &all_used));
5469 CHECK_EQ(0, processed);
5470
5471 CHECK_EQ(Single::NaN(),
5472 StrToF(" 0123456789", flags, Single::NaN(), &processed, &all_used));
5473 CHECK_EQ(0, processed);
5474
5475 CHECK_EQ(Single::NaN(),
5476 StrToF(" 01234567", flags, Single::NaN(), &processed, &all_used));
5477 CHECK_EQ(0, processed);
5478
5479 CHECK_EQ(Single::NaN(),
5480 StrToF(" + 01234567", flags, Single::NaN(), &processed, &all_used));
5481 CHECK_EQ(0, processed);
5482
5483 CHECK_EQ(Single::NaN(),
5484 StrToF(" - 01234567", flags, Single::NaN(), &processed, &all_used));
5485 CHECK_EQ(0, processed);
5486
5487 CHECK_EQ(Single::NaN(), StrToF(" 012 ", flags, 0.0f, &processed, &all_used));
5488 CHECK_EQ(0, processed);
5489
5490 CHECK_EQ(Single::NaN(), StrToF(" 00 ", flags, 1.0f, &processed, &all_used));
5491 CHECK_EQ(0, processed);
5492
5493 CHECK_EQ(Single::NaN(), StrToF(" 012 ", flags, 1.0f, &processed, &all_used));
5494 CHECK_EQ(0, processed);
5495
5496 CHECK_EQ(Single::NaN(),
5497 StrToF(" 0123456789 ", flags, Single::NaN(), &processed, &all_used));
5498 CHECK_EQ(0, processed);
5499
5500 CHECK_EQ(Single::NaN(),
5501 StrToF(" 01234567 ", flags, Single::NaN(), &processed, &all_used));
5502 CHECK_EQ(0, processed);
5503
5504 CHECK_EQ(Single::NaN(),
5505 StrToF(" + 01234567 ", flags, Single::NaN(), &processed, &all_used));
5506 CHECK_EQ(0, processed);
5507
5508 CHECK_EQ(Single::NaN(),
5509 StrToF(" - 01234567 ", flags, Single::NaN(), &processed, &all_used));
5510 CHECK_EQ(0, processed);
5511
5512 CHECK_EQ(10.0f, StrToF("012 ", flags, 0.0f, &processed, &all_used));
5513 CHECK_EQ(3, processed);
5514
5515 CHECK_EQ(0.0f, StrToF("00 ", flags, 1.0f, &processed, &all_used));
5516 CHECK_EQ(2, processed);
5517
5518 CHECK_EQ(123456789.0f,
5519 StrToF("0123456789 ", flags, Single::NaN(), &processed, &all_used));
5520 CHECK_EQ(10, processed);
5521
5522 CHECK_EQ(342391.0f,
5523 StrToF("01234567 ", flags, Single::NaN(), &processed, &all_used));
5524 CHECK_EQ(8, processed);
5525
5526 CHECK_EQ(342391.0f,
5527 StrToF("+01234567", flags, Single::NaN(), &processed, &all_used));
5528 CHECK(all_used);
5529
5530 CHECK_EQ(-342391.0f,
5531 StrToF("-01234567", flags, Single::NaN(), &processed, &all_used));
5532 CHECK(all_used);
5533
5534 CHECK_EQ(10.0f, StrToF("012foo ", flags, 0.0f, &processed, &all_used));
5535 CHECK_EQ(3, processed);
5536
5537 CHECK_EQ(0.0f, StrToF("00foo ", flags, 1.0f, &processed, &all_used));
5538 CHECK_EQ(2, processed);
5539
5540 CHECK_EQ(123456789.0f,
5541 StrToF("0123456789foo ", flags, Single::NaN(),
5542 &processed, &all_used));
5543 CHECK_EQ(10, processed);
5544
5545 CHECK_EQ(342391.0f,
5546 StrToF("01234567foo ", flags, Single::NaN(), &processed, &all_used));
5547 CHECK_EQ(8, processed);
5548
5549 CHECK_EQ(342391.0f,
5550 StrToF("+01234567foo", flags, Single::NaN(), &processed, &all_used));
5551 CHECK_EQ(9, processed);
5552
5553 CHECK_EQ(-342391.0f,
5554 StrToF("-01234567foo", flags, Single::NaN(), &processed, &all_used));
5555 CHECK_EQ(9, processed);
5556
5557 CHECK_EQ(10.0f, StrToF("012 foo ", flags, 0.0f, &processed, &all_used));
5558 CHECK_EQ(3, processed);
5559
5560 CHECK_EQ(0.0f, StrToF("00 foo ", flags, 1.0f, &processed, &all_used));
5561 CHECK_EQ(2, processed);
5562
5563 CHECK_EQ(123456789.0f,
5564 StrToF("0123456789 foo ", flags, Single::NaN(),
5565 &processed, &all_used));
5566 CHECK_EQ(10, processed);
5567
5568 CHECK_EQ(342391.0f,
5569 StrToF("01234567 foo ", flags, Single::NaN(),
5570 &processed, &all_used));
5571 CHECK_EQ(8, processed);
5572
5573 CHECK_EQ(342391.0f,
5574 StrToF("+01234567 foo", flags, Single::NaN(),
5575 &processed, &all_used));
5576 CHECK_EQ(9, processed);
5577
5578 CHECK_EQ(-342391.0f,
5579 StrToF("-01234567 foo", flags, Single::NaN(), &processed,
5580 &all_used));
5581 CHECK_EQ(9, processed);
5582
5583 CHECK_EQ(342391.0f,
5584 StrToF("01234567e0", flags, Single::NaN(), &processed, &all_used));
5585 CHECK_EQ(8, processed);
5586
5587 CHECK_EQ(342391.0f,
5588 StrToF("01234567e", flags, Single::NaN(), &processed, &all_used));
5589 CHECK_EQ(8, processed);
5590
5591 flags = StringToDoubleConverter::ALLOW_OCTALS |
5592 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
5593 StringToDoubleConverter::ALLOW_TRAILING_JUNK;
5594 CHECK_EQ(10.0f, StrToF("012", flags, 0.0f, &processed, &all_used));
5595 CHECK(all_used);
5596
5597 CHECK_EQ(0.0f, StrToF("00", flags, 1.0f, &processed, &all_used));
5598 CHECK(all_used);
5599
5600 CHECK_EQ(10.0f, StrToF("012", flags, 1.0f, &processed, &all_used));
5601 CHECK(all_used);
5602
5603 CHECK_EQ(123456789.0f,
5604 StrToF("0123456789", flags, Single::NaN(), &processed, &all_used));
5605 CHECK(all_used);
5606
5607 CHECK_EQ(342391.0f,
5608 StrToF("01234567", flags, Single::NaN(), &processed, &all_used));
5609 CHECK(all_used);
5610
5611 CHECK_EQ(342391.0f,
5612 StrToF("+01234567", flags, Single::NaN(), &processed, &all_used));
5613 CHECK(all_used);
5614
5615 CHECK_EQ(-342391.0f,
5616 StrToF("-01234567", flags, Single::NaN(), &processed, &all_used));
5617 CHECK(all_used);
5618
5619 CHECK_EQ(Single::NaN(), StrToF(" 012", flags, 0.0f, &processed, &all_used));
5620 CHECK_EQ(0, processed);
5621
5622 CHECK_EQ(Single::NaN(), StrToF(" 00", flags, 1.0f, &processed, &all_used));
5623 CHECK_EQ(0, processed);
5624
5625 CHECK_EQ(Single::NaN(), StrToF(" 012", flags, 1.0f, &processed, &all_used));
5626 CHECK_EQ(0, processed);
5627
5628 CHECK_EQ(Single::NaN(),
5629 StrToF(" 0123456789", flags, Single::NaN(), &processed, &all_used));
5630 CHECK_EQ(0, processed);
5631
5632 CHECK_EQ(Single::NaN(),
5633 StrToF(" 01234567", flags, Single::NaN(), &processed, &all_used));
5634 CHECK_EQ(0, processed);
5635
5636 CHECK_EQ(Single::NaN(),
5637 StrToF(" + 01234567", flags, Single::NaN(), &processed, &all_used));
5638 CHECK_EQ(0, processed);
5639
5640 CHECK_EQ(Single::NaN(),
5641 StrToF(" - 01234567", flags, Single::NaN(), &processed, &all_used));
5642 CHECK_EQ(0, processed);
5643
5644 CHECK_EQ(Single::NaN(), StrToF(" 012 ", flags, 0.0f, &processed, &all_used));
5645 CHECK_EQ(0, processed);
5646
5647 CHECK_EQ(Single::NaN(), StrToF(" 00 ", flags, 1.0f, &processed, &all_used));
5648 CHECK_EQ(0, processed);
5649
5650 CHECK_EQ(Single::NaN(), StrToF(" 012 ", flags, 1.0f, &processed, &all_used));
5651 CHECK_EQ(0, processed);
5652
5653 CHECK_EQ(Single::NaN(),
5654 StrToF(" 0123456789 ", flags, Single::NaN(), &processed, &all_used));
5655 CHECK_EQ(0, processed);
5656
5657 CHECK_EQ(Single::NaN(),
5658 StrToF(" 01234567 ", flags, Single::NaN(), &processed, &all_used));
5659 CHECK_EQ(0, processed);
5660
5661 CHECK_EQ(Single::NaN(),
5662 StrToF(" + 01234567 ", flags, Single::NaN(), &processed, &all_used));
5663 CHECK_EQ(0, processed);
5664
5665 CHECK_EQ(Single::NaN(),
5666 StrToF(" - 01234567 ", flags, Single::NaN(), &processed, &all_used));
5667 CHECK_EQ(0, processed);
5668
5669 CHECK_EQ(10.0f, StrToF("012 ", flags, 0.0f, &processed, &all_used));
5670 CHECK(all_used);
5671
5672 CHECK_EQ(0.0f, StrToF("00 ", flags, 1.0f, &processed, &all_used));
5673 CHECK(all_used);
5674
5675 CHECK_EQ(123456789.0f,
5676 StrToF("0123456789 ", flags, Single::NaN(), &processed, &all_used));
5677 CHECK(all_used);
5678
5679 CHECK_EQ(342391.0f,
5680 StrToF("01234567 ", flags, Single::NaN(), &processed, &all_used));
5681 CHECK(all_used);
5682
5683 CHECK_EQ(342391.0f,
5684 StrToF("+01234567", flags, Single::NaN(), &processed, &all_used));
5685 CHECK(all_used);
5686
5687 CHECK_EQ(-342391.0f,
5688 StrToF("-01234567", flags, Single::NaN(), &processed, &all_used));
5689 CHECK(all_used);
5690
5691 CHECK_EQ(10.0f, StrToF("012foo ", flags, 0.0f, &processed, &all_used));
5692 CHECK_EQ(3, processed);
5693
5694 CHECK_EQ(0.0f, StrToF("00foo ", flags, 1.0f, &processed, &all_used));
5695 CHECK_EQ(2, processed);
5696
5697 CHECK_EQ(123456789.0f,
5698 StrToF("0123456789foo ", flags, Single::NaN(),
5699 &processed, &all_used));
5700 CHECK_EQ(10, processed);
5701
5702 CHECK_EQ(342391.0f,
5703 StrToF("01234567foo ", flags, Single::NaN(), &processed, &all_used));
5704 CHECK_EQ(8, processed);
5705
5706 CHECK_EQ(342391.0f,
5707 StrToF("+01234567foo", flags, Single::NaN(), &processed, &all_used));
5708 CHECK_EQ(9, processed);
5709
5710 CHECK_EQ(-342391.0f,
5711 StrToF("-01234567foo", flags, Single::NaN(), &processed, &all_used));
5712 CHECK_EQ(9, processed);
5713
5714 CHECK_EQ(10.0f, StrToF("012 foo ", flags, 0.0f, &processed, &all_used));
5715 CHECK_EQ(4, processed);
5716
5717 CHECK_EQ(0.0f, StrToF("00 foo ", flags, 1.0f, &processed, &all_used));
5718 CHECK_EQ(3, processed);
5719
5720 CHECK_EQ(123456789.0f,
5721 StrToF("0123456789 foo ", flags, Single::NaN(),
5722 &processed, &all_used));
5723 CHECK_EQ(11, processed);
5724
5725 CHECK_EQ(342391.0f,
5726 StrToF("01234567 foo ", flags, Single::NaN(),
5727 &processed, &all_used));
5728 CHECK_EQ(9, processed);
5729
5730 CHECK_EQ(342391.0f,
5731 StrToF("+01234567 foo", flags, Single::NaN(),
5732 &processed, &all_used));
5733 CHECK_EQ(10, processed);
5734
5735 CHECK_EQ(-342391.0f,
5736 StrToF("-01234567 foo", flags, Single::NaN(),
5737 &processed, &all_used));
5738 CHECK_EQ(10, processed);
5739 }
5740
5741
TEST(StringToFloatSpecialValues)5742 TEST(StringToFloatSpecialValues) {
5743 int processed;
5744 int flags = StringToDoubleConverter::NO_FLAGS;
5745
5746 {
5747 // Use 1.0 as junk_string_value.
5748 StringToDoubleConverter converter(flags, 0.0f, 1.0f, "infinity", "NaN");
5749
5750 CHECK_EQ(Single::NaN(), converter.StringToDouble("+NaN", 4, &processed));
5751 CHECK_EQ(4, processed);
5752
5753 CHECK_EQ(-Single::Infinity(),
5754 converter.StringToDouble("-infinity", 9, &processed));
5755 CHECK_EQ(9, processed);
5756
5757 CHECK_EQ(1.0f, converter.StringToDouble("Infinity", 8, &processed));
5758 CHECK_EQ(0, processed);
5759
5760 CHECK_EQ(1.0f, converter.StringToDouble("++NaN", 5, &processed));
5761 CHECK_EQ(0, processed);
5762 }
5763
5764 {
5765 // Use 1.0 as junk_string_value.
5766 StringToDoubleConverter converter(flags, 0.0f, 1.0f, "+infinity", "1NaN");
5767
5768 // The '+' is consumed before trying to match the infinity string.
5769 CHECK_EQ(1.0f, converter.StringToDouble("+infinity", 9, &processed));
5770 CHECK_EQ(0, processed);
5771
5772 // The match for "1NaN" triggers, and doesn't let the 1234.0 complete.
5773 CHECK_EQ(1.0f, converter.StringToDouble("1234.0", 6, &processed));
5774 CHECK_EQ(0, processed);
5775 }
5776 }
5777
5778
TEST(StringToDoubleFloatWhitespace)5779 TEST(StringToDoubleFloatWhitespace) {
5780 int flags;
5781 int processed;
5782 bool all_used;
5783
5784 flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
5785 StringToDoubleConverter::ALLOW_TRAILING_SPACES |
5786 StringToDoubleConverter::ALLOW_SPACES_AFTER_SIGN;
5787
5788 const char kWhitespaceAscii[] = {
5789 0x0A, 0x0D, 0x09, 0x0B, 0x0C, 0x20,
5790 '-',
5791 0x0A, 0x0D, 0x09, 0x0B, 0x0C, 0x20,
5792 '1', '.', '2',
5793 0x0A, 0x0D, 0x09, 0x0B, 0x0C, 0x20,
5794 0x00
5795 };
5796 CHECK_EQ(-1.2, StrToD(kWhitespaceAscii, flags, Double::NaN(),
5797 &processed, &all_used));
5798 CHECK(all_used);
5799 CHECK_EQ(-1.2f, StrToF(kWhitespaceAscii, flags, Double::NaN(),
5800 &processed, &all_used));
5801 CHECK(all_used);
5802
5803 const uc16 kOghamSpaceMark = 0x1680;
5804 const uc16 kMongolianVowelSeparator = 0x180E;
5805 const uc16 kEnQuad = 0x2000;
5806 const uc16 kEmQuad = 0x2001;
5807 const uc16 kEnSpace = 0x2002;
5808 const uc16 kEmSpace = 0x2003;
5809 const uc16 kThreePerEmSpace = 0x2004;
5810 const uc16 kFourPerEmSpace = 0x2005;
5811 const uc16 kSixPerEmSpace = 0x2006;
5812 const uc16 kFigureSpace = 0x2007;
5813 const uc16 kPunctuationSpace = 0x2008;
5814 const uc16 kThinSpace = 0x2009;
5815 const uc16 kHairSpace = 0x200A;
5816 const uc16 kNarrowNoBreakSpace = 0x202F;
5817 const uc16 kMediumMathematicalSpace = 0x205F;
5818 const uc16 kIdeographicSpace = 0x3000;
5819
5820 const uc16 kWhitespace16[] = {
5821 0x0A, 0x0D, 0x09, 0x0B, 0x0C, 0x20, 0xA0, 0xFEFF,
5822 kOghamSpaceMark, kMongolianVowelSeparator, kEnQuad, kEmQuad,
5823 kEnSpace, kEmSpace, kThreePerEmSpace, kFourPerEmSpace, kSixPerEmSpace,
5824 kFigureSpace, kPunctuationSpace, kThinSpace, kHairSpace,
5825 kNarrowNoBreakSpace, kMediumMathematicalSpace, kIdeographicSpace,
5826 '-',
5827 0x0A, 0x0D, 0x09, 0x0B, 0x0C, 0x20, 0xA0, 0xFEFF,
5828 kOghamSpaceMark, kMongolianVowelSeparator, kEnQuad, kEmQuad,
5829 kEnSpace, kEmSpace, kThreePerEmSpace, kFourPerEmSpace, kSixPerEmSpace,
5830 kFigureSpace, kPunctuationSpace, kThinSpace, kHairSpace,
5831 kNarrowNoBreakSpace, kMediumMathematicalSpace, kIdeographicSpace,
5832 '1', '.', '2',
5833 0x0A, 0x0D, 0x09, 0x0B, 0x0C, 0x20, 0xA0, 0xFEFF,
5834 kOghamSpaceMark, kMongolianVowelSeparator, kEnQuad, kEmQuad,
5835 kEnSpace, kEmSpace, kThreePerEmSpace, kFourPerEmSpace, kSixPerEmSpace,
5836 kFigureSpace, kPunctuationSpace, kThinSpace, kHairSpace,
5837 kNarrowNoBreakSpace, kMediumMathematicalSpace, kIdeographicSpace,
5838 };
5839 const int kWhitespace16Length = DOUBLE_CONVERSION_ARRAY_SIZE(kWhitespace16);
5840 CHECK_EQ(-1.2, StrToD16(kWhitespace16, kWhitespace16Length, flags,
5841 Double::NaN(),
5842 &processed, &all_used));
5843 CHECK(all_used);
5844 CHECK_EQ(-1.2f, StrToF16(kWhitespace16, kWhitespace16Length, flags,
5845 Single::NaN(),
5846 &processed, &all_used));
5847 CHECK(all_used);
5848 }
5849
5850
TEST(StringToDoubleCaseInsensitiveSpecialValues)5851 TEST(StringToDoubleCaseInsensitiveSpecialValues) {
5852 int processed = 0;
5853
5854 int flags = StringToDoubleConverter::ALLOW_CASE_INSENSITIVITY |
5855 StringToDoubleConverter::ALLOW_LEADING_SPACES |
5856 StringToDoubleConverter::ALLOW_TRAILING_JUNK |
5857 StringToDoubleConverter::ALLOW_TRAILING_SPACES;
5858
5859 // Use 1.0 as junk_string_value.
5860 StringToDoubleConverter converter(flags, 0.0, 1.0, "infinity", "nan");
5861
5862 CHECK_EQ(Double::NaN(), converter.StringToDouble("+nan", 4, &processed));
5863 CHECK_EQ(4, processed);
5864
5865 CHECK_EQ(Double::NaN(), converter.StringToDouble("-nAN", 4, &processed));
5866 CHECK_EQ(4, processed);
5867
5868 CHECK_EQ(Double::NaN(), converter.StringToDouble("nAN", 3, &processed));
5869 CHECK_EQ(3, processed);
5870
5871 CHECK_EQ(Double::NaN(), converter.StringToDouble("nANabc", 6, &processed));
5872 CHECK_EQ(3, processed);
5873
5874 CHECK_EQ(+Double::Infinity(),
5875 converter.StringToDouble("+Infinity", 9, &processed));
5876 CHECK_EQ(9, processed);
5877
5878 CHECK_EQ(-Double::Infinity(),
5879 converter.StringToDouble("-INFinity", 9, &processed));
5880 CHECK_EQ(9, processed);
5881
5882 CHECK_EQ(Double::Infinity(),
5883 converter.StringToDouble("infINITY", 8, &processed));
5884 CHECK_EQ(8, processed);
5885
5886 CHECK_EQ(1.0, converter.StringToDouble("INF", 3, &processed));
5887 CHECK_EQ(0, processed);
5888
5889 CHECK_EQ(1.0, converter.StringToDouble("+inf", 4, &processed));
5890 CHECK_EQ(0, processed);
5891 }
5892