Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 1 | # Tests for the correctly-rounded string -> float conversions |
| 2 | # introduced in Python 2.7 and 3.1. |
| 3 | |
| 4 | import random |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 5 | import unittest |
| 6 | import re |
| 7 | import sys |
| 8 | import test.support |
| 9 | |
Mark Dickinson | 7b26d7f | 2010-02-07 20:32:50 +0000 | [diff] [blame] | 10 | if getattr(sys, 'float_repr_style', '') != 'short': |
| 11 | raise unittest.SkipTest('correctly-rounded string->float conversions ' |
| 12 | 'not available on this system') |
| 13 | |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 14 | # Correctly rounded str -> float in pure Python, for comparison. |
| 15 | |
| 16 | strtod_parser = re.compile(r""" # A numeric string consists of: |
| 17 | (?P<sign>[-+])? # an optional sign, followed by |
| 18 | (?=\d|\.\d) # a number with at least one digit |
| 19 | (?P<int>\d*) # having a (possibly empty) integer part |
| 20 | (?:\.(?P<frac>\d*))? # followed by an optional fractional part |
| 21 | (?:E(?P<exp>[-+]?\d+))? # and an optional exponent |
| 22 | \Z |
| 23 | """, re.VERBOSE | re.IGNORECASE).match |
| 24 | |
Mark Dickinson | 6ded1d5 | 2010-06-20 20:01:04 +0000 | [diff] [blame] | 25 | # Pure Python version of correctly rounded string->float conversion. |
| 26 | # Avoids any use of floating-point by returning the result as a hex string. |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 27 | def strtod(s, mant_dig=53, min_exp = -1021, max_exp = 1024): |
| 28 | """Convert a finite decimal string to a hex string representing an |
| 29 | IEEE 754 binary64 float. Return 'inf' or '-inf' on overflow. |
| 30 | This function makes no use of floating-point arithmetic at any |
| 31 | stage.""" |
| 32 | |
| 33 | # parse string into a pair of integers 'a' and 'b' such that |
| 34 | # abs(decimal value) = a/b, along with a boolean 'negative'. |
| 35 | m = strtod_parser(s) |
| 36 | if m is None: |
| 37 | raise ValueError('invalid numeric string') |
| 38 | fraction = m.group('frac') or '' |
| 39 | intpart = int(m.group('int') + fraction) |
| 40 | exp = int(m.group('exp') or '0') - len(fraction) |
| 41 | negative = m.group('sign') == '-' |
| 42 | a, b = intpart*10**max(exp, 0), 10**max(0, -exp) |
| 43 | |
| 44 | # quick return for zeros |
| 45 | if not a: |
| 46 | return '-0x0.0p+0' if negative else '0x0.0p+0' |
| 47 | |
| 48 | # compute exponent e for result; may be one too small in the case |
| 49 | # that the rounded value of a/b lies in a different binade from a/b |
| 50 | d = a.bit_length() - b.bit_length() |
| 51 | d += (a >> d if d >= 0 else a << -d) >= b |
| 52 | e = max(d, min_exp) - mant_dig |
| 53 | |
| 54 | # approximate a/b by number of the form q * 2**e; adjust e if necessary |
| 55 | a, b = a << max(-e, 0), b << max(e, 0) |
| 56 | q, r = divmod(a, b) |
| 57 | if 2*r > b or 2*r == b and q & 1: |
| 58 | q += 1 |
| 59 | if q.bit_length() == mant_dig+1: |
| 60 | q //= 2 |
| 61 | e += 1 |
| 62 | |
| 63 | # double check that (q, e) has the right form |
| 64 | assert q.bit_length() <= mant_dig and e >= min_exp - mant_dig |
| 65 | assert q.bit_length() == mant_dig or e == min_exp - mant_dig |
| 66 | |
| 67 | # check for overflow and underflow |
| 68 | if e + q.bit_length() > max_exp: |
| 69 | return '-inf' if negative else 'inf' |
| 70 | if not q: |
| 71 | return '-0x0.0p+0' if negative else '0x0.0p+0' |
| 72 | |
| 73 | # for hex representation, shift so # bits after point is a multiple of 4 |
| 74 | hexdigs = 1 + (mant_dig-2)//4 |
| 75 | shift = 3 - (mant_dig-2)%4 |
| 76 | q, e = q << shift, e - shift |
| 77 | return '{}0x{:x}.{:0{}x}p{:+d}'.format( |
| 78 | '-' if negative else '', |
| 79 | q // 16**hexdigs, |
| 80 | q % 16**hexdigs, |
| 81 | hexdigs, |
| 82 | e + 4*hexdigs) |
| 83 | |
Mark Dickinson | d0ff783 | 2010-02-21 14:49:52 +0000 | [diff] [blame] | 84 | TEST_SIZE = 10 |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 85 | |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 86 | class StrtodTests(unittest.TestCase): |
| 87 | def check_strtod(self, s): |
| 88 | """Compare the result of Python's builtin correctly rounded |
| 89 | string->float conversion (using float) to a pure Python |
| 90 | correctly rounded string->float implementation. Fail if the |
| 91 | two methods give different results.""" |
| 92 | |
| 93 | try: |
| 94 | fs = float(s) |
| 95 | except OverflowError: |
| 96 | got = '-inf' if s[0] == '-' else 'inf' |
Mark Dickinson | 1c7d69b | 2010-01-16 20:34:30 +0000 | [diff] [blame] | 97 | except MemoryError: |
| 98 | got = 'memory error' |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 99 | else: |
| 100 | got = fs.hex() |
| 101 | expected = strtod(s) |
| 102 | self.assertEqual(expected, got, |
| 103 | "Incorrectly rounded str->float conversion for {}: " |
| 104 | "expected {}, got {}".format(s, expected, got)) |
| 105 | |
Mark Dickinson | add2823 | 2010-01-21 19:51:08 +0000 | [diff] [blame] | 106 | def test_short_halfway_cases(self): |
| 107 | # exact halfway cases with a small number of significant digits |
| 108 | for k in 0, 5, 10, 15, 20: |
| 109 | # upper = smallest integer >= 2**54/5**k |
| 110 | upper = -(-2**54//5**k) |
| 111 | # lower = smallest odd number >= 2**53/5**k |
| 112 | lower = -(-2**53//5**k) |
| 113 | if lower % 2 == 0: |
| 114 | lower += 1 |
Mark Dickinson | d0ff783 | 2010-02-21 14:49:52 +0000 | [diff] [blame] | 115 | for i in range(TEST_SIZE): |
Mark Dickinson | add2823 | 2010-01-21 19:51:08 +0000 | [diff] [blame] | 116 | # Select a random odd n in [2**53/5**k, |
| 117 | # 2**54/5**k). Then n * 10**k gives a halfway case |
| 118 | # with small number of significant digits. |
| 119 | n, e = random.randrange(lower, upper, 2), k |
| 120 | |
| 121 | # Remove any additional powers of 5. |
| 122 | while n % 5 == 0: |
| 123 | n, e = n // 5, e + 1 |
| 124 | assert n % 10 in (1, 3, 7, 9) |
| 125 | |
| 126 | # Try numbers of the form n * 2**p2 * 10**e, p2 >= 0, |
| 127 | # until n * 2**p2 has more than 20 significant digits. |
| 128 | digits, exponent = n, e |
| 129 | while digits < 10**20: |
| 130 | s = '{}e{}'.format(digits, exponent) |
| 131 | self.check_strtod(s) |
| 132 | # Same again, but with extra trailing zeros. |
| 133 | s = '{}e{}'.format(digits * 10**40, exponent - 40) |
| 134 | self.check_strtod(s) |
| 135 | digits *= 2 |
| 136 | |
| 137 | # Try numbers of the form n * 5**p2 * 10**(e - p5), p5 |
| 138 | # >= 0, with n * 5**p5 < 10**20. |
| 139 | digits, exponent = n, e |
| 140 | while digits < 10**20: |
| 141 | s = '{}e{}'.format(digits, exponent) |
| 142 | self.check_strtod(s) |
| 143 | # Same again, but with extra trailing zeros. |
| 144 | s = '{}e{}'.format(digits * 10**40, exponent - 40) |
| 145 | self.check_strtod(s) |
| 146 | digits *= 5 |
| 147 | exponent -= 1 |
| 148 | |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 149 | def test_halfway_cases(self): |
| 150 | # test halfway cases for the round-half-to-even rule |
Mark Dickinson | d0ff783 | 2010-02-21 14:49:52 +0000 | [diff] [blame] | 151 | for i in range(100 * TEST_SIZE): |
| 152 | # bit pattern for a random finite positive (or +0.0) float |
| 153 | bits = random.randrange(2047*2**52) |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 154 | |
Mark Dickinson | d0ff783 | 2010-02-21 14:49:52 +0000 | [diff] [blame] | 155 | # convert bit pattern to a number of the form m * 2**e |
| 156 | e, m = divmod(bits, 2**52) |
| 157 | if e: |
| 158 | m, e = m + 2**52, e - 1 |
| 159 | e -= 1074 |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 160 | |
Mark Dickinson | d0ff783 | 2010-02-21 14:49:52 +0000 | [diff] [blame] | 161 | # add 0.5 ulps |
| 162 | m, e = 2*m + 1, e - 1 |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 163 | |
Mark Dickinson | d0ff783 | 2010-02-21 14:49:52 +0000 | [diff] [blame] | 164 | # convert to a decimal string |
| 165 | if e >= 0: |
| 166 | digits = m << e |
| 167 | exponent = 0 |
| 168 | else: |
| 169 | # m * 2**e = (m * 5**-e) * 10**e |
| 170 | digits = m * 5**-e |
| 171 | exponent = e |
| 172 | s = '{}e{}'.format(digits, exponent) |
| 173 | self.check_strtod(s) |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 174 | |
| 175 | def test_boundaries(self): |
| 176 | # boundaries expressed as triples (n, e, u), where |
| 177 | # n*10**e is an approximation to the boundary value and |
| 178 | # u*10**e is 1ulp |
| 179 | boundaries = [ |
| 180 | (10000000000000000000, -19, 1110), # a power of 2 boundary (1.0) |
| 181 | (17976931348623159077, 289, 1995), # overflow boundary (2.**1024) |
| 182 | (22250738585072013831, -327, 4941), # normal/subnormal (2.**-1022) |
| 183 | (0, -327, 4941), # zero |
| 184 | ] |
| 185 | for n, e, u in boundaries: |
| 186 | for j in range(1000): |
Mark Dickinson | d0ff783 | 2010-02-21 14:49:52 +0000 | [diff] [blame] | 187 | digits = n + random.randrange(-3*u, 3*u) |
| 188 | exponent = e |
| 189 | s = '{}e{}'.format(digits, exponent) |
| 190 | self.check_strtod(s) |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 191 | n *= 10 |
| 192 | u *= 10 |
| 193 | e -= 1 |
| 194 | |
| 195 | def test_underflow_boundary(self): |
| 196 | # test values close to 2**-1075, the underflow boundary; similar |
| 197 | # to boundary_tests, except that the random error doesn't scale |
| 198 | # with n |
| 199 | for exponent in range(-400, -320): |
| 200 | base = 10**-exponent // 2**1075 |
| 201 | for j in range(TEST_SIZE): |
| 202 | digits = base + random.randrange(-1000, 1000) |
| 203 | s = '{}e{}'.format(digits, exponent) |
| 204 | self.check_strtod(s) |
| 205 | |
| 206 | def test_bigcomp(self): |
Mark Dickinson | add2823 | 2010-01-21 19:51:08 +0000 | [diff] [blame] | 207 | for ndigs in 5, 10, 14, 15, 16, 17, 18, 19, 20, 40, 41, 50: |
| 208 | dig10 = 10**ndigs |
Mark Dickinson | d0ff783 | 2010-02-21 14:49:52 +0000 | [diff] [blame] | 209 | for i in range(10 * TEST_SIZE): |
Mark Dickinson | add2823 | 2010-01-21 19:51:08 +0000 | [diff] [blame] | 210 | digits = random.randrange(dig10) |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 211 | exponent = random.randrange(-400, 400) |
| 212 | s = '{}e{}'.format(digits, exponent) |
| 213 | self.check_strtod(s) |
| 214 | |
| 215 | def test_parsing(self): |
Mark Dickinson | 45b6365 | 2010-01-16 18:10:25 +0000 | [diff] [blame] | 216 | # make '0' more likely to be chosen than other digits |
| 217 | digits = '000000123456789' |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 218 | signs = ('+', '-', '') |
| 219 | |
| 220 | # put together random short valid strings |
| 221 | # \d*[.\d*]?e |
| 222 | for i in range(1000): |
| 223 | for j in range(TEST_SIZE): |
| 224 | s = random.choice(signs) |
| 225 | intpart_len = random.randrange(5) |
| 226 | s += ''.join(random.choice(digits) for _ in range(intpart_len)) |
| 227 | if random.choice([True, False]): |
| 228 | s += '.' |
| 229 | fracpart_len = random.randrange(5) |
| 230 | s += ''.join(random.choice(digits) |
| 231 | for _ in range(fracpart_len)) |
| 232 | else: |
| 233 | fracpart_len = 0 |
| 234 | if random.choice([True, False]): |
| 235 | s += random.choice(['e', 'E']) |
| 236 | s += random.choice(signs) |
| 237 | exponent_len = random.randrange(1, 4) |
| 238 | s += ''.join(random.choice(digits) |
| 239 | for _ in range(exponent_len)) |
| 240 | |
| 241 | if intpart_len + fracpart_len: |
| 242 | self.check_strtod(s) |
| 243 | else: |
| 244 | try: |
| 245 | float(s) |
| 246 | except ValueError: |
| 247 | pass |
| 248 | else: |
| 249 | assert False, "expected ValueError" |
| 250 | |
| 251 | def test_particular(self): |
| 252 | # inputs that produced crashes or incorrectly rounded results with |
| 253 | # previous versions of dtoa.c, for various reasons |
| 254 | test_strings = [ |
| 255 | # issue 7632 bug 1, originally reported failing case |
| 256 | '2183167012312112312312.23538020374420446192e-370', |
| 257 | # 5 instances of issue 7632 bug 2 |
| 258 | '12579816049008305546974391768996369464963024663104e-357', |
| 259 | '17489628565202117263145367596028389348922981857013e-357', |
| 260 | '18487398785991994634182916638542680759613590482273e-357', |
| 261 | '32002864200581033134358724675198044527469366773928e-358', |
| 262 | '94393431193180696942841837085033647913224148539854e-358', |
Mark Dickinson | 6ded1d5 | 2010-06-20 20:01:04 +0000 | [diff] [blame] | 263 | '73608278998966969345824653500136787876436005957953e-358', |
| 264 | '64774478836417299491718435234611299336288082136054e-358', |
| 265 | '13704940134126574534878641876947980878824688451169e-357', |
| 266 | '46697445774047060960624497964425416610480524760471e-358', |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 267 | # failing case for bug introduced by METD in r77451 (attempted |
| 268 | # fix for issue 7632, bug 2), and fixed in r77482. |
| 269 | '28639097178261763178489759107321392745108491825303e-311', |
| 270 | # two numbers demonstrating a flaw in the bigcomp 'dig == 0' |
| 271 | # correction block (issue 7632, bug 3) |
| 272 | '1.00000000000000001e44', |
| 273 | '1.0000000000000000100000000000000000000001e44', |
| 274 | # dtoa.c bug for numbers just smaller than a power of 2 (issue |
| 275 | # 7632, bug 4) |
| 276 | '99999999999999994487665465554760717039532578546e-47', |
| 277 | # failing case for off-by-one error introduced by METD in |
| 278 | # r77483 (dtoa.c cleanup), fixed in r77490 |
| 279 | '965437176333654931799035513671997118345570045914469' #... |
| 280 | '6213413350821416312194420007991306908470147322020121018368e0', |
| 281 | # incorrect lsb detection for round-half-to-even when |
| 282 | # bc->scale != 0 (issue 7632, bug 6). |
| 283 | '104308485241983990666713401708072175773165034278685' #... |
| 284 | '682646111762292409330928739751702404658197872319129' #... |
| 285 | '036519947435319418387839758990478549477777586673075' #... |
| 286 | '945844895981012024387992135617064532141489278815239' #... |
| 287 | '849108105951619997829153633535314849999674266169258' #... |
| 288 | '928940692239684771590065027025835804863585454872499' #... |
| 289 | '320500023126142553932654370362024104462255244034053' #... |
| 290 | '203998964360882487378334860197725139151265590832887' #... |
| 291 | '433736189468858614521708567646743455601905935595381' #... |
| 292 | '852723723645799866672558576993978025033590728687206' #... |
| 293 | '296379801363024094048327273913079612469982585674824' #... |
| 294 | '156000783167963081616214710691759864332339239688734' #... |
| 295 | '656548790656486646106983450809073750535624894296242' #... |
| 296 | '072010195710276073042036425579852459556183541199012' #... |
| 297 | '652571123898996574563824424330960027873516082763671875e-1075', |
| 298 | # demonstration that original fix for issue 7632 bug 1 was |
| 299 | # buggy; the exit condition was too strong |
| 300 | '247032822920623295e-341', |
Mark Dickinson | add2823 | 2010-01-21 19:51:08 +0000 | [diff] [blame] | 301 | # demonstrate similar problem to issue 7632 bug1: crash |
| 302 | # with 'oversized quotient in quorem' message. |
| 303 | '99037485700245683102805043437346965248029601286431e-373', |
| 304 | '99617639833743863161109961162881027406769510558457e-373', |
| 305 | '98852915025769345295749278351563179840130565591462e-372', |
| 306 | '99059944827693569659153042769690930905148015876788e-373', |
| 307 | '98914979205069368270421829889078356254059760327101e-372', |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 308 | # issue 7632 bug 5: the following 2 strings convert differently |
| 309 | '1000000000000000000000000000000000000000e-16', |
Mark Dickinson | 45b6365 | 2010-01-16 18:10:25 +0000 | [diff] [blame] | 310 | '10000000000000000000000000000000000000000e-17', |
Mark Dickinson | add2823 | 2010-01-21 19:51:08 +0000 | [diff] [blame] | 311 | # issue 7632 bug 7 |
| 312 | '991633793189150720000000000000000000000000000000000000000e-33', |
| 313 | # And another, similar, failing halfway case |
| 314 | '4106250198039490000000000000000000000000000000000000000e-38', |
Mark Dickinson | 45b6365 | 2010-01-16 18:10:25 +0000 | [diff] [blame] | 315 | # issue 7632 bug 8: the following produced 10.0 |
| 316 | '10.900000000000000012345678912345678912345', |
Benjamin Peterson | 5e55b3e | 2010-02-03 02:35:45 +0000 | [diff] [blame] | 317 | |
| 318 | # two humongous values from issue 7743 |
| 319 | '116512874940594195638617907092569881519034793229385' #... |
| 320 | '228569165191541890846564669771714896916084883987920' #... |
| 321 | '473321268100296857636200926065340769682863349205363' #... |
| 322 | '349247637660671783209907949273683040397979984107806' #... |
| 323 | '461822693332712828397617946036239581632976585100633' #... |
| 324 | '520260770761060725403904123144384571612073732754774' #... |
| 325 | '588211944406465572591022081973828448927338602556287' #... |
| 326 | '851831745419397433012491884869454462440536895047499' #... |
| 327 | '436551974649731917170099387762871020403582994193439' #... |
| 328 | '761933412166821484015883631622539314203799034497982' #... |
| 329 | '130038741741727907429575673302461380386596501187482' #... |
| 330 | '006257527709842179336488381672818798450229339123527' #... |
| 331 | '858844448336815912020452294624916993546388956561522' #... |
| 332 | '161875352572590420823607478788399460162228308693742' #... |
| 333 | '05287663441403533948204085390898399055004119873046875e-1075', |
| 334 | |
| 335 | '525440653352955266109661060358202819561258984964913' #... |
| 336 | '892256527849758956045218257059713765874251436193619' #... |
| 337 | '443248205998870001633865657517447355992225852945912' #... |
| 338 | '016668660000210283807209850662224417504752264995360' #... |
| 339 | '631512007753855801075373057632157738752800840302596' #... |
| 340 | '237050247910530538250008682272783660778181628040733' #... |
| 341 | '653121492436408812668023478001208529190359254322340' #... |
| 342 | '397575185248844788515410722958784640926528544043090' #... |
| 343 | '115352513640884988017342469275006999104519620946430' #... |
| 344 | '818767147966495485406577703972687838176778993472989' #... |
| 345 | '561959000047036638938396333146685137903018376496408' #... |
| 346 | '319705333868476925297317136513970189073693314710318' #... |
| 347 | '991252811050501448326875232850600451776091303043715' #... |
| 348 | '157191292827614046876950225714743118291034780466325' #... |
| 349 | '085141343734564915193426994587206432697337118211527' #... |
| 350 | '278968731294639353354774788602467795167875117481660' #... |
| 351 | '4738791256853675690543663283782215866825e-1180', |
| 352 | |
Mark Dickinson | add2823 | 2010-01-21 19:51:08 +0000 | [diff] [blame] | 353 | # exercise exit conditions in bigcomp comparison loop |
| 354 | '2602129298404963083833853479113577253105939995688e2', |
| 355 | '260212929840496308383385347911357725310593999568896e0', |
| 356 | '26021292984049630838338534791135772531059399956889601e-2', |
| 357 | '260212929840496308383385347911357725310593999568895e0', |
| 358 | '260212929840496308383385347911357725310593999568897e0', |
| 359 | '260212929840496308383385347911357725310593999568996e0', |
| 360 | '260212929840496308383385347911357725310593999568866e0', |
| 361 | # 2**53 |
| 362 | '9007199254740992.00', |
| 363 | # 2**1024 - 2**970: exact overflow boundary. All values |
| 364 | # smaller than this should round to something finite; any value |
| 365 | # greater than or equal to this one overflows. |
| 366 | '179769313486231580793728971405303415079934132710037' #... |
| 367 | '826936173778980444968292764750946649017977587207096' #... |
| 368 | '330286416692887910946555547851940402630657488671505' #... |
| 369 | '820681908902000708383676273854845817711531764475730' #... |
| 370 | '270069855571366959622842914819860834936475292719074' #... |
| 371 | '168444365510704342711559699508093042880177904174497792', |
| 372 | # 2**1024 - 2**970 - tiny |
| 373 | '179769313486231580793728971405303415079934132710037' #... |
| 374 | '826936173778980444968292764750946649017977587207096' #... |
| 375 | '330286416692887910946555547851940402630657488671505' #... |
| 376 | '820681908902000708383676273854845817711531764475730' #... |
| 377 | '270069855571366959622842914819860834936475292719074' #... |
| 378 | '168444365510704342711559699508093042880177904174497791.999', |
| 379 | # 2**1024 - 2**970 + tiny |
| 380 | '179769313486231580793728971405303415079934132710037' #... |
| 381 | '826936173778980444968292764750946649017977587207096' #... |
| 382 | '330286416692887910946555547851940402630657488671505' #... |
| 383 | '820681908902000708383676273854845817711531764475730' #... |
| 384 | '270069855571366959622842914819860834936475292719074' #... |
| 385 | '168444365510704342711559699508093042880177904174497792.001', |
| 386 | # 1 - 2**-54, +-tiny |
| 387 | '999999999999999944488848768742172978818416595458984375e-54', |
| 388 | '9999999999999999444888487687421729788184165954589843749999999e-54', |
| 389 | '9999999999999999444888487687421729788184165954589843750000001e-54', |
Mark Dickinson | 853c3bb | 2010-01-14 15:37:49 +0000 | [diff] [blame] | 390 | ] |
| 391 | for s in test_strings: |
| 392 | self.check_strtod(s) |
| 393 | |
| 394 | def test_main(): |
| 395 | test.support.run_unittest(StrtodTests) |
| 396 | |
| 397 | if __name__ == "__main__": |
| 398 | test_main() |