tests/test-strtod.c

   1 /*
   2  * Copyright (C) 2008 Free Software Foundation
   3  * Written by Eric Blake
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include <config.h>
  19
  20 #include <stdlib.h>
  21
  22 #include <errno.h>
  23 #include <float.h>
  24 #include <math.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27
  28 #define ASSERT(expr) \
  29   do                                                                         \
  30     {                                                                        \
  31       if (!(expr))                                                           \
  32         {                                                                    \
  33           fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
  34           /* FIXME abort ();*/status = 1;                               \
  35         }                                                                    \
  36     }                                                                        \
  37   while (0)
  38
  39 int
  40 main ()
  41 {
  42   int status = 0;
  43   /* Subject sequence empty or invalid.  */
  44   {
  45     errno = 0;
  46     const char input[] = "";
  47     char *ptr;
  48     double result = strtod (input, &ptr);
  49     ASSERT (result == 0.0);
  50     ASSERT (!signbit (result));
  51     ASSERT (ptr == input);
  52     ASSERT (errno == 0 || errno == EINVAL);
  53   }
  54   {
  55     errno = 0;
  56     const char input[] = " ";
  57     char *ptr;
  58     double result = strtod (input, &ptr);
  59     ASSERT (result == 0.0);
  60     ASSERT (!signbit (result));
  61     ASSERT (ptr == input);
  62     ASSERT (errno == 0 || errno == EINVAL);
  63   }
  64   {
  65     errno = 0;
  66     const char input[] = " +";
  67     char *ptr;
  68     double result = strtod (input, &ptr);
  69     ASSERT (result == 0.0);
  70     ASSERT (!signbit (result));
  71     ASSERT (ptr == input);
  72     ASSERT (errno == 0 || errno == EINVAL);
  73   }
  74   {
  75     errno = 0;
  76     const char input[] = " .";
  77     char *ptr;
  78     double result = strtod (input, &ptr);
  79     ASSERT (result == 0.0);
  80     ASSERT (!signbit (result));
  81     ASSERT (ptr == input);
  82     ASSERT (errno == 0 || errno == EINVAL);
  83   }
  84   {
  85     errno = 0;
  86     const char input[] = " .e0";
  87     char *ptr;
  88     double result = strtod (input, &ptr);
  89     ASSERT (result == 0.0);
  90     ASSERT (!signbit (result));
  91     ASSERT (ptr == input);
  92     ASSERT (errno == 0 || errno == EINVAL);
  93   }
  94   {
  95     errno = 0;
  96     const char input[] = " +.e-0";
  97     char *ptr;
  98     double result = strtod (input, &ptr);
  99     ASSERT (result == 0.0);
 100     ASSERT (!signbit (result));
 101     ASSERT (ptr == input);
 102     ASSERT (errno == 0 || errno == EINVAL);
 103   }
 104   {
 105     errno = 0;
 106     const char input[] = " in";
 107     char *ptr;
 108     double result = strtod (input, &ptr);
 109     ASSERT (result == 0.0);
 110     ASSERT (!signbit (result));
 111     ASSERT (ptr == input);
 112     ASSERT (errno == 0 || errno == EINVAL);
 113   }
 114   {
 115     errno = 0;
 116     const char input[] = " na";
 117     char *ptr;
 118     double result = strtod (input, &ptr);
 119     ASSERT (result == 0.0);
 120     ASSERT (!signbit (result));
 121     ASSERT (ptr == input);
 122     ASSERT (errno == 0 || errno == EINVAL);
 123   }
 124
 125   /* Simple floating point values.  */
 126   {
 127     errno = 0;
 128     const char input[] = "1";
 129     char *ptr;
 130     double result = strtod (input, &ptr);
 131     ASSERT (result == 1.0);
 132     ASSERT (ptr == input + 1);
 133     ASSERT (errno == 0);
 134   }
 135   {
 136     errno = 0;
 137     const char input[] = "1.";
 138     char *ptr;
 139     double result = strtod (input, &ptr);
 140     ASSERT (result == 1.0);
 141     ASSERT (ptr == input + 2);
 142     ASSERT (errno == 0);
 143   }
 144   {
 145     errno = 0;
 146     const char input[] = ".1";
 147     char *ptr;
 148     double result = strtod (input, &ptr);
 149     ASSERT (result == 0.1);
 150     ASSERT (ptr == input + 2);
 151     ASSERT (errno == 0);
 152   }
 153   {
 154     errno = 0;
 155     const char input[] = " 1";
 156     char *ptr;
 157     double result = strtod (input, &ptr);
 158     ASSERT (result == 1.0);
 159     ASSERT (ptr == input + 2);
 160     ASSERT (errno == 0);
 161   }
 162   {
 163     errno = 0;
 164     const char input[] = "+1";
 165     char *ptr;
 166     double result = strtod (input, &ptr);
 167     ASSERT (result == 1.0);
 168     ASSERT (ptr == input + 2);
 169     ASSERT (errno == 0);
 170   }
 171   {
 172     errno = 0;
 173     const char input[] = "-1";
 174     char *ptr;
 175     double result = strtod (input, &ptr);
 176     ASSERT (result == -1.0);
 177     ASSERT (ptr == input + 2);
 178     ASSERT (errno == 0);
 179   }
 180   {
 181     errno = 0;
 182     const char input[] = "1e0";
 183     char *ptr;
 184     double result = strtod (input, &ptr);
 185     ASSERT (result == 1.0);
 186     ASSERT (ptr == input + 3);
 187     ASSERT (errno == 0);
 188   }
 189   {
 190     errno = 0;
 191     const char input[] = "1e+0";
 192     char *ptr;
 193     double result = strtod (input, &ptr);
 194     ASSERT (result == 1.0);
 195     ASSERT (ptr == input + 4);
 196     ASSERT (errno == 0);
 197   }
 198   {
 199     errno = 0;
 200     const char input[] = "1e-0";
 201     char *ptr;
 202     double result = strtod (input, &ptr);
 203     ASSERT (result == 1.0);
 204     ASSERT (ptr == input + 4);
 205     ASSERT (errno == 0);
 206   }
 207   {
 208     errno = 0;
 209     const char input[] = "1e1";
 210     char *ptr;
 211     double result = strtod (input, &ptr);
 212     ASSERT (result == 10.0);
 213     ASSERT (ptr == input + 3);
 214     ASSERT (errno == 0);
 215   }
 216   {
 217     errno = 0;
 218     const char input[] = "1e-1";
 219     char *ptr;
 220     double result = strtod (input, &ptr);
 221     ASSERT (result == 0.1);
 222     ASSERT (ptr == input + 4);
 223     ASSERT (errno == 0);
 224   }
 225
 226   /* Zero.  */
 227   {
 228     errno = 0;
 229     const char input[] = "0";
 230     char *ptr;
 231     double result = strtod (input, &ptr);
 232     ASSERT (result == 0.0);
 233     ASSERT (!signbit (result));
 234     ASSERT (ptr == input + 1);
 235     ASSERT (errno == 0);
 236   }
 237   {
 238     errno = 0;
 239     const char input[] = ".0";
 240     char *ptr;
 241     double result = strtod (input, &ptr);
 242     ASSERT (result == 0.0);
 243     ASSERT (!signbit (result));
 244     ASSERT (ptr == input + 2);
 245     ASSERT (errno == 0);
 246   }
 247   {
 248     errno = 0;
 249     const char input[] = "0e0";
 250     char *ptr;
 251     double result = strtod (input, &ptr);
 252     ASSERT (result == 0.0);
 253     ASSERT (!signbit (result));
 254     ASSERT (ptr == input + 3);
 255     ASSERT (errno == 0);
 256   }
 257   {
 258     errno = 0;
 259     const char input[] = "0e+9999999";
 260     char *ptr;
 261     double result = strtod (input, &ptr);
 262     ASSERT (result == 0.0);
 263     ASSERT (!signbit (result));
 264     ASSERT (ptr == input + 10);
 265     ASSERT (errno == 0);
 266   }
 267   {
 268     errno = 0;
 269     const char input[] = "0e-9999999";
 270     char *ptr;
 271     double result = strtod (input, &ptr);
 272     ASSERT (result == 0.0);
 273     ASSERT (!signbit (result));
 274     ASSERT (ptr == input + 10);
 275     ASSERT (errno == 0);
 276   }
 277   {
 278     errno = 0;
 279     const char input[] = "-0";
 280     char *ptr;
 281     double result = strtod (input, &ptr);
 282     ASSERT (result == 0.0);
 283     ASSERT (signbit (result) == signbit (-0.0));
 284     ASSERT (ptr == input + 2);
 285     ASSERT (errno == 0);
 286   }
 287
 288   /* Suffixes.  */
 289   {
 290     errno = 0;
 291     const char input[] = "1f";
 292     char *ptr;
 293     double result = strtod (input, &ptr);
 294     ASSERT (result == 1.0);
 295     ASSERT (ptr == input + 1);
 296     ASSERT (errno == 0);
 297   }
 298   {
 299     errno = 0;
 300     const char input[] = "1.f";
 301     char *ptr;
 302     double result = strtod (input, &ptr);
 303     ASSERT (result == 1.0);
 304     ASSERT (ptr == input + 2);
 305     ASSERT (errno == 0);
 306   }
 307   {
 308     errno = 0;
 309     const char input[] = "1e";
 310     char *ptr;
 311     double result = strtod (input, &ptr);
 312     ASSERT (result == 1.0);
 313     ASSERT (ptr == input + 1);
 314     ASSERT (errno == 0);
 315   }
 316   {
 317     errno = 0;
 318     const char input[] = "1e+";
 319     char *ptr;
 320     double result = strtod (input, &ptr);
 321     ASSERT (result == 1.0);
 322     ASSERT (ptr == input + 1);
 323     ASSERT (errno == 0);
 324   }
 325   {
 326     errno = 0;
 327     const char input[] = "1e-";
 328     char *ptr;
 329     double result = strtod (input, &ptr);
 330     ASSERT (result == 1.0);
 331     ASSERT (ptr == input + 1);
 332     ASSERT (errno == 0);
 333   }
 334   {
 335     errno = 0;
 336     const char input[] = "1E 2";
 337     char *ptr;
 338     double result = strtod (input, &ptr);
 339     ASSERT (result == 1.0);
 340     ASSERT (ptr == input + 1);
 341     ASSERT (errno == 0);
 342   }
 343   {
 344     errno = 0;
 345     const char input[] = "0x";
 346     char *ptr;
 347     double result = strtod (input, &ptr);
 348     ASSERT (result == 0.0);
 349     ASSERT (!signbit (result));
 350     ASSERT (ptr == input + 1);
 351     ASSERT (errno == 0);
 352   }
 353   {
 354     errno = 0;
 355     const char input[] = "00x1";
 356     char *ptr;
 357     double result = strtod (input, &ptr);
 358     ASSERT (result == 0.0);
 359     ASSERT (!signbit (result));
 360     ASSERT (ptr == input + 2);
 361     ASSERT (errno == 0);
 362   }
 363   {
 364     errno = 0;
 365     const char input[] = "-0x";
 366     char *ptr;
 367     double result = strtod (input, &ptr);
 368     ASSERT (result == 0.0);
 369     ASSERT (signbit (result) == signbit (-0.0));
 370     ASSERT (ptr == input + 2);
 371     ASSERT (errno == 0);
 372   }
 373   {
 374     errno = 0;
 375     const char input[] = "0xg";
 376     char *ptr;
 377     double result = strtod (input, &ptr);
 378     ASSERT (result == 0.0);
 379     ASSERT (!signbit (result));
 380     ASSERT (ptr == input + 1);
 381     ASSERT (errno == 0);
 382   }
 383   {
 384     errno = 0;
 385     const char input[] = "0xp";
 386     char *ptr;
 387     double result = strtod (input, &ptr);
 388     ASSERT (result == 0.0);
 389     ASSERT (!signbit (result));
 390     ASSERT (ptr == input + 1);
 391     ASSERT (errno == 0);
 392   }
 393   {
 394     errno = 0;
 395     const char input[] = "0x.";
 396     char *ptr;
 397     double result = strtod (input, &ptr);
 398     ASSERT (result == 0.0);
 399     ASSERT (!signbit (result));
 400     ASSERT (ptr == input + 1);
 401     ASSERT (errno == 0);
 402   }
 403   {
 404     errno = 0;
 405     const char input[] = "0xp+";
 406     char *ptr;
 407     double result = strtod (input, &ptr);
 408     ASSERT (result == 0.0);
 409     ASSERT (!signbit (result));
 410     ASSERT (ptr == input + 1);
 411     ASSERT (errno == 0);
 412   }
 413   {
 414     errno = 0;
 415     const char input[] = "0xp+1";
 416     char *ptr;
 417     double result = strtod (input, &ptr);
 418     ASSERT (result == 0.0);
 419     ASSERT (!signbit (result));
 420     ASSERT (ptr == input + 1);
 421     ASSERT (errno == 0);
 422   }
 423   {
 424     errno = 0;
 425     const char input[] = "0x.p+1";
 426     char *ptr;
 427     double result = strtod (input, &ptr);
 428     ASSERT (result == 0.0);
 429     ASSERT (!signbit (result));
 430     ASSERT (ptr == input + 1);
 431     ASSERT (errno == 0);
 432   }
 433   {
 434     errno = 0;
 435     const char input[] = "1p+1";
 436     char *ptr;
 437     double result = strtod (input, &ptr);
 438     ASSERT (result == 1.0);
 439     ASSERT (ptr == input + 1);
 440     ASSERT (errno == 0);
 441   }
 442
 443   /* Overflow/underflow.  */
 444   {
 445     errno = 0;
 446     const char input[] = "1E100000";
 447     char *ptr;
 448     double result = strtod (input, &ptr);
 449     ASSERT (result == HUGE_VAL);
 450     ASSERT (ptr == input + 8);
 451     ASSERT (errno == ERANGE);
 452   }
 453   {
 454     errno = 0;
 455     const char input[] = "-1E100000";
 456     char *ptr;
 457     double result = strtod (input, &ptr);
 458     ASSERT (result == -HUGE_VAL);
 459     ASSERT (ptr == input + 9);
 460     ASSERT (errno == ERANGE);
 461   }
 462   {
 463     errno = 0;
 464     const char input[] = "1E-100000";
 465     char *ptr;
 466     double result = strtod (input, &ptr);
 467     ASSERT (0.0 <= result && result <= FLT_MIN);
 468     ASSERT (!signbit (result));
 469     ASSERT (ptr == input + 9);
 470     ASSERT (errno == ERANGE);
 471   }
 472   {
 473     errno = 0;
 474     const char input[] = "-1E-100000";
 475     char *ptr;
 476     double result = strtod (input, &ptr);
 477     ASSERT (-FLT_MIN <= result && result <= 0.0);
 478     ASSERT (signbit (result) == signbit (-0.0));
 479     ASSERT (ptr == input + 10);
 480     ASSERT (errno == ERANGE);
 481   }
 482
 483   /* Infinity.  */
 484   {
 485     errno = 0;
 486     const char input[] = "iNf";
 487     char *ptr;
 488     double result = strtod (input, &ptr);
 489     ASSERT (result == HUGE_VAL);
 490     ASSERT (ptr == input + 3);
 491     ASSERT (errno == 0);
 492   }
 493   {
 494     errno = 0;
 495     const char input[] = "-InF";
 496     char *ptr;
 497     double result = strtod (input, &ptr);
 498     ASSERT (result == -HUGE_VAL);
 499     ASSERT (ptr == input + 4);
 500     ASSERT (errno == 0);
 501   }
 502   {
 503     errno = 0;
 504     const char input[] = "infinite";
 505     char *ptr;
 506     double result = strtod (input, &ptr);
 507     ASSERT (result == HUGE_VAL);
 508     ASSERT (ptr == input + 3);
 509     ASSERT (errno == 0);
 510   }
 511   {
 512     errno = 0;
 513     const char input[] = "infinitY";
 514     char *ptr;
 515     double result = strtod (input, &ptr);
 516     ASSERT (result == HUGE_VAL);
 517     ASSERT (ptr == input + 8);
 518     ASSERT (errno == 0);
 519   }
 520   {
 521     errno = 0;
 522     const char input[] = "infinitY.";
 523     char *ptr;
 524     double result = strtod (input, &ptr);
 525     ASSERT (result == HUGE_VAL);
 526     ASSERT (ptr == input + 8);
 527     ASSERT (errno == 0);
 528   }
 529
 530   /* NaN.  Some processors set the sign bit of the default NaN, so all
 531      we check is that using a sign changes the result.  */
 532   {
 533     errno = 0;
 534     const char input[] = "-nan";
 535     char *ptr1;
 536     char *ptr2;
 537     double result1 = strtod (input, &ptr1);
 538     double result2 = strtod (input + 1, &ptr2);
 539 #ifdef NAN
 540     ASSERT (isnan (result1));
 541     ASSERT (isnan (result2));
 542     ASSERT (signbit (result1) != signbit (result2));
 543     ASSERT (ptr1 == input + 4);
 544     ASSERT (ptr2 == input + 4);
 545     ASSERT (errno == 0);
 546 #else
 547     ASSERT (result1 == 0.0);
 548     ASSERT (result2 == 0.0);
 549     ASSERT (!signbit (result1));
 550     ASSERT (!signbit (result2));
 551     ASSERT (ptr1 == input);
 552     ASSERT (ptr2 == input + 1);
 553     ASSERT (errno == 0 || errno == EINVAL);
 554 #endif
 555   }
 556   {
 557     errno = 0;
 558     const char input[] = "+nan(";
 559     char *ptr1;
 560     char *ptr2;
 561     double result1 = strtod (input, &ptr1);
 562     double result2 = strtod (input + 1, &ptr2);
 563 #ifdef NAN
 564     ASSERT (isnan (result1));
 565     ASSERT (isnan (result2));
 566     ASSERT (signbit (result1) == signbit (result2));
 567     ASSERT (ptr1 == input + 4);
 568     ASSERT (ptr2 == input + 4);
 569     ASSERT (errno == 0);
 570 #else
 571     ASSERT (result1 == 0.0);
 572     ASSERT (result2 == 0.0);
 573     ASSERT (!signbit (result1));
 574     ASSERT (!signbit (result2));
 575     ASSERT (ptr1 == input);
 576     ASSERT (ptr2 == input + 1);
 577     ASSERT (errno == 0 || errno == EINVAL);
 578 #endif
 579   }
 580   {
 581     errno = 0;
 582     const char input[] = "-nan()";
 583     char *ptr1;
 584     char *ptr2;
 585     double result1 = strtod (input, &ptr1);
 586     double result2 = strtod (input + 1, &ptr2);
 587 #ifdef NAN
 588     ASSERT (isnan (result1));
 589     ASSERT (isnan (result2));
 590     ASSERT (signbit (result1) != signbit (result2));
 591     ASSERT (ptr1 == input + 6);
 592     ASSERT (ptr2 == input + 6);
 593     ASSERT (errno == 0);
 594 #else
 595     ASSERT (result1 == 0.0);
 596     ASSERT (result2 == 0.0);
 597     ASSERT (!signbit (result1));
 598     ASSERT (!signbit (result2));
 599     ASSERT (ptr1 == input);
 600     ASSERT (ptr2 == input + 1);
 601     ASSERT (errno == 0 || errno == EINVAL);
 602 #endif
 603   }
 604   {
 605     errno = 0;
 606     const char input[] = " nan().";
 607     char *ptr;
 608     double result = strtod (input, &ptr);
 609 #ifdef NAN
 610     ASSERT (isnan (result));
 611     ASSERT (ptr == input + 6);
 612     ASSERT (errno == 0);
 613 #else
 614     ASSERT (result == 0.0);
 615     ASSERT (!signbit (result));
 616     ASSERT (ptr == input);
 617     ASSERT (errno == 0 || errno == EINVAL);
 618 #endif
 619   }
 620   {
 621     errno = 0;
 622     /* The behavior of nan(0) is implementation-defined, but all
 623        implementations we know of which handle optional
 624        n-char-sequences handle nan(0) the same as nan().  */
 625     const char input[] = "-nan(0).";
 626     char *ptr1;
 627     char *ptr2;
 628     double result1 = strtod (input, &ptr1);
 629     double result2 = strtod (input + 1, &ptr2);
 630 #ifdef NAN
 631     ASSERT (isnan (result1));
 632     ASSERT (isnan (result2));
 633     ASSERT (signbit (result1) != signbit (result2));
 634     ASSERT (ptr1 == input + 7);
 635     ASSERT (ptr2 == input + 7);
 636     ASSERT (errno == 0);
 637 #else
 638     ASSERT (result1 == 0.0);
 639     ASSERT (result2 == 0.0);
 640     ASSERT (!signbit (result1));
 641     ASSERT (!signbit (result2));
 642     ASSERT (ptr1 == input);
 643     ASSERT (ptr2 == input + 1);
 644     ASSERT (errno == 0 || errno == EINVAL);
 645 #endif
 646   }
 647
 648   /* Hex.  */
 649   {
 650     errno = 0;
 651     const char input[] = "0xa";
 652     char *ptr;
 653     double result = strtod (input, &ptr);
 654     ASSERT (result == 10.0);
 655     ASSERT (ptr == input + 3);
 656     ASSERT (errno == 0);
 657   }
 658   {
 659     errno = 0;
 660     const char input[] = "0XA";
 661     char *ptr;
 662     double result = strtod (input, &ptr);
 663     ASSERT (result == 10.0);
 664     ASSERT (ptr == input + 3);
 665     ASSERT (errno == 0);
 666   }
 667   {
 668     errno = 0;
 669     const char input[] = "0x1p";
 670     char *ptr;
 671     double result = strtod (input, &ptr);
 672     ASSERT (result == 1.0);
 673     ASSERT (ptr == input + 3);
 674     ASSERT (errno == 0);
 675   }
 676   {
 677     errno = 0;
 678     const char input[] = "0x1p+";
 679     char *ptr;
 680     double result = strtod (input, &ptr);
 681     ASSERT (result == 1.0);
 682     ASSERT (ptr == input + 3);
 683     ASSERT (errno == 0);
 684   }
 685   {
 686     errno = 0;
 687     const char input[] = "0x1p+1";
 688     char *ptr;
 689     double result = strtod (input, &ptr);
 690     ASSERT (result == 2.0);
 691     ASSERT (ptr == input + 6);
 692     ASSERT (errno == 0);
 693   }
 694   {
 695     errno = 0;
 696     const char input[] = "0x1p+1a";
 697     char *ptr;
 698     double result = strtod (input, &ptr);
 699     ASSERT (result == 2.0);
 700     ASSERT (ptr == input + 6);
 701     ASSERT (errno == 0);
 702   }
 703
 704   /* Large buffers.  */
 705   {
 706     errno = 0;
 707     size_t m = 1000000;
 708     char *input = malloc (m + 1);
 709     if (input)
 710       {
 711         char *ptr;
 712         double result;
 713         memset (input, '\t', m - 1);
 714         input[m - 1] = '1';
 715         input[m] = '\0';
 716         result = strtod (input, &ptr);
 717         ASSERT (result == 1.0);
 718         ASSERT (ptr == input + m);
 719         ASSERT (errno == 0);
 720       }
 721     free (input);
 722   }
 723   {
 724     errno = 0;
 725     size_t m = 1000000;
 726     char *input = malloc (m + 1);
 727     if (input)
 728       {
 729         char *ptr;
 730         double result;
 731         memset (input, '0', m - 1);
 732         input[m - 1] = '1';
 733         input[m] = '\0';
 734         result = strtod (input, &ptr);
 735         ASSERT (result == 1.0);
 736         ASSERT (ptr == input + m);
 737         ASSERT (errno == 0);
 738       }
 739     free (input);
 740   }
 741 #if 0
 742   /* Newlib has an artificial limit of 20000 for the exponent.  TODO -
 743      gnulib should fix this.  */
 744   {
 745     errno = 0;
 746     size_t m = 1000000;
 747     char *input = malloc (m + 1);
 748     if (input)
 749       {
 750         char *ptr;
 751         double result;
 752         input[0] = '.';
 753         memset (input + 1, '0', m - 10);
 754         input[m - 9] = '1';
 755         input[m - 8] = 'e';
 756         input[m - 7] = '+';
 757         input[m - 6] = '9';
 758         input[m - 5] = '9';
 759         input[m - 4] = '9';
 760         input[m - 3] = '9';
 761         input[m - 2] = '9';
 762         input[m - 1] = '1';
 763         input[m] = '\0';
 764         result = strtod (input, &ptr);
 765         ASSERT (result == 1.0);
 766         ASSERT (ptr == input + m);
 767         ASSERT (errno == 0);
 768       }
 769     free (input);
 770   }
 771   {
 772     errno = 0;
 773     size_t m = 1000000;
 774     char *input = malloc (m + 1);
 775     if (input)
 776       {
 777         char *ptr;
 778         double result;
 779         input[0] = '1';
 780         memset (input + 1, '0', m - 9);
 781         input[m - 8] = 'e';
 782         input[m - 7] = '-';
 783         input[m - 6] = '9';
 784         input[m - 5] = '9';
 785         input[m - 4] = '9';
 786         input[m - 3] = '9';
 787         input[m - 2] = '9';
 788         input[m - 1] = '1';
 789         input[m] = '\0';
 790         result = strtod (input, &ptr);
 791         ASSERT (result == 1.0);
 792         ASSERT (ptr == input + m);
 793         ASSERT (errno == 0);
 794       }
 795     free (input);
 796   }
 797 #endif
 798   {
 799     errno = 0;
 800     size_t m = 1000000;
 801     char *input = malloc (m + 1);
 802     if (input)
 803       {
 804         char *ptr;
 805         double result;
 806         input[0] = '-';
 807         input[1] = '0';
 808         input[2] = 'e';
 809         input[3] = '1';
 810         memset (input + 4, '0', m - 3);
 811         input[m] = '\0';
 812         result = strtod (input, &ptr);
 813         ASSERT (result == 0.0);
 814         ASSERT (signbit (result) == signbit (-0.0));
 815         ASSERT (ptr == input + m);
 816         ASSERT (errno == 0);
 817       }
 818     free (input);
 819   }
 820
 821   /* Rounding.  */
 822   /* TODO - is it worth some tests of rounding for typical IEEE corner
 823      cases, such as .5 ULP rounding up to the smallest denormal and
 824      not causing underflow, or FLT_MIN - .5 ULP not causing an
 825      infinite loop?  */
 826
 827   return status;
 828 }