1 // Copyright 2006-2008 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28 #include <stdlib.h>
29
30 #include "double-conversion/bignum.h"
31 #include "cctest.h"
32 #include "double-conversion/diy-fp.h"
33 #include "double-conversion/ieee.h"
34 #include "double-conversion/strtod.h"
35 #include "double-conversion/utils.h"
36
37 using namespace double_conversion;
38
StringToVector(const char * str)39 static Vector<const char> StringToVector(const char* str) {
40 int len = static_cast<int>(strlen(str));
41 return Vector<const char>(str, len);
42 }
43
44
StrtodChar(const char * str,int exponent)45 static double StrtodChar(const char* str, int exponent) {
46 return Strtod(StringToVector(str), exponent);
47 }
48
49
StrtodTrimmedChar(const char * str,int exponent)50 static double StrtodTrimmedChar(const char* str, int exponent) {
51 return StrtodTrimmed(StringToVector(str), exponent);
52 }
53
54
StrtofChar(const char * str,int exponent)55 static float StrtofChar(const char* str, int exponent) {
56 return Strtof(StringToVector(str), exponent);
57 }
58
StrtofTrimmedChar(const char * str,int exponent)59 static float StrtofTrimmedChar(const char* str, int exponent) {
60 return StrtofTrimmed(StringToVector(str), exponent);
61 }
62
63
TEST(Strtod)64 TEST(Strtod) {
65 Vector<const char> vector;
66
67 vector = StringToVector("0");
68 CHECK_EQ(0.0, Strtod(vector, 1));
69 CHECK_EQ(0.0, Strtod(vector, 2));
70 CHECK_EQ(0.0, Strtod(vector, -2));
71 CHECK_EQ(0.0, Strtod(vector, -999));
72 CHECK_EQ(0.0, Strtod(vector, +999));
73
74 vector = StringToVector("1");
75 CHECK_EQ(1.0, Strtod(vector, 0));
76 CHECK_EQ(10.0, Strtod(vector, 1));
77 CHECK_EQ(100.0, Strtod(vector, 2));
78 CHECK_EQ(1e20, Strtod(vector, 20));
79 CHECK_EQ(1e22, Strtod(vector, 22));
80 CHECK_EQ(1e23, Strtod(vector, 23));
81 CHECK_EQ(1e35, Strtod(vector, 35));
82 CHECK_EQ(1e36, Strtod(vector, 36));
83 CHECK_EQ(1e37, Strtod(vector, 37));
84 CHECK_EQ(1e-1, Strtod(vector, -1));
85 CHECK_EQ(1e-2, Strtod(vector, -2));
86 CHECK_EQ(1e-5, Strtod(vector, -5));
87 CHECK_EQ(1e-20, Strtod(vector, -20));
88 CHECK_EQ(1e-22, Strtod(vector, -22));
89 CHECK_EQ(1e-23, Strtod(vector, -23));
90 CHECK_EQ(1e-25, Strtod(vector, -25));
91 CHECK_EQ(1e-39, Strtod(vector, -39));
92
93 vector = StringToVector("2");
94 CHECK_EQ(2.0, Strtod(vector, 0));
95 CHECK_EQ(20.0, Strtod(vector, 1));
96 CHECK_EQ(200.0, Strtod(vector, 2));
97 CHECK_EQ(2e20, Strtod(vector, 20));
98 CHECK_EQ(2e22, Strtod(vector, 22));
99 CHECK_EQ(2e23, Strtod(vector, 23));
100 CHECK_EQ(2e35, Strtod(vector, 35));
101 CHECK_EQ(2e36, Strtod(vector, 36));
102 CHECK_EQ(2e37, Strtod(vector, 37));
103 CHECK_EQ(2e-1, Strtod(vector, -1));
104 CHECK_EQ(2e-2, Strtod(vector, -2));
105 CHECK_EQ(2e-5, Strtod(vector, -5));
106 CHECK_EQ(2e-20, Strtod(vector, -20));
107 CHECK_EQ(2e-22, Strtod(vector, -22));
108 CHECK_EQ(2e-23, Strtod(vector, -23));
109 CHECK_EQ(2e-25, Strtod(vector, -25));
110 CHECK_EQ(2e-39, Strtod(vector, -39));
111
112 vector = StringToVector("9");
113 CHECK_EQ(9.0, Strtod(vector, 0));
114 CHECK_EQ(90.0, Strtod(vector, 1));
115 CHECK_EQ(900.0, Strtod(vector, 2));
116 CHECK_EQ(9e20, Strtod(vector, 20));
117 CHECK_EQ(9e22, Strtod(vector, 22));
118 CHECK_EQ(9e23, Strtod(vector, 23));
119 CHECK_EQ(9e35, Strtod(vector, 35));
120 CHECK_EQ(9e36, Strtod(vector, 36));
121 CHECK_EQ(9e37, Strtod(vector, 37));
122 CHECK_EQ(9e-1, Strtod(vector, -1));
123 CHECK_EQ(9e-2, Strtod(vector, -2));
124 CHECK_EQ(9e-5, Strtod(vector, -5));
125 CHECK_EQ(9e-20, Strtod(vector, -20));
126 CHECK_EQ(9e-22, Strtod(vector, -22));
127 CHECK_EQ(9e-23, Strtod(vector, -23));
128 CHECK_EQ(9e-25, Strtod(vector, -25));
129 CHECK_EQ(9e-39, Strtod(vector, -39));
130
131 vector = StringToVector("12345");
132 CHECK_EQ(12345.0, Strtod(vector, 0));
133 CHECK_EQ(123450.0, Strtod(vector, 1));
134 CHECK_EQ(1234500.0, Strtod(vector, 2));
135 CHECK_EQ(12345e20, Strtod(vector, 20));
136 CHECK_EQ(12345e22, Strtod(vector, 22));
137 CHECK_EQ(12345e23, Strtod(vector, 23));
138 CHECK_EQ(12345e30, Strtod(vector, 30));
139 CHECK_EQ(12345e31, Strtod(vector, 31));
140 CHECK_EQ(12345e32, Strtod(vector, 32));
141 CHECK_EQ(12345e35, Strtod(vector, 35));
142 CHECK_EQ(12345e36, Strtod(vector, 36));
143 CHECK_EQ(12345e37, Strtod(vector, 37));
144 CHECK_EQ(12345e-1, Strtod(vector, -1));
145 CHECK_EQ(12345e-2, Strtod(vector, -2));
146 CHECK_EQ(12345e-5, Strtod(vector, -5));
147 CHECK_EQ(12345e-20, Strtod(vector, -20));
148 CHECK_EQ(12345e-22, Strtod(vector, -22));
149 CHECK_EQ(12345e-23, Strtod(vector, -23));
150 CHECK_EQ(12345e-25, Strtod(vector, -25));
151 CHECK_EQ(12345e-39, Strtod(vector, -39));
152
153 vector = StringToVector("12345678901234");
154 CHECK_EQ(12345678901234.0, Strtod(vector, 0));
155 CHECK_EQ(123456789012340.0, Strtod(vector, 1));
156 CHECK_EQ(1234567890123400.0, Strtod(vector, 2));
157 CHECK_EQ(12345678901234e20, Strtod(vector, 20));
158 CHECK_EQ(12345678901234e22, Strtod(vector, 22));
159 CHECK_EQ(12345678901234e23, Strtod(vector, 23));
160 CHECK_EQ(12345678901234e30, Strtod(vector, 30));
161 CHECK_EQ(12345678901234e31, Strtod(vector, 31));
162 CHECK_EQ(12345678901234e32, Strtod(vector, 32));
163 CHECK_EQ(12345678901234e35, Strtod(vector, 35));
164 CHECK_EQ(12345678901234e36, Strtod(vector, 36));
165 CHECK_EQ(12345678901234e37, Strtod(vector, 37));
166 CHECK_EQ(12345678901234e-1, Strtod(vector, -1));
167 CHECK_EQ(12345678901234e-2, Strtod(vector, -2));
168 CHECK_EQ(12345678901234e-5, Strtod(vector, -5));
169 CHECK_EQ(12345678901234e-20, Strtod(vector, -20));
170 CHECK_EQ(12345678901234e-22, Strtod(vector, -22));
171 CHECK_EQ(12345678901234e-23, Strtod(vector, -23));
172 CHECK_EQ(12345678901234e-25, Strtod(vector, -25));
173 CHECK_EQ(12345678901234e-39, Strtod(vector, -39));
174
175 vector = StringToVector("123456789012345");
176 CHECK_EQ(123456789012345.0, Strtod(vector, 0));
177 CHECK_EQ(1234567890123450.0, Strtod(vector, 1));
178 CHECK_EQ(12345678901234500.0, Strtod(vector, 2));
179 CHECK_EQ(123456789012345e20, Strtod(vector, 20));
180 CHECK_EQ(123456789012345e22, Strtod(vector, 22));
181 CHECK_EQ(123456789012345e23, Strtod(vector, 23));
182 CHECK_EQ(123456789012345e35, Strtod(vector, 35));
183 CHECK_EQ(123456789012345e36, Strtod(vector, 36));
184 CHECK_EQ(123456789012345e37, Strtod(vector, 37));
185 CHECK_EQ(123456789012345e39, Strtod(vector, 39));
186 CHECK_EQ(123456789012345e-1, Strtod(vector, -1));
187 CHECK_EQ(123456789012345e-2, Strtod(vector, -2));
188 CHECK_EQ(123456789012345e-5, Strtod(vector, -5));
189 CHECK_EQ(123456789012345e-20, Strtod(vector, -20));
190 CHECK_EQ(123456789012345e-22, Strtod(vector, -22));
191 CHECK_EQ(123456789012345e-23, Strtod(vector, -23));
192 CHECK_EQ(123456789012345e-25, Strtod(vector, -25));
193 CHECK_EQ(123456789012345e-39, Strtod(vector, -39));
194
195 CHECK_EQ(0.0, StrtodChar("0", 12345));
196 CHECK_EQ(0.0, StrtodChar("", 1324));
197 CHECK_EQ(0.0, StrtodChar("000000000", 123));
198 CHECK_EQ(0.0, StrtodChar("2", -324));
199 CHECK_EQ(4e-324, StrtodChar("3", -324));
200 // It would be more readable to put non-zero literals on the left side (i.e.
201 // CHECK_EQ(1e-325, StrtodChar("1", -325))), but then Gcc complains that
202 // they are truncated to zero.
203 CHECK_EQ(0.0, StrtodChar("1", -325));
204 CHECK_EQ(0.0, StrtodChar("1", -325));
205 CHECK_EQ(0.0, StrtodChar("20000", -328));
206 CHECK_EQ(40000e-328, StrtodChar("30000", -328));
207 CHECK_EQ(0.0, StrtodChar("10000", -329));
208 CHECK_EQ(0.0, StrtodChar("90000", -329));
209 CHECK_EQ(0.0, StrtodChar("000000001", -325));
210 CHECK_EQ(0.0, StrtodChar("000000001", -325));
211 CHECK_EQ(0.0, StrtodChar("0000000020000", -328));
212 CHECK_EQ(40000e-328, StrtodChar("00000030000", -328));
213 CHECK_EQ(0.0, StrtodChar("0000000010000", -329));
214 CHECK_EQ(0.0, StrtodChar("0000000090000", -329));
215
216 // It would be more readable to put the literals (and not Double::Infinity())
217 // on the left side (i.e. CHECK_EQ(1e309, StrtodChar("1", 309))), but then Gcc
218 // complains that the floating constant exceeds range of 'double'.
219 CHECK_EQ(Double::Infinity(), StrtodChar("1", 309));
220 CHECK_EQ(1e308, StrtodChar("1", 308));
221 CHECK_EQ(1234e305, StrtodChar("1234", 305));
222 CHECK_EQ(1234e304, StrtodChar("1234", 304));
223 CHECK_EQ(Double::Infinity(), StrtodChar("18", 307));
224 CHECK_EQ(17e307, StrtodChar("17", 307));
225 CHECK_EQ(Double::Infinity(), StrtodChar("0000001", 309));
226 CHECK_EQ(1e308, StrtodChar("00000001", 308));
227 CHECK_EQ(1234e305, StrtodChar("00000001234", 305));
228 CHECK_EQ(1234e304, StrtodChar("000000001234", 304));
229 CHECK_EQ(Double::Infinity(), StrtodChar("0000000018", 307));
230 CHECK_EQ(17e307, StrtodChar("0000000017", 307));
231 CHECK_EQ(Double::Infinity(), StrtodChar("1000000", 303));
232 CHECK_EQ(1e308, StrtodChar("100000", 303));
233 CHECK_EQ(1234e305, StrtodChar("123400000", 300));
234 CHECK_EQ(1234e304, StrtodChar("123400000", 299));
235 CHECK_EQ(Double::Infinity(), StrtodChar("180000000", 300));
236 CHECK_EQ(17e307, StrtodChar("170000000", 300));
237 CHECK_EQ(Double::Infinity(), StrtodChar("00000001000000", 303));
238 CHECK_EQ(1e308, StrtodChar("000000000000100000", 303));
239 CHECK_EQ(1234e305, StrtodChar("00000000123400000", 300));
240 CHECK_EQ(1234e304, StrtodChar("0000000123400000", 299));
241 CHECK_EQ(Double::Infinity(), StrtodChar("00000000180000000", 300));
242 CHECK_EQ(17e307, StrtodChar("00000000170000000", 300));
243 CHECK_EQ(1.7976931348623157E+308, StrtodChar("17976931348623157", 292));
244 CHECK_EQ(1.7976931348623158E+308, StrtodChar("17976931348623158", 292));
245 CHECK_EQ(Double::Infinity(), StrtodChar("17976931348623159", 292));
246
247 // The following number is the result of 89255.0/1e-22. Both floating-point
248 // numbers can be accurately represented with doubles. However on Linux,x86
249 // the floating-point stack is set to 80bits and the double-rounding
250 // introduces an error.
251 CHECK_EQ(89255e-22, StrtodChar("89255", -22));
252
253 // Some random values.
254 CHECK_EQ(358416272e-33, StrtodChar("358416272", -33));
255 CHECK_EQ(104110013277974872254e-225,
256 StrtodChar("104110013277974872254", -225));
257
258 CHECK_EQ(123456789e108, StrtodChar("123456789", 108));
259 CHECK_EQ(123456789e109, StrtodChar("123456789", 109));
260 CHECK_EQ(123456789e110, StrtodChar("123456789", 110));
261 CHECK_EQ(123456789e111, StrtodChar("123456789", 111));
262 CHECK_EQ(123456789e112, StrtodChar("123456789", 112));
263 CHECK_EQ(123456789e113, StrtodChar("123456789", 113));
264 CHECK_EQ(123456789e114, StrtodChar("123456789", 114));
265 CHECK_EQ(123456789e115, StrtodChar("123456789", 115));
266
267 CHECK_EQ(1234567890123456789012345e108,
268 StrtodChar("1234567890123456789012345", 108));
269 CHECK_EQ(1234567890123456789012345e109,
270 StrtodChar("1234567890123456789012345", 109));
271 CHECK_EQ(1234567890123456789012345e110,
272 StrtodChar("1234567890123456789012345", 110));
273 CHECK_EQ(1234567890123456789012345e111,
274 StrtodChar("1234567890123456789012345", 111));
275 CHECK_EQ(1234567890123456789012345e112,
276 StrtodChar("1234567890123456789012345", 112));
277 CHECK_EQ(1234567890123456789012345e113,
278 StrtodChar("1234567890123456789012345", 113));
279 CHECK_EQ(1234567890123456789012345e114,
280 StrtodChar("1234567890123456789012345", 114));
281 CHECK_EQ(1234567890123456789012345e115,
282 StrtodChar("1234567890123456789012345", 115));
283
284 CHECK_EQ(1234567890123456789052345e108,
285 StrtodChar("1234567890123456789052345", 108));
286 CHECK_EQ(1234567890123456789052345e109,
287 StrtodChar("1234567890123456789052345", 109));
288 CHECK_EQ(1234567890123456789052345e110,
289 StrtodChar("1234567890123456789052345", 110));
290 CHECK_EQ(1234567890123456789052345e111,
291 StrtodChar("1234567890123456789052345", 111));
292 CHECK_EQ(1234567890123456789052345e112,
293 StrtodChar("1234567890123456789052345", 112));
294 CHECK_EQ(1234567890123456789052345e113,
295 StrtodChar("1234567890123456789052345", 113));
296 CHECK_EQ(1234567890123456789052345e114,
297 StrtodChar("1234567890123456789052345", 114));
298 CHECK_EQ(1234567890123456789052345e115,
299 StrtodChar("1234567890123456789052345", 115));
300
301 CHECK_EQ(5.445618932859895e-255,
302 StrtodChar("5445618932859895362967233318697132813618813095743952975"
303 "4392982234069699615600475529427176366709107287468930197"
304 "8628345413991790019316974825934906752493984055268219809"
305 "5012176093045431437495773903922425632551857520884625114"
306 "6241265881735209066709685420744388526014389929047617597"
307 "0302268848374508109029268898695825171158085457567481507"
308 "4162979705098246243690189880319928315307816832576838178"
309 "2563074014542859888710209237525873301724479666744537857"
310 "9026553346649664045621387124193095870305991178772256504"
311 "4368663670643970181259143319016472430928902201239474588"
312 "1392338901353291306607057623202353588698746085415097902"
313 "6640064319118728664842287477491068264828851624402189317"
314 "2769161449825765517353755844373640588822904791244190695"
315 "2998382932630754670573838138825217065450843010498555058"
316 "88186560731", -1035));
317
318 // Boundary cases. Boundaries themselves should round to even.
319 //
320 // 0x1FFFFFFFFFFFF * 2^3 = 72057594037927928
321 // next: 72057594037927936
322 // boundary: 72057594037927932 should round up.
323 CHECK_EQ(72057594037927928.0, StrtodChar("72057594037927928", 0));
324 CHECK_EQ(72057594037927936.0, StrtodChar("72057594037927936", 0));
325 CHECK_EQ(72057594037927936.0, StrtodChar("72057594037927932", 0));
326 CHECK_EQ(72057594037927928.0, StrtodChar("7205759403792793199999", -5));
327 CHECK_EQ(72057594037927936.0, StrtodChar("7205759403792793200001", -5));
328
329 // 0x1FFFFFFFFFFFF * 2^10 = 9223372036854774784
330 // next: 9223372036854775808
331 // boundary: 9223372036854775296 should round up.
332 CHECK_EQ(9223372036854774784.0, StrtodChar("9223372036854774784", 0));
333 CHECK_EQ(9223372036854775808.0, StrtodChar("9223372036854775808", 0));
334 CHECK_EQ(9223372036854775808.0, StrtodChar("9223372036854775296", 0));
335 CHECK_EQ(9223372036854774784.0, StrtodChar("922337203685477529599999", -5));
336 CHECK_EQ(9223372036854775808.0, StrtodChar("922337203685477529600001", -5));
337
338 // 0x1FFFFFFFFFFFF * 2^50 = 10141204801825834086073718800384
339 // next: 10141204801825835211973625643008
340 // boundary: 10141204801825834649023672221696 should round up.
341 CHECK_EQ(10141204801825834086073718800384.0,
342 StrtodChar("10141204801825834086073718800384", 0));
343 CHECK_EQ(10141204801825835211973625643008.0,
344 StrtodChar("10141204801825835211973625643008", 0));
345 CHECK_EQ(10141204801825835211973625643008.0,
346 StrtodChar("10141204801825834649023672221696", 0));
347 CHECK_EQ(10141204801825834086073718800384.0,
348 StrtodChar("1014120480182583464902367222169599999", -5));
349 CHECK_EQ(10141204801825835211973625643008.0,
350 StrtodChar("1014120480182583464902367222169600001", -5));
351
352 // 0x1FFFFFFFFFFFF * 2^99 = 5708990770823838890407843763683279797179383808
353 // next: 5708990770823839524233143877797980545530986496
354 // boundary: 5708990770823839207320493820740630171355185152
355 // The boundary should round up.
356 CHECK_EQ(5708990770823838890407843763683279797179383808.0,
357 StrtodChar("5708990770823838890407843763683279797179383808", 0));
358 CHECK_EQ(5708990770823839524233143877797980545530986496.0,
359 StrtodChar("5708990770823839524233143877797980545530986496", 0));
360 CHECK_EQ(5708990770823839524233143877797980545530986496.0,
361 StrtodChar("5708990770823839207320493820740630171355185152", 0));
362 CHECK_EQ(5708990770823838890407843763683279797179383808.0,
363 StrtodChar("5708990770823839207320493820740630171355185151999", -3));
364 CHECK_EQ(5708990770823839524233143877797980545530986496.0,
365 StrtodChar("5708990770823839207320493820740630171355185152001", -3));
366
367 // The following test-cases got some public attention in early 2011 when they
368 // sent Java and PHP into an infinite loop.
369 CHECK_EQ(2.225073858507201e-308, StrtodChar("22250738585072011", -324));
370 CHECK_EQ(2.22507385850720138309e-308,
371 StrtodChar("22250738585072011360574097967091319759348195463516456480"
372 "23426109724822222021076945516529523908135087914149158913"
373 "03962110687008643869459464552765720740782062174337998814"
374 "10632673292535522868813721490129811224514518898490572223"
375 "07285255133155755015914397476397983411801999323962548289"
376 "01710708185069063066665599493827577257201576306269066333"
377 "26475653000092458883164330377797918696120494973903778297"
378 "04905051080609940730262937128958950003583799967207254304"
379 "36028407889577179615094551674824347103070260914462157228"
380 "98802581825451803257070188608721131280795122334262883686"
381 "22321503775666622503982534335974568884423900265498198385"
382 "48794829220689472168983109969836584681402285424333066033"
383 "98508864458040010349339704275671864433837704860378616227"
384 "71738545623065874679014086723327636718751", -1076));
385 }
386
387
TEST(StrtodTrimmed)388 TEST(StrtodTrimmed) {
389 Vector<const char> vector;
390
391 vector = StringToVector("1");
392 CHECK_EQ(1.0, StrtodTrimmed(vector, 0));
393 CHECK_EQ(10.0, StrtodTrimmed(vector, 1));
394 CHECK_EQ(100.0, StrtodTrimmed(vector, 2));
395 CHECK_EQ(1e20, StrtodTrimmed(vector, 20));
396 CHECK_EQ(1e22, StrtodTrimmed(vector, 22));
397 CHECK_EQ(1e23, StrtodTrimmed(vector, 23));
398 CHECK_EQ(1e35, StrtodTrimmed(vector, 35));
399 CHECK_EQ(1e36, StrtodTrimmed(vector, 36));
400 CHECK_EQ(1e37, StrtodTrimmed(vector, 37));
401 CHECK_EQ(1e-1, StrtodTrimmed(vector, -1));
402 CHECK_EQ(1e-2, StrtodTrimmed(vector, -2));
403 CHECK_EQ(1e-5, StrtodTrimmed(vector, -5));
404 CHECK_EQ(1e-20, StrtodTrimmed(vector, -20));
405 CHECK_EQ(1e-22, StrtodTrimmed(vector, -22));
406 CHECK_EQ(1e-23, StrtodTrimmed(vector, -23));
407 CHECK_EQ(1e-25, StrtodTrimmed(vector, -25));
408 CHECK_EQ(1e-39, StrtodTrimmed(vector, -39));
409
410 vector = StringToVector("2");
411 CHECK_EQ(2.0, StrtodTrimmed(vector, 0));
412 CHECK_EQ(20.0, StrtodTrimmed(vector, 1));
413 CHECK_EQ(200.0, StrtodTrimmed(vector, 2));
414 CHECK_EQ(2e20, StrtodTrimmed(vector, 20));
415 CHECK_EQ(2e22, StrtodTrimmed(vector, 22));
416 CHECK_EQ(2e23, StrtodTrimmed(vector, 23));
417 CHECK_EQ(2e35, StrtodTrimmed(vector, 35));
418 CHECK_EQ(2e36, StrtodTrimmed(vector, 36));
419 CHECK_EQ(2e37, StrtodTrimmed(vector, 37));
420 CHECK_EQ(2e-1, StrtodTrimmed(vector, -1));
421 CHECK_EQ(2e-2, StrtodTrimmed(vector, -2));
422 CHECK_EQ(2e-5, StrtodTrimmed(vector, -5));
423 CHECK_EQ(2e-20, StrtodTrimmed(vector, -20));
424 CHECK_EQ(2e-22, StrtodTrimmed(vector, -22));
425 CHECK_EQ(2e-23, StrtodTrimmed(vector, -23));
426 CHECK_EQ(2e-25, StrtodTrimmed(vector, -25));
427 CHECK_EQ(2e-39, StrtodTrimmed(vector, -39));
428
429 vector = StringToVector("9");
430 CHECK_EQ(9.0, StrtodTrimmed(vector, 0));
431 CHECK_EQ(90.0, StrtodTrimmed(vector, 1));
432 CHECK_EQ(900.0, StrtodTrimmed(vector, 2));
433 CHECK_EQ(9e20, StrtodTrimmed(vector, 20));
434 CHECK_EQ(9e22, StrtodTrimmed(vector, 22));
435 CHECK_EQ(9e23, StrtodTrimmed(vector, 23));
436 CHECK_EQ(9e35, StrtodTrimmed(vector, 35));
437 CHECK_EQ(9e36, StrtodTrimmed(vector, 36));
438 CHECK_EQ(9e37, StrtodTrimmed(vector, 37));
439 CHECK_EQ(9e-1, StrtodTrimmed(vector, -1));
440 CHECK_EQ(9e-2, StrtodTrimmed(vector, -2));
441 CHECK_EQ(9e-5, StrtodTrimmed(vector, -5));
442 CHECK_EQ(9e-20, StrtodTrimmed(vector, -20));
443 CHECK_EQ(9e-22, StrtodTrimmed(vector, -22));
444 CHECK_EQ(9e-23, StrtodTrimmed(vector, -23));
445 CHECK_EQ(9e-25, StrtodTrimmed(vector, -25));
446 CHECK_EQ(9e-39, StrtodTrimmed(vector, -39));
447
448 vector = StringToVector("12345");
449 CHECK_EQ(12345.0, StrtodTrimmed(vector, 0));
450 CHECK_EQ(123450.0, StrtodTrimmed(vector, 1));
451 CHECK_EQ(1234500.0, StrtodTrimmed(vector, 2));
452 CHECK_EQ(12345e20, StrtodTrimmed(vector, 20));
453 CHECK_EQ(12345e22, StrtodTrimmed(vector, 22));
454 CHECK_EQ(12345e23, StrtodTrimmed(vector, 23));
455 CHECK_EQ(12345e30, StrtodTrimmed(vector, 30));
456 CHECK_EQ(12345e31, StrtodTrimmed(vector, 31));
457 CHECK_EQ(12345e32, StrtodTrimmed(vector, 32));
458 CHECK_EQ(12345e35, StrtodTrimmed(vector, 35));
459 CHECK_EQ(12345e36, StrtodTrimmed(vector, 36));
460 CHECK_EQ(12345e37, StrtodTrimmed(vector, 37));
461 CHECK_EQ(12345e-1, StrtodTrimmed(vector, -1));
462 CHECK_EQ(12345e-2, StrtodTrimmed(vector, -2));
463 CHECK_EQ(12345e-5, StrtodTrimmed(vector, -5));
464 CHECK_EQ(12345e-20, StrtodTrimmed(vector, -20));
465 CHECK_EQ(12345e-22, StrtodTrimmed(vector, -22));
466 CHECK_EQ(12345e-23, StrtodTrimmed(vector, -23));
467 CHECK_EQ(12345e-25, StrtodTrimmed(vector, -25));
468 CHECK_EQ(12345e-39, StrtodTrimmed(vector, -39));
469
470 vector = StringToVector("12345678901234");
471 CHECK_EQ(12345678901234.0, StrtodTrimmed(vector, 0));
472 CHECK_EQ(123456789012340.0, StrtodTrimmed(vector, 1));
473 CHECK_EQ(1234567890123400.0, StrtodTrimmed(vector, 2));
474 CHECK_EQ(12345678901234e20, StrtodTrimmed(vector, 20));
475 CHECK_EQ(12345678901234e22, StrtodTrimmed(vector, 22));
476 CHECK_EQ(12345678901234e23, StrtodTrimmed(vector, 23));
477 CHECK_EQ(12345678901234e30, StrtodTrimmed(vector, 30));
478 CHECK_EQ(12345678901234e31, StrtodTrimmed(vector, 31));
479 CHECK_EQ(12345678901234e32, StrtodTrimmed(vector, 32));
480 CHECK_EQ(12345678901234e35, StrtodTrimmed(vector, 35));
481 CHECK_EQ(12345678901234e36, StrtodTrimmed(vector, 36));
482 CHECK_EQ(12345678901234e37, StrtodTrimmed(vector, 37));
483 CHECK_EQ(12345678901234e-1, StrtodTrimmed(vector, -1));
484 CHECK_EQ(12345678901234e-2, StrtodTrimmed(vector, -2));
485 CHECK_EQ(12345678901234e-5, StrtodTrimmed(vector, -5));
486 CHECK_EQ(12345678901234e-20, StrtodTrimmed(vector, -20));
487 CHECK_EQ(12345678901234e-22, StrtodTrimmed(vector, -22));
488 CHECK_EQ(12345678901234e-23, StrtodTrimmed(vector, -23));
489 CHECK_EQ(12345678901234e-25, StrtodTrimmed(vector, -25));
490 CHECK_EQ(12345678901234e-39, StrtodTrimmed(vector, -39));
491
492 vector = StringToVector("123456789012345");
493 CHECK_EQ(123456789012345.0, StrtodTrimmed(vector, 0));
494 CHECK_EQ(1234567890123450.0, StrtodTrimmed(vector, 1));
495 CHECK_EQ(12345678901234500.0, StrtodTrimmed(vector, 2));
496 CHECK_EQ(123456789012345e20, StrtodTrimmed(vector, 20));
497 CHECK_EQ(123456789012345e22, StrtodTrimmed(vector, 22));
498 CHECK_EQ(123456789012345e23, StrtodTrimmed(vector, 23));
499 CHECK_EQ(123456789012345e35, StrtodTrimmed(vector, 35));
500 CHECK_EQ(123456789012345e36, StrtodTrimmed(vector, 36));
501 CHECK_EQ(123456789012345e37, StrtodTrimmed(vector, 37));
502 CHECK_EQ(123456789012345e39, StrtodTrimmed(vector, 39));
503 CHECK_EQ(123456789012345e-1, StrtodTrimmed(vector, -1));
504 CHECK_EQ(123456789012345e-2, StrtodTrimmed(vector, -2));
505 CHECK_EQ(123456789012345e-5, StrtodTrimmed(vector, -5));
506 CHECK_EQ(123456789012345e-20, StrtodTrimmed(vector, -20));
507 CHECK_EQ(123456789012345e-22, StrtodTrimmed(vector, -22));
508 CHECK_EQ(123456789012345e-23, StrtodTrimmed(vector, -23));
509 CHECK_EQ(123456789012345e-25, StrtodTrimmed(vector, -25));
510 CHECK_EQ(123456789012345e-39, StrtodTrimmed(vector, -39));
511
512 CHECK_EQ(0.0, StrtodTrimmedChar("", 1324));
513 CHECK_EQ(0.0, StrtodTrimmedChar("2", -324));
514 CHECK_EQ(4e-324, StrtodTrimmedChar("3", -324));
515 // It would be more readable to put non-zero literals on the left side (i.e.
516 // CHECK_EQ(1e-325, StrtodChar("1", -325))), but then Gcc complains that
517 // they are truncated to zero.
518 CHECK_EQ(0.0, StrtodTrimmedChar("1", -325));
519 CHECK_EQ(0.0, StrtodTrimmedChar("1", -325));
520
521 // It would be more readable to put the literals (and not Double::Infinity())
522 // on the left side (i.e. CHECK_EQ(1e309, StrtodChar("1", 309))), but then Gcc
523 // complains that the floating constant exceeds range of 'double'.
524 CHECK_EQ(Double::Infinity(), StrtodTrimmedChar("1", 309));
525 CHECK_EQ(1e308, StrtodTrimmedChar("1", 308));
526 CHECK_EQ(1234e305, StrtodTrimmedChar("1234", 305));
527 CHECK_EQ(1234e304, StrtodTrimmedChar("1234", 304));
528 CHECK_EQ(Double::Infinity(), StrtodTrimmedChar("18", 307));
529 CHECK_EQ(17e307, StrtodTrimmedChar("17", 307));
530
531 CHECK_EQ(1.7976931348623157E+308, StrtodTrimmedChar("17976931348623157", 292));
532 CHECK_EQ(1.7976931348623158E+308, StrtodTrimmedChar("17976931348623158", 292));
533 CHECK_EQ(Double::Infinity(), StrtodTrimmedChar("17976931348623159", 292));
534
535 // The following number is the result of 89255.0/1e-22. Both floating-point
536 // numbers can be accurately represented with doubles. However on Linux,x86
537 // the floating-point stack is set to 80bits and the double-rounding
538 // introduces an error.
539 CHECK_EQ(89255e-22, StrtodTrimmedChar("89255", -22));
540
541 // Some random values.
542 CHECK_EQ(358416272e-33, StrtodTrimmedChar("358416272", -33));
543 CHECK_EQ(104110013277974872254e-225,
544 StrtodTrimmedChar("104110013277974872254", -225));
545
546 CHECK_EQ(123456789e108, StrtodTrimmedChar("123456789", 108));
547 CHECK_EQ(123456789e109, StrtodTrimmedChar("123456789", 109));
548 CHECK_EQ(123456789e110, StrtodTrimmedChar("123456789", 110));
549 CHECK_EQ(123456789e111, StrtodTrimmedChar("123456789", 111));
550 CHECK_EQ(123456789e112, StrtodTrimmedChar("123456789", 112));
551 CHECK_EQ(123456789e113, StrtodTrimmedChar("123456789", 113));
552 CHECK_EQ(123456789e114, StrtodTrimmedChar("123456789", 114));
553 CHECK_EQ(123456789e115, StrtodTrimmedChar("123456789", 115));
554 CHECK_EQ(1234567890123456789012345e108,
555 StrtodTrimmedChar("1234567890123456789012345", 108));
556 CHECK_EQ(1234567890123456789012345e109,
557 StrtodTrimmedChar("1234567890123456789012345", 109));
558 CHECK_EQ(1234567890123456789012345e110,
559 StrtodTrimmedChar("1234567890123456789012345", 110));
560 CHECK_EQ(1234567890123456789012345e111,
561 StrtodTrimmedChar("1234567890123456789012345", 111));
562 CHECK_EQ(1234567890123456789012345e112,
563 StrtodTrimmedChar("1234567890123456789012345", 112));
564 CHECK_EQ(1234567890123456789012345e113,
565 StrtodTrimmedChar("1234567890123456789012345", 113));
566 CHECK_EQ(1234567890123456789012345e114,
567 StrtodTrimmedChar("1234567890123456789012345", 114));
568 CHECK_EQ(1234567890123456789012345e115,
569 StrtodTrimmedChar("1234567890123456789012345", 115));
570
571 CHECK_EQ(1234567890123456789052345e108,
572 StrtodTrimmedChar("1234567890123456789052345", 108));
573 CHECK_EQ(1234567890123456789052345e109,
574 StrtodTrimmedChar("1234567890123456789052345", 109));
575 CHECK_EQ(1234567890123456789052345e110,
576 StrtodTrimmedChar("1234567890123456789052345", 110));
577 CHECK_EQ(1234567890123456789052345e111,
578 StrtodTrimmedChar("1234567890123456789052345", 111));
579 CHECK_EQ(1234567890123456789052345e112,
580 StrtodTrimmedChar("1234567890123456789052345", 112));
581 CHECK_EQ(1234567890123456789052345e113,
582 StrtodTrimmedChar("1234567890123456789052345", 113));
583 CHECK_EQ(1234567890123456789052345e114,
584 StrtodTrimmedChar("1234567890123456789052345", 114));
585 CHECK_EQ(1234567890123456789052345e115,
586 StrtodTrimmedChar("1234567890123456789052345", 115));
587
588 // Boundary cases. Boundaries themselves should round to even.
589 //
590 // 0x1FFFFFFFFFFFF * 2^3 = 72057594037927928
591 // next: 72057594037927936
592 // boundary: 72057594037927932 should round up.
593 CHECK_EQ(72057594037927928.0, StrtodTrimmedChar("72057594037927928", 0));
594 CHECK_EQ(72057594037927936.0, StrtodTrimmedChar("72057594037927936", 0));
595 CHECK_EQ(72057594037927936.0, StrtodTrimmedChar("72057594037927932", 0));
596 CHECK_EQ(72057594037927928.0, StrtodTrimmedChar("7205759403792793199999", -5));
597 CHECK_EQ(72057594037927936.0, StrtodTrimmedChar("7205759403792793200001", -5));
598
599 // 0x1FFFFFFFFFFFF * 2^10 = 9223372036854774784
600 // next: 9223372036854775808
601 // boundary: 9223372036854775296 should round up.
602 CHECK_EQ(9223372036854774784.0, StrtodTrimmedChar("9223372036854774784", 0));
603 CHECK_EQ(9223372036854775808.0, StrtodTrimmedChar("9223372036854775808", 0));
604 CHECK_EQ(9223372036854775808.0, StrtodTrimmedChar("9223372036854775296", 0));
605 CHECK_EQ(9223372036854774784.0, StrtodTrimmedChar("922337203685477529599999", -5));
606 CHECK_EQ(9223372036854775808.0, StrtodTrimmedChar("922337203685477529600001", -5));
607
608 // 0x1FFFFFFFFFFFF * 2^50 = 10141204801825834086073718800384
609 // next: 10141204801825835211973625643008
610 // boundary: 10141204801825834649023672221696 should round up.
611 CHECK_EQ(10141204801825834086073718800384.0,
612 StrtodTrimmedChar("10141204801825834086073718800384", 0));
613 CHECK_EQ(10141204801825835211973625643008.0,
614 StrtodTrimmedChar("10141204801825835211973625643008", 0));
615 CHECK_EQ(10141204801825835211973625643008.0,
616 StrtodTrimmedChar("10141204801825834649023672221696", 0));
617 CHECK_EQ(10141204801825834086073718800384.0,
618 StrtodTrimmedChar("1014120480182583464902367222169599999", -5));
619 CHECK_EQ(10141204801825835211973625643008.0,
620 StrtodTrimmedChar("1014120480182583464902367222169600001", -5));
621
622 // 0x1FFFFFFFFFFFF * 2^99 = 5708990770823838890407843763683279797179383808
623 // next: 5708990770823839524233143877797980545530986496
624 // boundary: 5708990770823839207320493820740630171355185152
625 // The boundary should round up.
626 CHECK_EQ(5708990770823838890407843763683279797179383808.0,
627 StrtodTrimmedChar("5708990770823838890407843763683279797179383808", 0));
628 CHECK_EQ(5708990770823839524233143877797980545530986496.0,
629 StrtodTrimmedChar("5708990770823839524233143877797980545530986496", 0));
630 CHECK_EQ(5708990770823839524233143877797980545530986496.0,
631 StrtodTrimmedChar("5708990770823839207320493820740630171355185152", 0));
632 CHECK_EQ(5708990770823838890407843763683279797179383808.0,
633 StrtodTrimmedChar("5708990770823839207320493820740630171355185151999", -3));
634 CHECK_EQ(5708990770823839524233143877797980545530986496.0,
635 StrtodTrimmedChar("5708990770823839207320493820740630171355185152001", -3));
636
637 // The following test-cases got some public attention in early 2011 when they
638 // sent Java and PHP into an infinite loop.
639 CHECK_EQ(2.225073858507201e-308, StrtodTrimmedChar("22250738585072011", -324));
640 CHECK_EQ(2.22507385850720138309e-308,
641 StrtodTrimmedChar("22250738585072011360574097967091319759348195463516456480"
642 "23426109724822222021076945516529523908135087914149158913"
643 "03962110687008643869459464552765720740782062174337998814"
644 "10632673292535522868813721490129811224514518898490572223"
645 "07285255133155755015914397476397983411801999323962548289"
646 "01710708185069063066665599493827577257201576306269066333"
647 "26475653000092458883164330377797918696120494973903778297"
648 "04905051080609940730262937128958950003583799967207254304"
649 "36028407889577179615094551674824347103070260914462157228"
650 "98802581825451803257070188608721131280795122334262883686"
651 "22321503775666622503982534335974568884423900265498198385"
652 "48794829220689472168983109969836584681402285424333066033"
653 "98508864458040010349339704275671864433837704860378616227"
654 "71738545623065874679014086723327636718751", -1076));
655 }
656
657
TEST(Strtof)658 TEST(Strtof) {
659 Vector<const char> vector;
660
661 vector = StringToVector("0");
662 CHECK_EQ(0.0f, Strtof(vector, 1));
663 CHECK_EQ(0.0f, Strtof(vector, 2));
664 CHECK_EQ(0.0f, Strtof(vector, -2));
665 CHECK_EQ(0.0f, Strtof(vector, -999));
666 CHECK_EQ(0.0f, Strtof(vector, +999));
667
668 vector = StringToVector("1");
669 CHECK_EQ(1.0f, Strtof(vector, 0));
670 CHECK_EQ(10.0f, Strtof(vector, 1));
671 CHECK_EQ(100.0f, Strtof(vector, 2));
672 CHECK_EQ(1e20f, Strtof(vector, 20));
673 CHECK_EQ(1e22f, Strtof(vector, 22));
674 CHECK_EQ(1e23f, Strtof(vector, 23));
675 CHECK_EQ(1e35f, Strtof(vector, 35));
676 CHECK_EQ(1e36f, Strtof(vector, 36));
677 CHECK_EQ(1e37f, Strtof(vector, 37));
678 CHECK_EQ(1e-1f, Strtof(vector, -1));
679 CHECK_EQ(1e-2f, Strtof(vector, -2));
680 CHECK_EQ(1e-5f, Strtof(vector, -5));
681 CHECK_EQ(1e-20f, Strtof(vector, -20));
682 CHECK_EQ(1e-22f, Strtof(vector, -22));
683 CHECK_EQ(1e-23f, Strtof(vector, -23));
684 CHECK_EQ(1e-25f, Strtof(vector, -25));
685 CHECK_EQ(1e-39f, Strtof(vector, -39));
686
687 vector = StringToVector("2");
688 CHECK_EQ(2.0f, Strtof(vector, 0));
689 CHECK_EQ(20.0f, Strtof(vector, 1));
690 CHECK_EQ(200.0f, Strtof(vector, 2));
691 CHECK_EQ(2e20f, Strtof(vector, 20));
692 CHECK_EQ(2e22f, Strtof(vector, 22));
693 CHECK_EQ(2e23f, Strtof(vector, 23));
694 CHECK_EQ(2e35f, Strtof(vector, 35));
695 CHECK_EQ(2e36f, Strtof(vector, 36));
696 CHECK_EQ(2e37f, Strtof(vector, 37));
697 CHECK_EQ(2e-1f, Strtof(vector, -1));
698 CHECK_EQ(2e-2f, Strtof(vector, -2));
699 CHECK_EQ(2e-5f, Strtof(vector, -5));
700 CHECK_EQ(2e-20f, Strtof(vector, -20));
701 CHECK_EQ(2e-22f, Strtof(vector, -22));
702 CHECK_EQ(2e-23f, Strtof(vector, -23));
703 CHECK_EQ(2e-25f, Strtof(vector, -25));
704 CHECK_EQ(2e-39f, Strtof(vector, -39));
705
706 vector = StringToVector("9");
707 CHECK_EQ(9.0f, Strtof(vector, 0));
708 CHECK_EQ(90.0f, Strtof(vector, 1));
709 CHECK_EQ(900.0f, Strtof(vector, 2));
710 CHECK_EQ(9e20f, Strtof(vector, 20));
711 CHECK_EQ(9e22f, Strtof(vector, 22));
712 CHECK_EQ(9e23f, Strtof(vector, 23));
713 CHECK_EQ(9e35f, Strtof(vector, 35));
714 CHECK_EQ(9e36f, Strtof(vector, 36));
715 CHECK_EQ(9e37f, Strtof(vector, 37));
716 CHECK_EQ(9e-1f, Strtof(vector, -1));
717 CHECK_EQ(9e-2f, Strtof(vector, -2));
718 CHECK_EQ(9e-5f, Strtof(vector, -5));
719 CHECK_EQ(9e-20f, Strtof(vector, -20));
720 CHECK_EQ(9e-22f, Strtof(vector, -22));
721 CHECK_EQ(9e-23f, Strtof(vector, -23));
722 CHECK_EQ(9e-25f, Strtof(vector, -25));
723 CHECK_EQ(9e-39f, Strtof(vector, -39));
724
725 vector = StringToVector("12345");
726 CHECK_EQ(12345.0f, Strtof(vector, 0));
727 CHECK_EQ(123450.0f, Strtof(vector, 1));
728 CHECK_EQ(1234500.0f, Strtof(vector, 2));
729 CHECK_EQ(12345e20f, Strtof(vector, 20));
730 CHECK_EQ(12345e22f, Strtof(vector, 22));
731 CHECK_EQ(12345e23f, Strtof(vector, 23));
732 CHECK_EQ(12345e30f, Strtof(vector, 30));
733 CHECK_EQ(12345e31f, Strtof(vector, 31));
734 CHECK_EQ(12345e32f, Strtof(vector, 32));
735 CHECK_EQ(12345e-1f, Strtof(vector, -1));
736 CHECK_EQ(12345e-2f, Strtof(vector, -2));
737 CHECK_EQ(12345e-5f, Strtof(vector, -5));
738 CHECK_EQ(12345e-20f, Strtof(vector, -20));
739 CHECK_EQ(12345e-22f, Strtof(vector, -22));
740 CHECK_EQ(12345e-23f, Strtof(vector, -23));
741 CHECK_EQ(12345e-25f, Strtof(vector, -25));
742 CHECK_EQ(12345e-39f, Strtof(vector, -39));
743
744 vector = StringToVector("12345678901234");
745 CHECK_EQ(12345678901234.0f, Strtof(vector, 0));
746 CHECK_EQ(123456789012340.0f, Strtof(vector, 1));
747 CHECK_EQ(1234567890123400.0f, Strtof(vector, 2));
748 CHECK_EQ(12345678901234e20f, Strtof(vector, 20));
749 CHECK_EQ(12345678901234e22f, Strtof(vector, 22));
750 CHECK_EQ(12345678901234e23f, Strtof(vector, 23));
751 CHECK_EQ(12345678901234e-1f, Strtof(vector, -1));
752 CHECK_EQ(12345678901234e-2f, Strtof(vector, -2));
753 CHECK_EQ(12345678901234e-5f, Strtof(vector, -5));
754 CHECK_EQ(12345678901234e-20f, Strtof(vector, -20));
755 CHECK_EQ(12345678901234e-22f, Strtof(vector, -22));
756 CHECK_EQ(12345678901234e-23f, Strtof(vector, -23));
757 CHECK_EQ(12345678901234e-25f, Strtof(vector, -25));
758 CHECK_EQ(12345678901234e-39f, Strtof(vector, -39));
759
760 vector = StringToVector("123456789012345");
761 CHECK_EQ(123456789012345.0f, Strtof(vector, 0));
762 CHECK_EQ(1234567890123450.0f, Strtof(vector, 1));
763 CHECK_EQ(12345678901234500.0f, Strtof(vector, 2));
764 CHECK_EQ(123456789012345e20f, Strtof(vector, 20));
765 CHECK_EQ(123456789012345e22f, Strtof(vector, 22));
766 CHECK_EQ(123456789012345e23f, Strtof(vector, 23));
767 CHECK_EQ(123456789012345e-1f, Strtof(vector, -1));
768 CHECK_EQ(123456789012345e-2f, Strtof(vector, -2));
769 CHECK_EQ(123456789012345e-5f, Strtof(vector, -5));
770 CHECK_EQ(123456789012345e-20f, Strtof(vector, -20));
771 CHECK_EQ(123456789012345e-22f, Strtof(vector, -22));
772 CHECK_EQ(123456789012345e-23f, Strtof(vector, -23));
773 CHECK_EQ(123456789012345e-25f, Strtof(vector, -25));
774 CHECK_EQ(123456789012345e-39f, Strtof(vector, -39));
775
776 CHECK_EQ(0.0f, StrtofChar("0", 12345));
777 CHECK_EQ(0.0f, StrtofChar("", 1324));
778 CHECK_EQ(0.0f, StrtofChar("000000000", 123));
779 CHECK_EQ(0.0f, StrtofChar("2", -324));
780 CHECK_EQ(1e-45f, StrtofChar("1", -45));
781 // It would be more readable to put non-zero literals on the left side (i.e.
782 // CHECK_EQ(1e-46, StrtofChar("1", -45))), but then Gcc complains that
783 // they are truncated to zero.
784 CHECK_EQ(0.0f, StrtofChar("1", -46));
785 CHECK_EQ(0.0f, StrtofChar("1", -47));
786 CHECK_EQ(1e-45f, StrtofChar("1", -45));
787 CHECK_EQ(1e-45f, StrtofChar("8", -46));
788 CHECK_EQ(0.0f, StrtofChar("200000", -51));
789 CHECK_EQ(100000e-50f, StrtofChar("100000", -50));
790 CHECK_EQ(0.0f, StrtofChar("100000", -51));
791 CHECK_EQ(0.0f, StrtofChar("900000", -52));
792 CHECK_EQ(0.0f, StrtofChar("000000001", -47));
793 CHECK_EQ(0.0f, StrtofChar("000000001", -47));
794 CHECK_EQ(0.0f, StrtofChar("00000000200000", -51));
795 CHECK_EQ(800000e-50f, StrtofChar("000000800000", -50));
796 CHECK_EQ(0.0f, StrtofChar("00000000100000", -51));
797 CHECK_EQ(1e-45f, StrtofChar("00000000900000", -51));
798
799 // It would be more readable to put the literals (and not Double::Infinity())
800 // on the left side (i.e. CHECK_EQ(3e38, StrtofChar("3", 38))), but then Gcc
801 // complains that the floating constant exceeds range of 'double'.
802 CHECK_EQ(Single::Infinity(), StrtofChar("3", 39));
803 CHECK_EQ(3e38f, StrtofChar("3", 38));
804 CHECK_EQ(3401e35f, StrtofChar("3401", 35));
805 CHECK_EQ(3401e34f, StrtofChar("3401", 34));
806 CHECK_EQ(Single::Infinity(), StrtofChar("3410", 35));
807 CHECK_EQ(34e37f, StrtofChar("34", 37));
808 CHECK_EQ(Single::Infinity(), StrtofChar("0000001", 39));
809 CHECK_EQ(3401e35f, StrtofChar("0000003401", 35));
810 CHECK_EQ(3401e34f, StrtofChar("0000003401", 34));
811 CHECK_EQ(Single::Infinity(), StrtofChar("0000003410", 35));
812 CHECK_EQ(34e37f, StrtofChar("00000034", 37));
813 CHECK_EQ(1e38f, StrtofChar("100000", 33));
814 CHECK_EQ(3401e35f, StrtofChar("340100000", 30));
815 CHECK_EQ(3401e34f, StrtofChar("340100000", 29));
816 CHECK_EQ(Single::Infinity(), StrtofChar("341000000", 30));
817 CHECK_EQ(34e37f, StrtofChar("3400000", 32));
818 CHECK_EQ(1e38f, StrtofChar("00000100000", 33));
819 CHECK_EQ(3401e35f, StrtofChar("00000340100000", 30));
820 CHECK_EQ(3401e34f, StrtofChar("00000340100000", 29));
821 CHECK_EQ(Single::Infinity(), StrtofChar("00000341000000", 30));
822 CHECK_EQ(34e37f, StrtofChar("000003400000", 32));
823 CHECK_EQ(3.4028234e+38f, StrtofChar("34028235676", 28));
824 CHECK_EQ(3.4028234e+38f, StrtofChar("34028235677", 28));
825 CHECK_EQ(Single::Infinity(), StrtofChar("34028235678", 28));
826
827 // The following number is the result of 89255.0/1e-22. Both floating-point
828 // numbers can be accurately represented with doubles. However on Linux,x86
829 // the floating-point stack is set to 80bits and the double-rounding
830 // introduces an error.
831 CHECK_EQ(89255e-22f, StrtofChar("89255", -22));
832
833 // Boundary cases. Boundaries themselves should round to even.
834 //
835 // 0x4f012334 = 2166567936
836 // next: 2166568192
837 // boundary: 2166568064 should round down.
838 CHECK_EQ(2166567936.0f, StrtofChar("2166567936", 0));
839 CHECK_EQ(2166568192.0f, StrtofChar("2166568192", 0));
840 CHECK_EQ(2166567936.0f, StrtofChar("2166568064", 0));
841 CHECK_EQ(2166567936.0f, StrtofChar("216656806399999", -5));
842 CHECK_EQ(2166568192.0f, StrtofChar("216656806400001", -5));
843 // Verify that we don't double round.
844 // Get the boundary of the boundary.
845 CHECK_EQ(2.1665680640000002384185791015625e9, 2166568064.0);
846 // Visual Studio gets this wrong and believes that these two numbers are the
847 // same doubles. We want to test our conversion and not the compiler. We
848 // therefore disable the check.
849 #ifndef _MSC_VER
850 CHECK(2.16656806400000023841857910156251e9 != 2166568064.0);
851 #endif
852 CHECK_EQ(2166568192.0f, StrtofChar("21665680640000002384185791015625", -22));
853
854 // 0x4fffffff = 8589934080
855 // next: 8589934592
856 // boundary: 8589934336 should round up.
857 CHECK_EQ(8589934080.0f, StrtofChar("8589934080", 0));
858 CHECK_EQ(8589934592.0f, StrtofChar("8589934592", 0));
859 CHECK_EQ(8589934592.0f, StrtofChar("8589934336", 0));
860 CHECK_EQ(8589934080.0f, StrtofChar("858993433599999", -5));
861 CHECK_EQ(8589934592.0f, StrtofChar("858993433600001", -5));
862 // Verify that we don't double round.
863 // Get the boundary of the boundary.
864 // Visual Studio gets this wrong. To avoid failing tests because of a broken
865 // compiler we disable the following two tests. They were only testing the
866 // compiler. The real test is still active.
867 #ifndef _MSC_VER
868 CHECK_EQ(8.589934335999999523162841796875e+09, 8589934336.0);
869 CHECK(8.5899343359999995231628417968749e+09 != 8589934336.0);
870 #endif
871 CHECK_EQ(8589934080.0f, StrtofChar("8589934335999999523162841796875", -21));
872
873 // 0x4f000000 = 2147483648
874 // next: 2147483904
875 // boundary: 2147483776 should round down.
876 CHECK_EQ(2147483648.0f, StrtofChar("2147483648", 0));
877 CHECK_EQ(2147483904.0f, StrtofChar("2147483904", 0));
878 CHECK_EQ(2147483648.0f, StrtofChar("2147483776", 0));
879 CHECK_EQ(2147483648.0f, StrtofChar("214748377599999", -5));
880 CHECK_EQ(2147483904.0f, StrtofChar("214748377600001", -5));
881
882 }
883
TEST(StrtofTrimmed)884 TEST(StrtofTrimmed) {
885 Vector<const char> vector;
886
887 vector = StringToVector("1");
888 CHECK_EQ(1.0f, StrtofTrimmed(vector, 0));
889 CHECK_EQ(10.0f, StrtofTrimmed(vector, 1));
890 CHECK_EQ(100.0f, StrtofTrimmed(vector, 2));
891 CHECK_EQ(1e20f, StrtofTrimmed(vector, 20));
892 CHECK_EQ(1e22f, StrtofTrimmed(vector, 22));
893 CHECK_EQ(1e23f, StrtofTrimmed(vector, 23));
894 CHECK_EQ(1e35f, StrtofTrimmed(vector, 35));
895 CHECK_EQ(1e36f, StrtofTrimmed(vector, 36));
896 CHECK_EQ(1e37f, StrtofTrimmed(vector, 37));
897 CHECK_EQ(1e-1f, StrtofTrimmed(vector, -1));
898 CHECK_EQ(1e-2f, StrtofTrimmed(vector, -2));
899 CHECK_EQ(1e-5f, StrtofTrimmed(vector, -5));
900 CHECK_EQ(1e-20f, StrtofTrimmed(vector, -20));
901 CHECK_EQ(1e-22f, StrtofTrimmed(vector, -22));
902 CHECK_EQ(1e-23f, StrtofTrimmed(vector, -23));
903 CHECK_EQ(1e-25f, StrtofTrimmed(vector, -25));
904 CHECK_EQ(1e-39f, StrtofTrimmed(vector, -39));
905
906 vector = StringToVector("2");
907 CHECK_EQ(2.0f, StrtofTrimmed(vector, 0));
908 CHECK_EQ(20.0f, StrtofTrimmed(vector, 1));
909 CHECK_EQ(200.0f, StrtofTrimmed(vector, 2));
910 CHECK_EQ(2e20f, StrtofTrimmed(vector, 20));
911 CHECK_EQ(2e22f, StrtofTrimmed(vector, 22));
912 CHECK_EQ(2e23f, StrtofTrimmed(vector, 23));
913 CHECK_EQ(2e35f, StrtofTrimmed(vector, 35));
914 CHECK_EQ(2e36f, StrtofTrimmed(vector, 36));
915 CHECK_EQ(2e37f, StrtofTrimmed(vector, 37));
916 CHECK_EQ(2e-1f, StrtofTrimmed(vector, -1));
917 CHECK_EQ(2e-2f, StrtofTrimmed(vector, -2));
918 CHECK_EQ(2e-5f, StrtofTrimmed(vector, -5));
919 CHECK_EQ(2e-20f, StrtofTrimmed(vector, -20));
920 CHECK_EQ(2e-22f, StrtofTrimmed(vector, -22));
921 CHECK_EQ(2e-23f, StrtofTrimmed(vector, -23));
922 CHECK_EQ(2e-25f, StrtofTrimmed(vector, -25));
923 CHECK_EQ(2e-39f, StrtofTrimmed(vector, -39));
924
925 vector = StringToVector("9");
926 CHECK_EQ(9.0f, StrtofTrimmed(vector, 0));
927 CHECK_EQ(90.0f, StrtofTrimmed(vector, 1));
928 CHECK_EQ(900.0f, StrtofTrimmed(vector, 2));
929 CHECK_EQ(9e20f, StrtofTrimmed(vector, 20));
930 CHECK_EQ(9e22f, StrtofTrimmed(vector, 22));
931 CHECK_EQ(9e23f, StrtofTrimmed(vector, 23));
932 CHECK_EQ(9e35f, StrtofTrimmed(vector, 35));
933 CHECK_EQ(9e36f, StrtofTrimmed(vector, 36));
934 CHECK_EQ(9e37f, StrtofTrimmed(vector, 37));
935 CHECK_EQ(9e-1f, StrtofTrimmed(vector, -1));
936 CHECK_EQ(9e-2f, StrtofTrimmed(vector, -2));
937 CHECK_EQ(9e-5f, StrtofTrimmed(vector, -5));
938 CHECK_EQ(9e-20f, StrtofTrimmed(vector, -20));
939 CHECK_EQ(9e-22f, StrtofTrimmed(vector, -22));
940 CHECK_EQ(9e-23f, StrtofTrimmed(vector, -23));
941 CHECK_EQ(9e-25f, StrtofTrimmed(vector, -25));
942 CHECK_EQ(9e-39f, StrtofTrimmed(vector, -39));
943
944 vector = StringToVector("12345");
945 CHECK_EQ(12345.0f, StrtofTrimmed(vector, 0));
946 CHECK_EQ(123450.0f, StrtofTrimmed(vector, 1));
947 CHECK_EQ(1234500.0f, StrtofTrimmed(vector, 2));
948 CHECK_EQ(12345e20f, StrtofTrimmed(vector, 20));
949 CHECK_EQ(12345e22f, StrtofTrimmed(vector, 22));
950 CHECK_EQ(12345e23f, StrtofTrimmed(vector, 23));
951 CHECK_EQ(12345e30f, StrtofTrimmed(vector, 30));
952 CHECK_EQ(12345e31f, StrtofTrimmed(vector, 31));
953 CHECK_EQ(12345e32f, StrtofTrimmed(vector, 32));
954 CHECK_EQ(12345e-1f, StrtofTrimmed(vector, -1));
955 CHECK_EQ(12345e-2f, StrtofTrimmed(vector, -2));
956 CHECK_EQ(12345e-5f, StrtofTrimmed(vector, -5));
957 CHECK_EQ(12345e-20f, StrtofTrimmed(vector, -20));
958 CHECK_EQ(12345e-22f, StrtofTrimmed(vector, -22));
959 CHECK_EQ(12345e-23f, StrtofTrimmed(vector, -23));
960 CHECK_EQ(12345e-25f, StrtofTrimmed(vector, -25));
961 CHECK_EQ(12345e-39f, StrtofTrimmed(vector, -39));
962
963 vector = StringToVector("12345678901234");
964 CHECK_EQ(12345678901234.0f, StrtofTrimmed(vector, 0));
965 CHECK_EQ(123456789012340.0f, StrtofTrimmed(vector, 1));
966 CHECK_EQ(1234567890123400.0f, StrtofTrimmed(vector, 2));
967 CHECK_EQ(12345678901234e20f, StrtofTrimmed(vector, 20));
968 CHECK_EQ(12345678901234e22f, StrtofTrimmed(vector, 22));
969 CHECK_EQ(12345678901234e23f, StrtofTrimmed(vector, 23));
970 CHECK_EQ(12345678901234e-1f, StrtofTrimmed(vector, -1));
971 CHECK_EQ(12345678901234e-2f, StrtofTrimmed(vector, -2));
972 CHECK_EQ(12345678901234e-5f, StrtofTrimmed(vector, -5));
973 CHECK_EQ(12345678901234e-20f, StrtofTrimmed(vector, -20));
974 CHECK_EQ(12345678901234e-22f, StrtofTrimmed(vector, -22));
975 CHECK_EQ(12345678901234e-23f, StrtofTrimmed(vector, -23));
976 CHECK_EQ(12345678901234e-25f, StrtofTrimmed(vector, -25));
977 CHECK_EQ(12345678901234e-39f, StrtofTrimmed(vector, -39));
978
979 vector = StringToVector("123456789012345");
980 CHECK_EQ(123456789012345.0f, StrtofTrimmed(vector, 0));
981 CHECK_EQ(1234567890123450.0f, StrtofTrimmed(vector, 1));
982 CHECK_EQ(12345678901234500.0f, StrtofTrimmed(vector, 2));
983 CHECK_EQ(123456789012345e20f, StrtofTrimmed(vector, 20));
984 CHECK_EQ(123456789012345e22f, StrtofTrimmed(vector, 22));
985 CHECK_EQ(123456789012345e23f, StrtofTrimmed(vector, 23));
986 CHECK_EQ(123456789012345e-1f, StrtofTrimmed(vector, -1));
987 CHECK_EQ(123456789012345e-2f, StrtofTrimmed(vector, -2));
988 CHECK_EQ(123456789012345e-5f, StrtofTrimmed(vector, -5));
989 CHECK_EQ(123456789012345e-20f, StrtofTrimmed(vector, -20));
990 CHECK_EQ(123456789012345e-22f, StrtofTrimmed(vector, -22));
991 CHECK_EQ(123456789012345e-23f, StrtofTrimmed(vector, -23));
992 CHECK_EQ(123456789012345e-25f, StrtofTrimmed(vector, -25));
993 CHECK_EQ(123456789012345e-39f, StrtofTrimmed(vector, -39));
994
995 CHECK_EQ(0.0f, StrtofTrimmedChar("", 1324));
996 CHECK_EQ(0.0f, StrtofTrimmedChar("2", -324));
997 CHECK_EQ(1e-45f, StrtofTrimmedChar("1", -45));
998 // It would be more readable to put non-zero literals on the left side (i.e.
999 // CHECK_EQ(1e-46, StrtofChar("1", -45))), but then Gcc complains that
1000 // they are truncated to zero.
1001 CHECK_EQ(0.0f, StrtofTrimmedChar("1", -46));
1002 CHECK_EQ(0.0f, StrtofTrimmedChar("1", -47));
1003 CHECK_EQ(1e-45f, StrtofTrimmedChar("1", -45));
1004 CHECK_EQ(1e-45f, StrtofTrimmedChar("8", -46));
1005
1006 // It would be more readable to put the literals (and not Double::Infinity())
1007 // on the left side (i.e. CHECK_EQ(3e38, StrtofChar("3", 38))), but then Gcc
1008 // complains that the floating constant exceeds range of 'double'.
1009 CHECK_EQ(Single::Infinity(), StrtofTrimmedChar("3", 39));
1010 CHECK_EQ(3e38f, StrtofTrimmedChar("3", 38));
1011 CHECK_EQ(3401e35f, StrtofTrimmedChar("3401", 35));
1012 CHECK_EQ(3401e34f, StrtofTrimmedChar("3401", 34));
1013 CHECK_EQ(34e37f, StrtofTrimmedChar("34", 37));
1014 CHECK_EQ(3.4028234e+38f, StrtofTrimmedChar("34028235676", 28));
1015 CHECK_EQ(3.4028234e+38f, StrtofTrimmedChar("34028235677", 28));
1016 CHECK_EQ(Single::Infinity(), StrtofTrimmedChar("34028235678", 28));
1017
1018 // The following number is the result of 89255.0/1e-22. Both floating-point
1019 // numbers can be accurately represented with doubles. However on Linux,x86
1020 // the floating-point stack is set to 80bits and the double-rounding
1021 // introduces an error.
1022 CHECK_EQ(89255e-22f, StrtofTrimmedChar("89255", -22));
1023
1024 // Boundary cases. Boundaries themselves should round to even.
1025 //
1026 // 0x4f012334 = 2166567936
1027 // next: 2166568192
1028 // boundary: 2166568064 should round down.
1029 CHECK_EQ(2166567936.0f, StrtofTrimmedChar("2166567936", 0));
1030 CHECK_EQ(2166568192.0f, StrtofTrimmedChar("2166568192", 0));
1031 CHECK_EQ(2166567936.0f, StrtofTrimmedChar("2166568064", 0));
1032 CHECK_EQ(2166567936.0f, StrtofTrimmedChar("216656806399999", -5));
1033 CHECK_EQ(2166568192.0f, StrtofTrimmedChar("216656806400001", -5));
1034 // Verify that we don't double round.
1035 // Get the boundary of the boundary.
1036 CHECK_EQ(2.1665680640000002384185791015625e9, 2166568064.0);
1037 // Visual Studio gets this wrong and believes that these two numbers are the
1038 // same doubles. We want to test our conversion and not the compiler. We
1039 // therefore disable the check.
1040 #ifndef _MSC_VER
1041 CHECK(2.16656806400000023841857910156251e9 != 2166568064.0);
1042 #endif
1043 CHECK_EQ(2166568192.0f, StrtofTrimmedChar("21665680640000002384185791015625", -22));
1044
1045 // 0x4fffffff = 8589934080
1046 // next: 8589934592
1047 // boundary: 8589934336 should round up.
1048 CHECK_EQ(8589934592.0f, StrtofTrimmedChar("8589934592", 0));
1049 CHECK_EQ(8589934592.0f, StrtofTrimmedChar("8589934336", 0));
1050 CHECK_EQ(8589934080.0f, StrtofTrimmedChar("858993433599999", -5));
1051 CHECK_EQ(8589934592.0f, StrtofTrimmedChar("858993433600001", -5));
1052 // Verify that we don't double round.
1053 // Get the boundary of the boundary.
1054 // Visual Studio gets this wrong. To avoid failing tests because of a broken
1055 // compiler we disable the following two tests. They were only testing the
1056 // compiler. The real test is still active.
1057 #ifndef _MSC_VER
1058 CHECK_EQ(8.589934335999999523162841796875e+09, 8589934336.0);
1059 CHECK(8.5899343359999995231628417968749e+09 != 8589934336.0);
1060 #endif
1061 CHECK_EQ(8589934080.0f, StrtofTrimmedChar("8589934335999999523162841796875", -21));
1062
1063 // 0x4f000000 = 2147483648
1064 // next: 2147483904
1065 // boundary: 2147483776 should round down.
1066 CHECK_EQ(2147483648.0f, StrtofTrimmedChar("2147483648", 0));
1067 CHECK_EQ(2147483904.0f, StrtofTrimmedChar("2147483904", 0));
1068 CHECK_EQ(2147483648.0f, StrtofTrimmedChar("2147483776", 0));
1069 CHECK_EQ(2147483648.0f, StrtofTrimmedChar("214748377599999", -5));
1070 CHECK_EQ(2147483904.0f, StrtofTrimmedChar("214748377600001", -5));
1071 }
1072
CompareBignumToDiyFp(const Bignum & bignum_digits,int bignum_exponent,DiyFp diy_fp)1073 static int CompareBignumToDiyFp(const Bignum& bignum_digits,
1074 int bignum_exponent,
1075 DiyFp diy_fp) {
1076 Bignum bignum;
1077 bignum.AssignBignum(bignum_digits);
1078 Bignum other;
1079 other.AssignUInt64(diy_fp.f());
1080 if (bignum_exponent >= 0) {
1081 bignum.MultiplyByPowerOfTen(bignum_exponent);
1082 } else {
1083 other.MultiplyByPowerOfTen(-bignum_exponent);
1084 }
1085 if (diy_fp.e() >= 0) {
1086 other.ShiftLeft(diy_fp.e());
1087 } else {
1088 bignum.ShiftLeft(-diy_fp.e());
1089 }
1090 return Bignum::Compare(bignum, other);
1091 }
1092
1093
CheckDouble(Vector<const char> buffer,int exponent,double to_check)1094 static bool CheckDouble(Vector<const char> buffer,
1095 int exponent,
1096 double to_check) {
1097 DiyFp lower_boundary;
1098 DiyFp upper_boundary;
1099 Bignum input_digits;
1100 input_digits.AssignDecimalString(buffer);
1101 if (to_check == 0.0) {
1102 const double kMinDouble = 4e-324;
1103 // Check that the buffer*10^exponent < (0 + kMinDouble)/2.
1104 Double d(kMinDouble);
1105 d.NormalizedBoundaries(&lower_boundary, &upper_boundary);
1106 return CompareBignumToDiyFp(input_digits, exponent, lower_boundary) <= 0;
1107 }
1108 if (to_check == Double::Infinity()) {
1109 const double kMaxDouble = 1.7976931348623157e308;
1110 // Check that the buffer*10^exponent >= boundary between kMaxDouble and inf.
1111 Double d(kMaxDouble);
1112 d.NormalizedBoundaries(&lower_boundary, &upper_boundary);
1113 return CompareBignumToDiyFp(input_digits, exponent, upper_boundary) >= 0;
1114 }
1115 Double d(to_check);
1116 d.NormalizedBoundaries(&lower_boundary, &upper_boundary);
1117 if ((d.Significand() & 1) == 0) {
1118 return CompareBignumToDiyFp(input_digits, exponent, lower_boundary) >= 0 &&
1119 CompareBignumToDiyFp(input_digits, exponent, upper_boundary) <= 0;
1120 } else {
1121 return CompareBignumToDiyFp(input_digits, exponent, lower_boundary) > 0 &&
1122 CompareBignumToDiyFp(input_digits, exponent, upper_boundary) < 0;
1123 }
1124 }
1125
1126
1127 // Copied from v8.cc and adapted to make the function deterministic.
DeterministicRandom()1128 static uint32_t DeterministicRandom() {
1129 // Random number generator using George Marsaglia's MWC algorithm.
1130 static uint32_t hi = 0;
1131 static uint32_t lo = 0;
1132
1133 // Initialization values don't have any special meaning. (They are the result
1134 // of two calls to random().)
1135 if (hi == 0) hi = 0xbfe166e7;
1136 if (lo == 0) lo = 0x64d1c3c9;
1137
1138 // Mix the bits.
1139 hi = 36969 * (hi & 0xFFFF) + (hi >> 16);
1140 lo = 18273 * (lo & 0xFFFF) + (lo >> 16);
1141 return (hi << 16) + (lo & 0xFFFF);
1142 }
1143
1144
1145 static const int kBufferSize = 1024;
1146 static const int kShortStrtodRandomCount = 2;
1147 static const int kLargeStrtodRandomCount = 2;
1148
TEST(RandomStrtod)1149 TEST(RandomStrtod) {
1150 char buffer[kBufferSize];
1151 for (int length = 1; length < 15; length++) {
1152 for (int i = 0; i < kShortStrtodRandomCount; ++i) {
1153 int pos = 0;
1154 for (int j = 0; j < length; ++j) {
1155 buffer[pos++] = DeterministicRandom() % 10 + '0';
1156 }
1157 int exponent = DeterministicRandom() % (25*2 + 1) - 25 - length;
1158 buffer[pos] = '\0';
1159 Vector<const char> vector(buffer, pos);
1160 double strtod_result = Strtod(vector, exponent);
1161 CHECK(CheckDouble(vector, exponent, strtod_result));
1162 }
1163 }
1164 for (int length = 15; length < 800; length += 2) {
1165 for (int i = 0; i < kLargeStrtodRandomCount; ++i) {
1166 int pos = 0;
1167 for (int j = 0; j < length; ++j) {
1168 buffer[pos++] = DeterministicRandom() % 10 + '0';
1169 }
1170 int exponent = DeterministicRandom() % (308*2 + 1) - 308 - length;
1171 buffer[pos] = '\0';
1172 Vector<const char> vector(buffer, pos);
1173 double strtod_result = Strtod(vector, exponent);
1174 CHECK(CheckDouble(vector, exponent, strtod_result));
1175 }
1176 }
1177 }
1178
1179
CheckFloat(Vector<const char> buffer,int exponent,float to_check)1180 static bool CheckFloat(Vector<const char> buffer,
1181 int exponent,
1182 float to_check) {
1183 DiyFp lower_boundary;
1184 DiyFp upper_boundary;
1185 Bignum input_digits;
1186 input_digits.AssignDecimalString(buffer);
1187 if (to_check == 0.0) {
1188 const float kMinFloat = 1e-45f;
1189 // Check that the buffer*10^exponent < (0 + kMinFloat)/2.
1190 Single s(kMinFloat);
1191 s.NormalizedBoundaries(&lower_boundary, &upper_boundary);
1192 return CompareBignumToDiyFp(input_digits, exponent, lower_boundary) <= 0;
1193 }
1194 if (to_check == static_cast<float>(Double::Infinity())) {
1195 const float kMaxFloat = 3.4028234e38f;
1196 // Check that the buffer*10^exponent >= boundary between kMaxFloat and inf.
1197 Single s(kMaxFloat);
1198 s.NormalizedBoundaries(&lower_boundary, &upper_boundary);
1199 return CompareBignumToDiyFp(input_digits, exponent, upper_boundary) >= 0;
1200 }
1201 Single s(to_check);
1202 s.NormalizedBoundaries(&lower_boundary, &upper_boundary);
1203 if ((s.Significand() & 1) == 0) {
1204 return CompareBignumToDiyFp(input_digits, exponent, lower_boundary) >= 0 &&
1205 CompareBignumToDiyFp(input_digits, exponent, upper_boundary) <= 0;
1206 } else {
1207 return CompareBignumToDiyFp(input_digits, exponent, lower_boundary) > 0 &&
1208 CompareBignumToDiyFp(input_digits, exponent, upper_boundary) < 0;
1209 }
1210 }
1211
1212
1213 static const int kShortStrtofRandomCount = 2;
1214 static const int kLargeStrtofRandomCount = 2;
1215
TEST(RandomStrtof)1216 TEST(RandomStrtof) {
1217 char buffer[kBufferSize];
1218 for (int length = 1; length < 15; length++) {
1219 for (int i = 0; i < kShortStrtofRandomCount; ++i) {
1220 int pos = 0;
1221 for (int j = 0; j < length; ++j) {
1222 buffer[pos++] = DeterministicRandom() % 10 + '0';
1223 }
1224 int exponent = DeterministicRandom() % (5*2 + 1) - 5 - length;
1225 buffer[pos] = '\0';
1226 Vector<const char> vector(buffer, pos);
1227 float strtof_result = Strtof(vector, exponent);
1228 CHECK(CheckFloat(vector, exponent, strtof_result));
1229 }
1230 }
1231 for (int length = 15; length < 800; length += 2) {
1232 for (int i = 0; i < kLargeStrtofRandomCount; ++i) {
1233 int pos = 0;
1234 for (int j = 0; j < length; ++j) {
1235 buffer[pos++] = DeterministicRandom() % 10 + '0';
1236 }
1237 int exponent = DeterministicRandom() % (38*2 + 1) - 38 - length;
1238 buffer[pos] = '\0';
1239 Vector<const char> vector(buffer, pos);
1240 float strtof_result = Strtof(vector, exponent);
1241 CHECK(CheckFloat(vector, exponent, strtof_result));
1242 }
1243 }
1244 }
1245