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 37using namespace double_conversion; 38 39static 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 45static double StrtodChar(const char* str, int exponent) { 46 return Strtod(StringToVector(str), exponent); 47} 48 49 50static double StrtodTrimmedChar(const char* str, int exponent) { 51 return StrtodTrimmed(StringToVector(str), exponent); 52} 53 54 55static float StrtofChar(const char* str, int exponent) { 56 return Strtof(StringToVector(str), exponent); 57} 58 59static float StrtofTrimmedChar(const char* str, int exponent) { 60 return StrtofTrimmed(StringToVector(str), exponent); 61} 62 63 64TEST(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 388TEST(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 658TEST(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 884TEST(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 1073static 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 1094static 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. 1128static 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 1145static const int kBufferSize = 1024; 1146static const int kShortStrtodRandomCount = 2; 1147static const int kLargeStrtodRandomCount = 2; 1148 1149TEST(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 1180static 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 1213static const int kShortStrtofRandomCount = 2; 1214static const int kLargeStrtofRandomCount = 2; 1215 1216TEST(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