2 * Copyright (C) 2008 Free Software Foundation
3 * Written by Eric Blake
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.
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.
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/>. */
28 #include "isnand-nolibm.h"
30 #define ASSERT(expr) \
35 fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
37 /* FIXME abort ();*/status = 1; \
42 /* Avoid requiring -lm just for fabs. */
43 #define FABS(d) ((d) < 0.0 ? -(d) : (d))
45 /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
46 So we use -zero instead. */
53 /* Subject sequence empty or invalid. */
55 const char input[] = "";
59 result = strtod (input, &ptr);
60 ASSERT (result == 0.0);
61 ASSERT (!signbit (result));
62 ASSERT (ptr == input);
63 ASSERT (errno == 0 || errno == EINVAL);
66 const char input[] = " ";
70 result = strtod (input, &ptr);
71 ASSERT (result == 0.0);
72 ASSERT (!signbit (result));
73 ASSERT (ptr == input);
74 ASSERT (errno == 0 || errno == EINVAL);
77 const char input[] = " +";
81 result = strtod (input, &ptr);
82 ASSERT (result == 0.0);
83 ASSERT (!signbit (result));
84 ASSERT (ptr == input);
85 ASSERT (errno == 0 || errno == EINVAL);
88 const char input[] = " .";
92 result = strtod (input, &ptr);
93 ASSERT (result == 0.0);
94 ASSERT (!signbit (result));
95 ASSERT (ptr == input);
96 ASSERT (errno == 0 || errno == EINVAL);
99 const char input[] = " .e0";
103 result = strtod (input, &ptr);
104 ASSERT (result == 0.0);
105 ASSERT (!signbit (result));
106 ASSERT (ptr == input); /* IRIX 6.5, OSF/1 5.1 */
107 ASSERT (errno == 0 || errno == EINVAL);
110 const char input[] = " +.e-0";
114 result = strtod (input, &ptr);
115 ASSERT (result == 0.0);
116 ASSERT (!signbit (result));
117 ASSERT (ptr == input); /* IRIX 6.5, OSF/1 5.1 */
118 ASSERT (errno == 0 || errno == EINVAL);
121 const char input[] = " in";
125 result = strtod (input, &ptr);
126 ASSERT (result == 0.0);
127 ASSERT (!signbit (result));
128 ASSERT (ptr == input);
129 ASSERT (errno == 0 || errno == EINVAL);
132 const char input[] = " na";
136 result = strtod (input, &ptr);
137 ASSERT (result == 0.0);
138 ASSERT (!signbit (result));
139 ASSERT (ptr == input);
140 ASSERT (errno == 0 || errno == EINVAL);
143 /* Simple floating point values. */
145 const char input[] = "1";
149 result = strtod (input, &ptr);
150 ASSERT (result == 1.0);
151 ASSERT (ptr == input + 1);
155 const char input[] = "1.";
159 result = strtod (input, &ptr);
160 ASSERT (result == 1.0);
161 ASSERT (ptr == input + 2);
165 const char input[] = ".5";
169 result = strtod (input, &ptr);
170 /* FIXME - gnulib's version is rather inaccurate. It would be
171 nice to guarantee an exact result, but for now, we settle for a
173 ASSERT (FABS (result - 0.5) < DBL_EPSILON);
174 ASSERT (ptr == input + 2);
178 const char input[] = " 1";
182 result = strtod (input, &ptr);
183 ASSERT (result == 1.0);
184 ASSERT (ptr == input + 2);
188 const char input[] = "+1";
192 result = strtod (input, &ptr);
193 ASSERT (result == 1.0);
194 ASSERT (ptr == input + 2);
198 const char input[] = "-1";
202 result = strtod (input, &ptr);
203 ASSERT (result == -1.0);
204 ASSERT (ptr == input + 2);
208 const char input[] = "1e0";
212 result = strtod (input, &ptr);
213 ASSERT (result == 1.0);
214 ASSERT (ptr == input + 3);
218 const char input[] = "1e+0";
222 result = strtod (input, &ptr);
223 ASSERT (result == 1.0);
224 ASSERT (ptr == input + 4);
228 const char input[] = "1e-0";
232 result = strtod (input, &ptr);
233 ASSERT (result == 1.0);
234 ASSERT (ptr == input + 4);
238 const char input[] = "1e1";
242 result = strtod (input, &ptr);
243 ASSERT (result == 10.0);
244 ASSERT (ptr == input + 3);
248 const char input[] = "5e-1";
252 result = strtod (input, &ptr);
253 /* FIXME - gnulib's version is rather inaccurate. It would be
254 nice to guarantee an exact result, but for now, we settle for a
256 ASSERT (FABS (result - 0.5) < DBL_EPSILON);
257 ASSERT (ptr == input + 4);
263 const char input[] = "0";
267 result = strtod (input, &ptr);
268 ASSERT (result == 0.0);
269 ASSERT (!signbit (result));
270 ASSERT (ptr == input + 1);
274 const char input[] = ".0";
278 result = strtod (input, &ptr);
279 ASSERT (result == 0.0);
280 ASSERT (!signbit (result));
281 ASSERT (ptr == input + 2);
285 const char input[] = "0e0";
289 result = strtod (input, &ptr);
290 ASSERT (result == 0.0);
291 ASSERT (!signbit (result));
292 ASSERT (ptr == input + 3);
296 const char input[] = "0e+9999999";
300 result = strtod (input, &ptr);
301 ASSERT (result == 0.0);
302 ASSERT (!signbit (result));
303 ASSERT (ptr == input + 10);
307 const char input[] = "0e-9999999";
311 result = strtod (input, &ptr);
312 ASSERT (result == 0.0);
313 ASSERT (!signbit (result));
314 ASSERT (ptr == input + 10);
318 const char input[] = "-0";
322 result = strtod (input, &ptr);
323 ASSERT (result == 0.0);
324 ASSERT (!!signbit (result) == !!signbit (-zero)); /* IRIX 6.5, OSF/1 4.0 */
325 ASSERT (ptr == input + 2);
331 const char input[] = "1f";
335 result = strtod (input, &ptr);
336 ASSERT (result == 1.0);
337 ASSERT (ptr == input + 1);
341 const char input[] = "1.f";
345 result = strtod (input, &ptr);
346 ASSERT (result == 1.0);
347 ASSERT (ptr == input + 2);
351 const char input[] = "1e";
355 result = strtod (input, &ptr);
356 ASSERT (result == 1.0);
357 ASSERT (ptr == input + 1);
361 const char input[] = "1e+";
365 result = strtod (input, &ptr);
366 ASSERT (result == 1.0);
367 ASSERT (ptr == input + 1);
371 const char input[] = "1e-";
375 result = strtod (input, &ptr);
376 ASSERT (result == 1.0);
377 ASSERT (ptr == input + 1);
381 const char input[] = "1E 2";
385 result = strtod (input, &ptr);
386 ASSERT (result == 1.0); /* HP-UX 11.11, IRIX 6.5, OSF/1 4.0 */
387 ASSERT (ptr == input + 1); /* HP-UX 11.11, IRIX 6.5 */
391 const char input[] = "0x";
395 result = strtod (input, &ptr);
396 ASSERT (result == 0.0);
397 ASSERT (!signbit (result));
398 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
402 const char input[] = "00x1";
406 result = strtod (input, &ptr);
407 ASSERT (result == 0.0);
408 ASSERT (!signbit (result));
409 ASSERT (ptr == input + 2);
413 const char input[] = "-0x";
417 result = strtod (input, &ptr);
418 ASSERT (result == 0.0);
419 ASSERT (!!signbit (result) == !!signbit (-zero)); /* MacOS X 10.3, FreeBSD 6.2, IRIX 6.5, OSF/1 4.0 */
420 ASSERT (ptr == input + 2); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
424 const char input[] = "0xg";
428 result = strtod (input, &ptr);
429 ASSERT (result == 0.0);
430 ASSERT (!signbit (result));
431 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
435 const char input[] = "0xp";
439 result = strtod (input, &ptr);
440 ASSERT (result == 0.0);
441 ASSERT (!signbit (result));
442 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
446 const char input[] = "0x.";
450 result = strtod (input, &ptr);
451 ASSERT (result == 0.0);
452 ASSERT (!signbit (result));
453 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
457 const char input[] = "0xp+";
461 result = strtod (input, &ptr);
462 ASSERT (result == 0.0);
463 ASSERT (!signbit (result));
464 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
468 const char input[] = "0xp+1";
472 result = strtod (input, &ptr);
473 ASSERT (result == 0.0);
474 ASSERT (!signbit (result));
475 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
479 const char input[] = "0x.p+1";
483 result = strtod (input, &ptr);
484 ASSERT (result == 0.0);
485 ASSERT (!signbit (result));
486 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
490 const char input[] = "1p+1";
494 result = strtod (input, &ptr);
495 ASSERT (result == 1.0);
496 ASSERT (ptr == input + 1);
500 /* Overflow/underflow. */
502 const char input[] = "1E1000000";
506 result = strtod (input, &ptr);
507 ASSERT (result == HUGE_VAL);
508 ASSERT (ptr == input + 9); /* OSF/1 5.1 */
509 ASSERT (errno == ERANGE);
512 const char input[] = "-1E1000000";
516 result = strtod (input, &ptr);
517 ASSERT (result == -HUGE_VAL);
518 ASSERT (ptr == input + 10);
519 ASSERT (errno == ERANGE);
522 const char input[] = "1E-100000";
526 result = strtod (input, &ptr);
527 ASSERT (0.0 <= result && result <= DBL_MIN);
528 ASSERT (!signbit (result));
529 ASSERT (ptr == input + 9);
530 ASSERT (errno == ERANGE);
533 const char input[] = "-1E-100000";
537 result = strtod (input, &ptr);
538 ASSERT (-DBL_MIN <= result && result <= 0.0);
540 /* FIXME - this is glibc bug 5995; POSIX allows returning positive
541 0 on negative underflow, even though quality of implementation
542 demands preserving the sign. Disable this test until fixed
543 glibc is more prevalent. */
544 ASSERT (!!signbit (result) == !!signbit (-zero)); /* glibc-2.3.6, mingw */
546 ASSERT (ptr == input + 10);
547 ASSERT (errno == ERANGE);
552 const char input[] = "iNf";
556 result = strtod (input, &ptr);
557 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
558 ASSERT (ptr == input + 3); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
559 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
562 const char input[] = "-InF";
566 result = strtod (input, &ptr);
567 ASSERT (result == -HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
568 ASSERT (ptr == input + 4); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 4.0, Solaris 9, mingw */
569 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
572 const char input[] = "infinite";
576 result = strtod (input, &ptr);
577 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
578 ASSERT (ptr == input + 3); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
579 ASSERT (errno == 0); /* OSF/1 4.0 */
582 const char input[] = "infinitY";
586 result = strtod (input, &ptr);
587 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
588 ASSERT (ptr == input + 8); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
589 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
592 const char input[] = "infinitY.";
596 result = strtod (input, &ptr);
597 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
598 ASSERT (ptr == input + 8); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
599 ASSERT (errno == 0); /* OSF/1 4.0 */
602 /* NaN. Some processors set the sign bit of the default NaN, so all
603 we check is that using a sign changes the result. */
605 const char input[] = "-nan";
611 result1 = strtod (input, &ptr1);
612 result2 = strtod (input + 1, &ptr2);
613 #if 1 /* All known CPUs support NaNs. */
614 ASSERT (isnand (result1)); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
615 ASSERT (isnand (result2)); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
617 /* Sign bits of NaN is a portability sticking point, not worth
619 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
621 ASSERT (ptr1 == input + 4); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
622 ASSERT (ptr2 == input + 4); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
623 ASSERT (errno == 0); /* HP-UX 11.11 */
625 ASSERT (result1 == 0.0);
626 ASSERT (result2 == 0.0);
627 ASSERT (!signbit (result1));
628 ASSERT (!signbit (result2));
629 ASSERT (ptr1 == input);
630 ASSERT (ptr2 == input + 1);
631 ASSERT (errno == 0 || errno == EINVAL);
635 const char input[] = "+nan(";
641 result1 = strtod (input, &ptr1);
642 result2 = strtod (input + 1, &ptr2);
643 #if 1 /* All known CPUs support NaNs. */
644 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
645 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
646 ASSERT (!!signbit (result1) == !!signbit (result2));
647 ASSERT (ptr1 == input + 4); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
648 ASSERT (ptr2 == input + 4); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
651 ASSERT (result1 == 0.0);
652 ASSERT (result2 == 0.0);
653 ASSERT (!signbit (result1));
654 ASSERT (!signbit (result2));
655 ASSERT (ptr1 == input);
656 ASSERT (ptr2 == input + 1);
657 ASSERT (errno == 0 || errno == EINVAL);
661 const char input[] = "-nan()";
667 result1 = strtod (input, &ptr1);
668 result2 = strtod (input + 1, &ptr2);
669 #if 1 /* All known CPUs support NaNs. */
670 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
671 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
673 /* Sign bits of NaN is a portability sticking point, not worth
675 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
677 ASSERT (ptr1 == input + 6); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
678 ASSERT (ptr2 == input + 6); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
681 ASSERT (result1 == 0.0);
682 ASSERT (result2 == 0.0);
683 ASSERT (!signbit (result1));
684 ASSERT (!signbit (result2));
685 ASSERT (ptr1 == input);
686 ASSERT (ptr2 == input + 1);
687 ASSERT (errno == 0 || errno == EINVAL);
691 const char input[] = " nan().";
695 result = strtod (input, &ptr);
696 #if 1 /* All known CPUs support NaNs. */
697 ASSERT (isnand (result)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
698 ASSERT (ptr == input + 6); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
701 ASSERT (result == 0.0);
702 ASSERT (!signbit (result));
703 ASSERT (ptr == input);
704 ASSERT (errno == 0 || errno == EINVAL);
708 /* The behavior of nan(0) is implementation-defined, but all
709 implementations we know of which handle optional
710 n-char-sequences handle nan(0) the same as nan(). */
711 const char input[] = "-nan(0).";
717 result1 = strtod (input, &ptr1);
718 result2 = strtod (input + 1, &ptr2);
719 #if 1 /* All known CPUs support NaNs. */
720 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
721 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
723 /* Sign bits of NaN is a portability sticking point, not worth
725 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
727 ASSERT (ptr1 == input + 7); /* glibc-2.3.6, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
728 ASSERT (ptr2 == input + 7); /* glibc-2.3.6, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
731 ASSERT (result1 == 0.0);
732 ASSERT (result2 == 0.0);
733 ASSERT (!signbit (result1));
734 ASSERT (!signbit (result2));
735 ASSERT (ptr1 == input);
736 ASSERT (ptr2 == input + 1);
737 ASSERT (errno == 0 || errno == EINVAL);
743 const char input[] = "0xa";
747 result = strtod (input, &ptr);
748 ASSERT (result == 10.0); /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
749 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 */
753 const char input[] = "0XA";
757 result = strtod (input, &ptr);
758 ASSERT (result == 10.0); /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
759 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 */
763 const char input[] = "0x1p";
767 result = strtod (input, &ptr);
768 ASSERT (result == 1.0); /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
769 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 */
773 const char input[] = "0x1p+";
777 result = strtod (input, &ptr);
778 ASSERT (result == 1.0); /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
779 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 */
783 const char input[] = "0x1p+1";
787 result = strtod (input, &ptr);
788 ASSERT (result == 2.0); /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
789 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 */
793 const char input[] = "0x1p+1a";
797 result = strtod (input, &ptr);
798 ASSERT (result == 2.0); /* NetBSD 3.0, OpenBSD 4.0, AIX 5.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
799 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 */
806 char *input = malloc (m + 1);
811 memset (input, '\t', m - 1);
815 result = strtod (input, &ptr);
816 ASSERT (result == 1.0);
817 ASSERT (ptr == input + m);
824 char *input = malloc (m + 1);
829 memset (input, '0', m - 1);
833 result = strtod (input, &ptr);
834 ASSERT (result == 1.0);
835 ASSERT (ptr == input + m);
841 /* Newlib has an artificial limit of 20000 for the exponent. TODO -
842 gnulib should fix this. */
845 char *input = malloc (m + 1);
851 memset (input + 1, '0', m - 10);
863 result = strtod (input, &ptr);
864 ASSERT (result == 1.0); /* MacOS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
865 ASSERT (ptr == input + m); /* OSF/1 5.1 */
866 ASSERT (errno == 0); /* MacOS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
872 char *input = malloc (m + 1);
878 memset (input + 1, '0', m - 9);
889 result = strtod (input, &ptr);
890 ASSERT (result == 1.0); /* MacOS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
891 ASSERT (ptr == input + m);
892 ASSERT (errno == 0); /* MacOS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
899 char *input = malloc (m + 1);
908 memset (input + 4, '0', m - 3);
911 result = strtod (input, &ptr);
912 ASSERT (result == 0.0);
913 ASSERT (!!signbit (result) == !!signbit (-zero)); /* IRIX 6.5, OSF/1 4.0 */
914 ASSERT (ptr == input + m);
921 /* TODO - is it worth some tests of rounding for typical IEEE corner
922 cases, such as .5 ULP rounding up to the smallest denormal and
923 not causing underflow, or DBL_MIN - .5 ULP not causing an