tests/test-strtold.h

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