tests/test-strtof.h

   1 /* Test of strtof() and c_strtof() in the "C" locale.
   2    Copyright (C) 2008-2025 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Eric Blake.  */
  18
  19 static void
  20 test_function (float (*my_strtof) (const char *, char **))
  21 {
  22   /* Subject sequence empty or invalid.  */
  23   {
  24     const char input[] = "";
  25     char *ptr;
  26     float result;
  27     errno = 0;
  28     result = my_strtof (input, &ptr);
  29     ASSERT (result == 0.0f);
  30     ASSERT (!signbit (result));
  31     ASSERT (ptr == input);
  32     ASSERT (errno == 0 || errno == EINVAL);
  33   }
  34   {
  35     const char input[] = " ";
  36     char *ptr;
  37     float result;
  38     errno = 0;
  39     result = my_strtof (input, &ptr);
  40     ASSERT (result == 0.0f);
  41     ASSERT (!signbit (result));
  42     ASSERT (ptr == input);
  43     ASSERT (errno == 0 || errno == EINVAL);
  44   }
  45   {
  46     const char input[] = " +";
  47     char *ptr;
  48     float result;
  49     errno = 0;
  50     result = my_strtof (input, &ptr);
  51     ASSERT (result == 0.0f);
  52     ASSERT (!signbit (result));
  53     ASSERT (ptr == input);
  54     ASSERT (errno == 0 || errno == EINVAL);
  55   }
  56   {
  57     const char input[] = " .";
  58     char *ptr;
  59     float result;
  60     errno = 0;
  61     result = my_strtof (input, &ptr);
  62     ASSERT (result == 0.0f);
  63     ASSERT (!signbit (result));
  64     ASSERT (ptr == input);
  65     ASSERT (errno == 0 || errno == EINVAL);
  66   }
  67   {
  68     const char input[] = " .e0";
  69     char *ptr;
  70     float result;
  71     errno = 0;
  72     result = my_strtof (input, &ptr);
  73     ASSERT (result == 0.0f);
  74     ASSERT (!signbit (result));
  75     ASSERT (ptr == input);              /* IRIX 6.5, OSF/1 5.1 */
  76     ASSERT (errno == 0 || errno == EINVAL);
  77   }
  78   {
  79     const char input[] = " +.e-0";
  80     char *ptr;
  81     float result;
  82     errno = 0;
  83     result = my_strtof (input, &ptr);
  84     ASSERT (result == 0.0f);
  85     ASSERT (!signbit (result));
  86     ASSERT (ptr == input);              /* IRIX 6.5, OSF/1 5.1 */
  87     ASSERT (errno == 0 || errno == EINVAL);
  88   }
  89   {
  90     const char input[] = " in";
  91     char *ptr;
  92     float result;
  93     errno = 0;
  94     result = my_strtof (input, &ptr);
  95     ASSERT (result == 0.0f);
  96     ASSERT (!signbit (result));
  97     ASSERT (ptr == input);
  98     ASSERT (errno == 0 || errno == EINVAL);
  99   }
 100   {
 101     const char input[] = " na";
 102     char *ptr;
 103     float result;
 104     errno = 0;
 105     result = my_strtof (input, &ptr);
 106     ASSERT (result == 0.0f);
 107     ASSERT (!signbit (result));
 108     ASSERT (ptr == input);
 109     ASSERT (errno == 0 || errno == EINVAL);
 110   }
 111
 112   /* Simple floating point values.  */
 113   {
 114     const char input[] = "1";
 115     char *ptr;
 116     float result;
 117     errno = 0;
 118     result = my_strtof (input, &ptr);
 119     ASSERT (result == 1.0f);
 120     ASSERT (ptr == input + 1);
 121     ASSERT (errno == 0);
 122   }
 123   {
 124     const char input[] = "1.";
 125     char *ptr;
 126     float result;
 127     errno = 0;
 128     result = my_strtof (input, &ptr);
 129     ASSERT (result == 1.0f);
 130     ASSERT (ptr == input + 2);
 131     ASSERT (errno == 0);
 132   }
 133   {
 134     const char input[] = ".5";
 135     char *ptr;
 136     float result;
 137     errno = 0;
 138     result = my_strtof (input, &ptr);
 139     ASSERT (result == 0.5f);
 140     ASSERT (ptr == input + 2);
 141     ASSERT (errno == 0);
 142   }
 143   {
 144     const char input[] = " 1";
 145     char *ptr;
 146     float result;
 147     errno = 0;
 148     result = my_strtof (input, &ptr);
 149     ASSERT (result == 1.0f);
 150     ASSERT (ptr == input + 2);
 151     ASSERT (errno == 0);
 152   }
 153   {
 154     const char input[] = "+1";
 155     char *ptr;
 156     float result;
 157     errno = 0;
 158     result = my_strtof (input, &ptr);
 159     ASSERT (result == 1.0f);
 160     ASSERT (ptr == input + 2);
 161     ASSERT (errno == 0);
 162   }
 163   {
 164     const char input[] = "-1";
 165     char *ptr;
 166     float result;
 167     errno = 0;
 168     result = my_strtof (input, &ptr);
 169     ASSERT (result == -1.0f);
 170     ASSERT (ptr == input + 2);
 171     ASSERT (errno == 0);
 172   }
 173   {
 174     const char input[] = "1e0";
 175     char *ptr;
 176     float result;
 177     errno = 0;
 178     result = my_strtof (input, &ptr);
 179     ASSERT (result == 1.0f);
 180     ASSERT (ptr == input + 3);
 181     ASSERT (errno == 0);
 182   }
 183   {
 184     const char input[] = "1e+0";
 185     char *ptr;
 186     float result;
 187     errno = 0;
 188     result = my_strtof (input, &ptr);
 189     ASSERT (result == 1.0f);
 190     ASSERT (ptr == input + 4);
 191     ASSERT (errno == 0);
 192   }
 193   {
 194     const char input[] = "1e-0";
 195     char *ptr;
 196     float result;
 197     errno = 0;
 198     result = my_strtof (input, &ptr);
 199     ASSERT (result == 1.0f);
 200     ASSERT (ptr == input + 4);
 201     ASSERT (errno == 0);
 202   }
 203   {
 204     const char input[] = "1e1";
 205     char *ptr;
 206     float result;
 207     errno = 0;
 208     result = my_strtof (input, &ptr);
 209     ASSERT (result == 10.0f);
 210     ASSERT (ptr == input + 3);
 211     ASSERT (errno == 0);
 212   }
 213   {
 214     const char input[] = "5e-1";
 215     char *ptr;
 216     float result;
 217     errno = 0;
 218     result = my_strtof (input, &ptr);
 219     ASSERT (result == 0.5f);
 220     ASSERT (ptr == input + 4);
 221     ASSERT (errno == 0);
 222   }
 223
 224   /* Zero.  */
 225   {
 226     const char input[] = "0";
 227     char *ptr;
 228     float result;
 229     errno = 0;
 230     result = my_strtof (input, &ptr);
 231     ASSERT (result == 0.0f);
 232     ASSERT (!signbit (result));
 233     ASSERT (ptr == input + 1);
 234     ASSERT (errno == 0);
 235   }
 236   {
 237     const char input[] = ".0";
 238     char *ptr;
 239     float result;
 240     errno = 0;
 241     result = my_strtof (input, &ptr);
 242     ASSERT (result == 0.0f);
 243     ASSERT (!signbit (result));
 244     ASSERT (ptr == input + 2);
 245     ASSERT (errno == 0);
 246   }
 247   {
 248     const char input[] = "0e0";
 249     char *ptr;
 250     float result;
 251     errno = 0;
 252     result = my_strtof (input, &ptr);
 253     ASSERT (result == 0.0f);
 254     ASSERT (!signbit (result));
 255     ASSERT (ptr == input + 3);
 256     ASSERT (errno == 0);
 257   }
 258   {
 259     const char input[] = "0e+9999999";
 260     char *ptr;
 261     float result;
 262     errno = 0;
 263     result = my_strtof (input, &ptr);
 264     ASSERT (result == 0.0f);
 265     ASSERT (!signbit (result));
 266     ASSERT (ptr == input + 10);
 267     ASSERT (errno == 0);
 268   }
 269   {
 270     const char input[] = "0e-9999999";
 271     char *ptr;
 272     float result;
 273     errno = 0;
 274     result = my_strtof (input, &ptr);
 275     ASSERT (result == 0.0f);
 276     ASSERT (!signbit (result));
 277     ASSERT (ptr == input + 10);
 278     ASSERT (errno == 0);
 279   }
 280   {
 281     const char input[] = "-0";
 282     char *ptr;
 283     float result;
 284     errno = 0;
 285     result = my_strtof (input, &ptr);
 286     ASSERT (result == 0.0f);
 287     ASSERT (!!signbit (result) == !!signbit (minus_zerof)); /* IRIX 6.5, OSF/1 4.0 */
 288     ASSERT (ptr == input + 2);
 289     ASSERT (errno == 0);
 290   }
 291
 292   /* Suffixes.  */
 293   {
 294     const char input[] = "1f";
 295     char *ptr;
 296     float result;
 297     errno = 0;
 298     result = my_strtof (input, &ptr);
 299     ASSERT (result == 1.0f);
 300     ASSERT (ptr == input + 1);
 301     ASSERT (errno == 0);
 302   }
 303   {
 304     const char input[] = "1.f";
 305     char *ptr;
 306     float result;
 307     errno = 0;
 308     result = my_strtof (input, &ptr);
 309     ASSERT (result == 1.0f);
 310     ASSERT (ptr == input + 2);
 311     ASSERT (errno == 0);
 312   }
 313   {
 314     const char input[] = "1e";
 315     char *ptr;
 316     float result;
 317     errno = 0;
 318     result = my_strtof (input, &ptr);
 319     ASSERT (result == 1.0f);
 320     ASSERT (ptr == input + 1);
 321     ASSERT (errno == 0);
 322   }
 323   {
 324     const char input[] = "1e+";
 325     char *ptr;
 326     float result;
 327     errno = 0;
 328     result = my_strtof (input, &ptr);
 329     ASSERT (result == 1.0f);
 330     ASSERT (ptr == input + 1);
 331     ASSERT (errno == 0);
 332   }
 333   {
 334     const char input[] = "1e-";
 335     char *ptr;
 336     float result;
 337     errno = 0;
 338     result = my_strtof (input, &ptr);
 339     ASSERT (result == 1.0f);
 340     ASSERT (ptr == input + 1);
 341     ASSERT (errno == 0);
 342   }
 343   {
 344     const char input[] = "1E 2";
 345     char *ptr;
 346     float result;
 347     errno = 0;
 348     result = my_strtof (input, &ptr);
 349     ASSERT (result == 1.0f);            /* HP-UX 11.11, IRIX 6.5, OSF/1 4.0 */
 350     ASSERT (ptr == input + 1);          /* HP-UX 11.11, IRIX 6.5 */
 351     ASSERT (errno == 0);
 352   }
 353   {
 354     const char input[] = "0x";
 355     char *ptr;
 356     float result;
 357     errno = 0;
 358     result = my_strtof (input, &ptr);
 359     ASSERT (result == 0.0f);
 360     ASSERT (!signbit (result));
 361     ASSERT (ptr == input + 1);          /* glibc-2.3.6, Mac OS X 10.3, FreeBSD 6.2, AIX 7.1 */
 362     ASSERT (errno == 0);
 363   }
 364   {
 365     const char input[] = "00x1";
 366     char *ptr;
 367     float result;
 368     errno = 0;
 369     result = my_strtof (input, &ptr);
 370     ASSERT (result == 0.0f);
 371     ASSERT (!signbit (result));
 372     ASSERT (ptr == input + 2);
 373     ASSERT (errno == 0);
 374   }
 375   {
 376     const char input[] = "-0x";
 377     char *ptr;
 378     float result;
 379     errno = 0;
 380     result = my_strtof (input, &ptr);
 381     ASSERT (result == 0.0f);
 382     ASSERT (!!signbit (result) == !!signbit (minus_zerof)); /* Mac OS X 10.3, FreeBSD 6.2, IRIX 6.5, OSF/1 4.0 */
 383     ASSERT (ptr == input + 2);          /* glibc-2.3.6, Mac OS X 10.3, FreeBSD 6.2, AIX 7.1 */
 384     ASSERT (errno == 0);
 385   }
 386   {
 387     const char input[] = "0xg";
 388     char *ptr;
 389     float result;
 390     errno = 0;
 391     result = my_strtof (input, &ptr);
 392     ASSERT (result == 0.0f);
 393     ASSERT (!signbit (result));
 394     ASSERT (ptr == input + 1);          /* glibc-2.3.6, Mac OS X 10.3, FreeBSD 6.2, AIX 7.1 */
 395     ASSERT (errno == 0);
 396   }
 397   {
 398     const char input[] = "0xp";
 399     char *ptr;
 400     float result;
 401     errno = 0;
 402     result = my_strtof (input, &ptr);
 403     ASSERT (result == 0.0f);
 404     ASSERT (!signbit (result));
 405     ASSERT (ptr == input + 1);          /* glibc-2.3.6, Mac OS X 10.3, FreeBSD 6.2, AIX 7.1 */
 406     ASSERT (errno == 0);
 407   }
 408   {
 409     const char input[] = "0XP";
 410     char *ptr;
 411     float result;
 412     errno = 0;
 413     result = my_strtof (input, &ptr);
 414     ASSERT (result == 0.0f);
 415     ASSERT (!signbit (result));
 416     ASSERT (ptr == input + 1);          /* glibc-2.3.6, Mac OS X 10.3, FreeBSD 6.2, AIX 7.1 */
 417     ASSERT (errno == 0);
 418   }
 419   {
 420     const char input[] = "0x.";
 421     char *ptr;
 422     float result;
 423     errno = 0;
 424     result = my_strtof (input, &ptr);
 425     ASSERT (result == 0.0f);
 426     ASSERT (!signbit (result));
 427     ASSERT (ptr == input + 1);          /* glibc-2.3.6, Mac OS X 10.3, FreeBSD 6.2, AIX 7.1 */
 428     ASSERT (errno == 0);
 429   }
 430   {
 431     const char input[] = "0xp+";
 432     char *ptr;
 433     float result;
 434     errno = 0;
 435     result = my_strtof (input, &ptr);
 436     ASSERT (result == 0.0f);
 437     ASSERT (!signbit (result));
 438     ASSERT (ptr == input + 1);          /* glibc-2.3.6, Mac OS X 10.3, FreeBSD 6.2, AIX 7.1 */
 439     ASSERT (errno == 0);
 440   }
 441   {
 442     const char input[] = "0xp+1";
 443     char *ptr;
 444     float result;
 445     errno = 0;
 446     result = my_strtof (input, &ptr);
 447     ASSERT (result == 0.0f);
 448     ASSERT (!signbit (result));
 449     ASSERT (ptr == input + 1);          /* glibc-2.3.6, Mac OS X 10.3, FreeBSD 6.2, AIX 7.1 */
 450     ASSERT (errno == 0);
 451   }
 452   {
 453     const char input[] = "0x.p+1";
 454     char *ptr;
 455     float result;
 456     errno = 0;
 457     result = my_strtof (input, &ptr);
 458     ASSERT (result == 0.0f);
 459     ASSERT (!signbit (result));
 460     ASSERT (ptr == input + 1);          /* glibc-2.3.6, Mac OS X 10.3, FreeBSD 6.2, AIX 7.1 */
 461     ASSERT (errno == 0);
 462   }
 463   {
 464     const char input[] = "1p+1";
 465     char *ptr;
 466     float result;
 467     errno = 0;
 468     result = my_strtof (input, &ptr);
 469     ASSERT (result == 1.0f);
 470     ASSERT (ptr == input + 1);
 471     ASSERT (errno == 0);
 472   }
 473   {
 474     const char input[] = "1P+1";
 475     char *ptr;
 476     float result;
 477     errno = 0;
 478     result = my_strtof (input, &ptr);
 479     ASSERT (result == 1.0f);
 480     ASSERT (ptr == input + 1);
 481     ASSERT (errno == 0);
 482   }
 483
 484   /* Overflow.  */
 485   {
 486     const char input[] = "1e50";
 487     char *ptr;
 488     float result;
 489     errno = 0;
 490     result = my_strtof (input, &ptr);
 491     ASSERT (result == HUGE_VAL);
 492     ASSERT (ptr == input + 4);          /* OSF/1 5.1 */
 493     ASSERT (errno == ERANGE);
 494   }
 495   {
 496     const char input[] = "1E1000000";
 497     char *ptr;
 498     float result;
 499     errno = 0;
 500     result = my_strtof (input, &ptr);
 501     ASSERT (result == HUGE_VAL);
 502     ASSERT (ptr == input + 9);          /* OSF/1 5.1 */
 503     ASSERT (errno == ERANGE);
 504   }
 505   {
 506     const char input[] = "-1E1000000";
 507     char *ptr;
 508     float result;
 509     errno = 0;
 510     result = my_strtof (input, &ptr);
 511     ASSERT (result == -HUGE_VAL);
 512     ASSERT (ptr == input + 10);
 513     ASSERT (errno == ERANGE);
 514   }
 515
 516   /* Gradual underflow, resulting in a denormalized number.  */
 517   {
 518     const char input[] = "1e-40";
 519     char *ptr;
 520     float result;
 521     errno = 0;
 522     result = my_strtof (input, &ptr);
 523     ASSERT (0.0f < result && result <= FLT_MIN);
 524     ASSERT (ptr == input + 5);
 525 #if !defined _MSC_VER
 526     ASSERT (errno == ERANGE);
 527 #endif
 528   }
 529   {
 530     const char input[] = "-1e-40";
 531     char *ptr;
 532     float result;
 533     errno = 0;
 534     result = my_strtof (input, &ptr);
 535     ASSERT (-FLT_MIN <= result && result < 0.0f);
 536     ASSERT (ptr == input + 6);
 537 #if !defined _MSC_VER
 538     ASSERT (errno == ERANGE);
 539 #endif
 540   }
 541
 542   /* Flush-to-zero underflow.  */
 543   {
 544     const char input[] = "1E-100000";
 545     char *ptr;
 546     float result;
 547     errno = 0;
 548     result = my_strtof (input, &ptr);
 549 #if 1
 550     ASSERT (result == 0.0f);
 551 #else /* This is all that ISO C guarantees.  */
 552     ASSERT (0.0f <= result && result <= FLT_MIN);
 553 #endif
 554     ASSERT (!signbit (result));
 555     ASSERT (ptr == input + 9);
 556     ASSERT (errno == ERANGE);
 557   }
 558   {
 559     const char input[] = "-1E-100000";
 560     char *ptr;
 561     float result;
 562     errno = 0;
 563     result = my_strtof (input, &ptr);
 564 #if 1
 565     ASSERT (result == 0.0f);
 566 #else /* This is all that ISO C guarantees.  */
 567     ASSERT (-FLT_MIN <= result && result <= 0.0f);
 568 #endif
 569     /* Negative underflow.  Expect a negative sign, although POSIX allows +0.0f.
 570        See also <https://sourceware.org/bugzilla/show_bug.cgi?id=5995>.  */
 571     ASSERT (!!signbit (result) == !!signbit (minus_zerof)); /* glibc-2.3.6, mingw */
 572     ASSERT (ptr == input + 10);
 573     ASSERT (errno == ERANGE);
 574   }
 575
 576   /* Space before the exponent.  */
 577   {
 578     const char input[] = "1E 1000000";
 579     char *ptr;
 580     float result;
 581     errno = 0;
 582     result = my_strtof (input, &ptr);
 583     ASSERT (result == 1.0f);            /* HP-UX 11.11, IRIX 6.5, OSF/1 4.0 */
 584     ASSERT (ptr == input + 1);          /* HP-UX 11.11, IRIX 6.5 */
 585     ASSERT (errno == 0);
 586   }
 587   {
 588     const char input[] = "0x1P 1000000";
 589     char *ptr;
 590     float result;
 591     errno = 0;
 592     result = my_strtof (input, &ptr);
 593     ASSERT (result == 1.0f);            /* NetBSD 3.0, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 594     ASSERT (ptr == input + 3);          /* NetBSD 3.0, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 595     ASSERT (errno == 0);
 596   }
 597
 598   /* Infinity.  */
 599   {
 600     const char input[] = "iNf";
 601     char *ptr;
 602     float result;
 603     errno = 0;
 604     result = my_strtof (input, &ptr);
 605     ASSERT (result == HUGE_VAL);        /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
 606     ASSERT (ptr == input + 3);          /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
 607     ASSERT (errno == 0);                /* HP-UX 11.11, OSF/1 4.0 */
 608   }
 609   {
 610     const char input[] = "-InF";
 611     char *ptr;
 612     float result;
 613     errno = 0;
 614     result = my_strtof (input, &ptr);
 615     ASSERT (result == -HUGE_VAL);       /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
 616     ASSERT (ptr == input + 4);          /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 4.0, Solaris 9, mingw */
 617     ASSERT (errno == 0);                /* HP-UX 11.11, OSF/1 4.0 */
 618   }
 619   {
 620     const char input[] = "infinite";
 621     char *ptr;
 622     float result;
 623     errno = 0;
 624     result = my_strtof (input, &ptr);
 625     ASSERT (result == HUGE_VAL);        /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 626     ASSERT (ptr == input + 3);          /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 627     ASSERT (errno == 0);                /* OSF/1 4.0 */
 628   }
 629   {
 630     const char input[] = "infinitY";
 631     char *ptr;
 632     float result;
 633     errno = 0;
 634     result = my_strtof (input, &ptr);
 635     ASSERT (result == HUGE_VAL);        /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
 636     ASSERT (ptr == input + 8);          /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
 637     ASSERT (errno == 0);                /* HP-UX 11.11, OSF/1 4.0 */
 638   }
 639   {
 640     const char input[] = "infinitY.";
 641     char *ptr;
 642     float result;
 643     errno = 0;
 644     result = my_strtof (input, &ptr);
 645     ASSERT (result == HUGE_VAL);        /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 646     ASSERT (ptr == input + 8);          /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 647     ASSERT (errno == 0);                /* OSF/1 4.0 */
 648   }
 649
 650   /* NaN.  Some processors set the sign bit of the default NaN, so all
 651      we check is that using a sign changes the result.  */
 652   {
 653     const char input[] = "-nan";
 654     char *ptr1;
 655     char *ptr2;
 656     float result1;
 657     float result2;
 658     errno = 0;
 659     result1 = my_strtof (input, &ptr1);
 660     result2 = my_strtof (input + 1, &ptr2);
 661 #if 1 /* All known CPUs support NaNs.  */
 662     ASSERT (isnanf (result1));          /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
 663     ASSERT (isnanf (result2));          /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
 664 # if 0
 665     /* Sign bits of NaN is a portability sticking point, not worth
 666        worrying about.  */
 667     ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
 668 # endif
 669     ASSERT (ptr1 == input + 4);         /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
 670     ASSERT (ptr2 == input + 4);         /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
 671     ASSERT (errno == 0);                /* HP-UX 11.11 */
 672 #else
 673     ASSERT (result1 == 0.0f);
 674     ASSERT (result2 == 0.0f);
 675     ASSERT (!signbit (result1));
 676     ASSERT (!signbit (result2));
 677     ASSERT (ptr1 == input);
 678     ASSERT (ptr2 == input + 1);
 679     ASSERT (errno == 0 || errno == EINVAL);
 680 #endif
 681   }
 682   {
 683     const char input[] = "+nan(";
 684     char *ptr1;
 685     char *ptr2;
 686     float result1;
 687     float result2;
 688     errno = 0;
 689     result1 = my_strtof (input, &ptr1);
 690     result2 = my_strtof (input + 1, &ptr2);
 691 #if 1 /* All known CPUs support NaNs.  */
 692     ASSERT (isnanf (result1));          /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 693     ASSERT (isnanf (result2));          /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 694     ASSERT (!!signbit (result1) == !!signbit (result2));
 695     ASSERT (ptr1 == input + 4);         /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
 696     ASSERT (ptr2 == input + 4);         /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
 697     ASSERT (errno == 0);
 698 #else
 699     ASSERT (result1 == 0.0f);
 700     ASSERT (result2 == 0.0f);
 701     ASSERT (!signbit (result1));
 702     ASSERT (!signbit (result2));
 703     ASSERT (ptr1 == input);
 704     ASSERT (ptr2 == input + 1);
 705     ASSERT (errno == 0 || errno == EINVAL);
 706 #endif
 707   }
 708   {
 709     const char input[] = "-nan()";
 710     char *ptr1;
 711     char *ptr2;
 712     float result1;
 713     float result2;
 714     errno = 0;
 715     result1 = my_strtof (input, &ptr1);
 716     result2 = my_strtof (input + 1, &ptr2);
 717 #if 1 /* All known CPUs support NaNs.  */
 718     ASSERT (isnanf (result1));          /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 719     ASSERT (isnanf (result2));          /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 720 # if 0
 721     /* Sign bits of NaN is a portability sticking point, not worth
 722        worrying about.  */
 723     ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
 724 # endif
 725     ASSERT (ptr1 == input + 6);         /* glibc-2.3.6, Mac OS X 10.3, FreeBSD 6.2, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 726     ASSERT (ptr2 == input + 6);         /* glibc-2.3.6, Mac OS X 10.3, FreeBSD 6.2, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 727     ASSERT (errno == 0);
 728 #else
 729     ASSERT (result1 == 0.0f);
 730     ASSERT (result2 == 0.0f);
 731     ASSERT (!signbit (result1));
 732     ASSERT (!signbit (result2));
 733     ASSERT (ptr1 == input);
 734     ASSERT (ptr2 == input + 1);
 735     ASSERT (errno == 0 || errno == EINVAL);
 736 #endif
 737   }
 738   {
 739     const char input[] = " nan().";
 740     char *ptr;
 741     float result;
 742     errno = 0;
 743     result = my_strtof (input, &ptr);
 744 #if 1 /* All known CPUs support NaNs.  */
 745     ASSERT (isnanf (result));           /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 746     ASSERT (ptr == input + 6);          /* glibc-2.3.6, Mac OS X 10.3, FreeBSD 6.2, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 747     ASSERT (errno == 0);
 748 #else
 749     ASSERT (result == 0.0f);
 750     ASSERT (!signbit (result));
 751     ASSERT (ptr == input);
 752     ASSERT (errno == 0 || errno == EINVAL);
 753 #endif
 754   }
 755   {
 756     /* The behavior of nan(0) is implementation-defined, but all
 757        implementations we know of which handle optional
 758        n-char-sequences handle nan(0) the same as nan().  */
 759     const char input[] = "-nan(0).";
 760     char *ptr1;
 761     char *ptr2;
 762     float result1;
 763     float result2;
 764     errno = 0;
 765     result1 = my_strtof (input, &ptr1);
 766     result2 = my_strtof (input + 1, &ptr2);
 767 #if 1 /* All known CPUs support NaNs.  */
 768     ASSERT (isnanf (result1));          /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 769     ASSERT (isnanf (result2));          /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 770 # if 0
 771     /* Sign bits of NaN is a portability sticking point, not worth
 772        worrying about.  */
 773     ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
 774 # endif
 775     ASSERT (ptr1 == input + 7);         /* glibc-2.3.6, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 776     ASSERT (ptr2 == input + 7);         /* glibc-2.3.6, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
 777     ASSERT (errno == 0);
 778 #else
 779     ASSERT (result1 == 0.0f);
 780     ASSERT (result2 == 0.0f);
 781     ASSERT (!signbit (result1));
 782     ASSERT (!signbit (result2));
 783     ASSERT (ptr1 == input);
 784     ASSERT (ptr2 == input + 1);
 785     ASSERT (errno == 0 || errno == EINVAL);
 786 #endif
 787   }
 788
 789   /* Hex.  */
 790   {
 791     const char input[] = "0xa";
 792     char *ptr;
 793     float result;
 794     errno = 0;
 795     result = my_strtof (input, &ptr);
 796     ASSERT (result == 10.0f);           /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 797     ASSERT (ptr == input + 3);          /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 798     ASSERT (errno == 0);
 799   }
 800   {
 801     const char input[] = "0XA";
 802     char *ptr;
 803     float result;
 804     errno = 0;
 805     result = my_strtof (input, &ptr);
 806     ASSERT (result == 10.0f);           /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 807     ASSERT (ptr == input + 3);          /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 808     ASSERT (errno == 0);
 809   }
 810   {
 811     const char input[] = "0x1p";
 812     char *ptr;
 813     float result;
 814     errno = 0;
 815     result = my_strtof (input, &ptr);
 816     ASSERT (result == 1.0f);            /* NetBSD 3.0, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 817     ASSERT (ptr == input + 3);          /* NetBSD 3.0, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 818     ASSERT (errno == 0);
 819   }
 820   {
 821     const char input[] = "0x1p+";
 822     char *ptr;
 823     float result;
 824     errno = 0;
 825     result = my_strtof (input, &ptr);
 826     ASSERT (result == 1.0f);            /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 827     ASSERT (ptr == input + 3);          /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 828     ASSERT (errno == 0);
 829   }
 830   {
 831     const char input[] = "0x1P+";
 832     char *ptr;
 833     float result;
 834     errno = 0;
 835     result = my_strtof (input, &ptr);
 836     ASSERT (result == 1.0f);            /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 837     ASSERT (ptr == input + 3);          /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 838     ASSERT (errno == 0);
 839   }
 840   {
 841     const char input[] = "0x1p+1";
 842     char *ptr;
 843     float result;
 844     errno = 0;
 845     result = my_strtof (input, &ptr);
 846     ASSERT (result == 2.0f);            /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 847     ASSERT (ptr == input + 6);          /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 848     ASSERT (errno == 0);
 849   }
 850   {
 851     const char input[] = "0X1P+1";
 852     char *ptr;
 853     float result;
 854     errno = 0;
 855     result = my_strtof (input, &ptr);
 856     ASSERT (result == 2.0f);            /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 857     ASSERT (ptr == input + 6);          /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 858     ASSERT (errno == 0);
 859   }
 860   {
 861     const char input[] = "0x1p+1a";
 862     char *ptr;
 863     float result;
 864     errno = 0;
 865     result = my_strtof (input, &ptr);
 866     ASSERT (result == 2.0f);            /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 867     ASSERT (ptr == input + 6);          /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 868     ASSERT (errno == 0);
 869   }
 870   {
 871     const char input[] = "0x1p 2";
 872     char *ptr;
 873     float result;
 874     errno = 0;
 875     result = my_strtof (input, &ptr);
 876     ASSERT (result == 1.0f);            /* NetBSD 3.0, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 877     ASSERT (ptr == input + 3);          /* NetBSD 3.0, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
 878     ASSERT (errno == 0);
 879   }
 880
 881   /* Large buffers.  */
 882   {
 883     size_t m = 1000000;
 884     char *input = malloc (m + 1);
 885     if (input)
 886       {
 887         char *ptr;
 888         float result;
 889         memset (input, '\t', m - 1);
 890         input[m - 1] = '1';
 891         input[m] = '\0';
 892         errno = 0;
 893         result = my_strtof (input, &ptr);
 894         ASSERT (result == 1.0f);
 895         ASSERT (ptr == input + m);
 896         ASSERT (errno == 0);
 897       }
 898     free (input);
 899   }
 900   {
 901     size_t m = 1000000;
 902     char *input = malloc (m + 1);
 903     if (input)
 904       {
 905         char *ptr;
 906         float result;
 907         memset (input, '0', m - 1);
 908         input[m - 1] = '1';
 909         input[m] = '\0';
 910         errno = 0;
 911         result = my_strtof (input, &ptr);
 912         ASSERT (result == 1.0f);
 913         ASSERT (ptr == input + m);
 914         ASSERT (errno == 0);
 915       }
 916     free (input);
 917   }
 918 #if 0
 919   /* Newlib has an artificial limit of 20000 for the exponent.  TODO -
 920      gnulib should fix this.  */
 921   {
 922     size_t m = 1000000;
 923     char *input = malloc (m + 1);
 924     if (input)
 925       {
 926         char *ptr;
 927         float result;
 928         input[0] = '.';
 929         memset (input + 1, '0', m - 10);
 930         input[m - 9] = '1';
 931         input[m - 8] = 'e';
 932         input[m - 7] = '+';
 933         input[m - 6] = '9';
 934         input[m - 5] = '9';
 935         input[m - 4] = '9';
 936         input[m - 3] = '9';
 937         input[m - 2] = '9';
 938         input[m - 1] = '1';
 939         input[m] = '\0';
 940         errno = 0;
 941         result = my_strtof (input, &ptr);
 942         ASSERT (result == 1.0f);        /* Mac OS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
 943         ASSERT (ptr == input + m);      /* OSF/1 5.1 */
 944         ASSERT (errno == 0);            /* Mac OS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
 945       }
 946     free (input);
 947   }
 948   {
 949     size_t m = 1000000;
 950     char *input = malloc (m + 1);
 951     if (input)
 952       {
 953         char *ptr;
 954         float result;
 955         input[0] = '1';
 956         memset (input + 1, '0', m - 9);
 957         input[m - 8] = 'e';
 958         input[m - 7] = '-';
 959         input[m - 6] = '9';
 960         input[m - 5] = '9';
 961         input[m - 4] = '9';
 962         input[m - 3] = '9';
 963         input[m - 2] = '9';
 964         input[m - 1] = '1';
 965         input[m] = '\0';
 966         errno = 0;
 967         result = my_strtof (input, &ptr);
 968         ASSERT (result == 1.0f);        /* Mac OS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
 969         ASSERT (ptr == input + m);
 970         ASSERT (errno == 0);            /* Mac OS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
 971       }
 972     free (input);
 973   }
 974 #endif
 975   {
 976     size_t m = 1000000;
 977     char *input = malloc (m + 1);
 978     if (input)
 979       {
 980         char *ptr;
 981         float result;
 982         input[0] = '-';
 983         input[1] = '0';
 984         input[2] = 'e';
 985         input[3] = '1';
 986         memset (input + 4, '0', m - 3);
 987         input[m] = '\0';
 988         errno = 0;
 989         result = my_strtof (input, &ptr);
 990         ASSERT (result == 0.0f);
 991         ASSERT (!!signbit (result) == !!signbit (minus_zerof)); /* IRIX 6.5, OSF/1 4.0 */
 992         ASSERT (ptr == input + m);
 993         ASSERT (errno == 0);
 994       }
 995     free (input);
 996   }
 997
 998   /* Rounding.  */
 999   /* TODO - is it worth some tests of rounding for typical IEEE corner
1000      cases, such as .5 ULP rounding up to the smallest denormal and
1001      not causing underflow, or FLT_MIN - .5 ULP not causing an
1002      infinite loop?  */
1003 }