2 * Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
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/>. */
22 #include "signature.h"
23 SIGNATURE_CHECK (strtod, double, (char const *, char **));
30 #include "isnand-nolibm.h"
33 /* Avoid requiring -lm just for fabs. */
34 #define FABS(d) ((d) < 0.0 ? -(d) : (d))
36 /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
37 So we use -zero instead. */
44 /* Subject sequence empty or invalid. */
46 const char input[] = "";
50 result = strtod (input, &ptr);
51 ASSERT (result == 0.0);
52 ASSERT (!signbit (result));
53 ASSERT (ptr == input);
54 ASSERT (errno == 0 || errno == EINVAL);
57 const char input[] = " ";
61 result = strtod (input, &ptr);
62 ASSERT (result == 0.0);
63 ASSERT (!signbit (result));
64 ASSERT (ptr == input);
65 ASSERT (errno == 0 || errno == EINVAL);
68 const char input[] = " +";
72 result = strtod (input, &ptr);
73 ASSERT (result == 0.0);
74 ASSERT (!signbit (result));
75 ASSERT (ptr == input);
76 ASSERT (errno == 0 || errno == EINVAL);
79 const char input[] = " .";
83 result = strtod (input, &ptr);
84 ASSERT (result == 0.0);
85 ASSERT (!signbit (result));
86 ASSERT (ptr == input);
87 ASSERT (errno == 0 || errno == EINVAL);
90 const char input[] = " .e0";
94 result = strtod (input, &ptr);
95 ASSERT (result == 0.0);
96 ASSERT (!signbit (result));
97 ASSERT (ptr == input); /* IRIX 6.5, OSF/1 5.1 */
98 ASSERT (errno == 0 || errno == EINVAL);
101 const char input[] = " +.e-0";
105 result = strtod (input, &ptr);
106 ASSERT (result == 0.0);
107 ASSERT (!signbit (result));
108 ASSERT (ptr == input); /* IRIX 6.5, OSF/1 5.1 */
109 ASSERT (errno == 0 || errno == EINVAL);
112 const char input[] = " in";
116 result = strtod (input, &ptr);
117 ASSERT (result == 0.0);
118 ASSERT (!signbit (result));
119 ASSERT (ptr == input);
120 ASSERT (errno == 0 || errno == EINVAL);
123 const char input[] = " na";
127 result = strtod (input, &ptr);
128 ASSERT (result == 0.0);
129 ASSERT (!signbit (result));
130 ASSERT (ptr == input);
131 ASSERT (errno == 0 || errno == EINVAL);
134 /* Simple floating point values. */
136 const char input[] = "1";
140 result = strtod (input, &ptr);
141 ASSERT (result == 1.0);
142 ASSERT (ptr == input + 1);
146 const char input[] = "1.";
150 result = strtod (input, &ptr);
151 ASSERT (result == 1.0);
152 ASSERT (ptr == input + 2);
156 const char input[] = ".5";
160 result = strtod (input, &ptr);
161 /* FIXME - gnulib's version is rather inaccurate. It would be
162 nice to guarantee an exact result, but for now, we settle for a
164 ASSERT (FABS (result - 0.5) < DBL_EPSILON);
165 ASSERT (ptr == input + 2);
169 const char input[] = " 1";
173 result = strtod (input, &ptr);
174 ASSERT (result == 1.0);
175 ASSERT (ptr == input + 2);
179 const char input[] = "+1";
183 result = strtod (input, &ptr);
184 ASSERT (result == 1.0);
185 ASSERT (ptr == input + 2);
189 const char input[] = "-1";
193 result = strtod (input, &ptr);
194 ASSERT (result == -1.0);
195 ASSERT (ptr == input + 2);
199 const char input[] = "1e0";
203 result = strtod (input, &ptr);
204 ASSERT (result == 1.0);
205 ASSERT (ptr == input + 3);
209 const char input[] = "1e+0";
213 result = strtod (input, &ptr);
214 ASSERT (result == 1.0);
215 ASSERT (ptr == input + 4);
219 const char input[] = "1e-0";
223 result = strtod (input, &ptr);
224 ASSERT (result == 1.0);
225 ASSERT (ptr == input + 4);
229 const char input[] = "1e1";
233 result = strtod (input, &ptr);
234 ASSERT (result == 10.0);
235 ASSERT (ptr == input + 3);
239 const char input[] = "5e-1";
243 result = strtod (input, &ptr);
244 /* FIXME - gnulib's version is rather inaccurate. It would be
245 nice to guarantee an exact result, but for now, we settle for a
247 ASSERT (FABS (result - 0.5) < DBL_EPSILON);
248 ASSERT (ptr == input + 4);
254 const char input[] = "0";
258 result = strtod (input, &ptr);
259 ASSERT (result == 0.0);
260 ASSERT (!signbit (result));
261 ASSERT (ptr == input + 1);
265 const char input[] = ".0";
269 result = strtod (input, &ptr);
270 ASSERT (result == 0.0);
271 ASSERT (!signbit (result));
272 ASSERT (ptr == input + 2);
276 const char input[] = "0e0";
280 result = strtod (input, &ptr);
281 ASSERT (result == 0.0);
282 ASSERT (!signbit (result));
283 ASSERT (ptr == input + 3);
287 const char input[] = "0e+9999999";
291 result = strtod (input, &ptr);
292 ASSERT (result == 0.0);
293 ASSERT (!signbit (result));
294 ASSERT (ptr == input + 10);
298 const char input[] = "0e-9999999";
302 result = strtod (input, &ptr);
303 ASSERT (result == 0.0);
304 ASSERT (!signbit (result));
305 ASSERT (ptr == input + 10);
309 const char input[] = "-0";
313 result = strtod (input, &ptr);
314 ASSERT (result == 0.0);
315 ASSERT (!!signbit (result) == !!signbit (-zero)); /* IRIX 6.5, OSF/1 4.0 */
316 ASSERT (ptr == input + 2);
322 const char input[] = "1f";
326 result = strtod (input, &ptr);
327 ASSERT (result == 1.0);
328 ASSERT (ptr == input + 1);
332 const char input[] = "1.f";
336 result = strtod (input, &ptr);
337 ASSERT (result == 1.0);
338 ASSERT (ptr == input + 2);
342 const char input[] = "1e";
346 result = strtod (input, &ptr);
347 ASSERT (result == 1.0);
348 ASSERT (ptr == input + 1);
352 const char input[] = "1e+";
356 result = strtod (input, &ptr);
357 ASSERT (result == 1.0);
358 ASSERT (ptr == input + 1);
362 const char input[] = "1e-";
366 result = strtod (input, &ptr);
367 ASSERT (result == 1.0);
368 ASSERT (ptr == input + 1);
372 const char input[] = "1E 2";
376 result = strtod (input, &ptr);
377 ASSERT (result == 1.0); /* HP-UX 11.11, IRIX 6.5, OSF/1 4.0 */
378 ASSERT (ptr == input + 1); /* HP-UX 11.11, IRIX 6.5 */
382 const char input[] = "0x";
386 result = strtod (input, &ptr);
387 ASSERT (result == 0.0);
388 ASSERT (!signbit (result));
389 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
393 const char input[] = "00x1";
397 result = strtod (input, &ptr);
398 ASSERT (result == 0.0);
399 ASSERT (!signbit (result));
400 ASSERT (ptr == input + 2);
404 const char input[] = "-0x";
408 result = strtod (input, &ptr);
409 ASSERT (result == 0.0);
410 ASSERT (!!signbit (result) == !!signbit (-zero)); /* MacOS X 10.3, FreeBSD 6.2, IRIX 6.5, OSF/1 4.0 */
411 ASSERT (ptr == input + 2); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
415 const char input[] = "0xg";
419 result = strtod (input, &ptr);
420 ASSERT (result == 0.0);
421 ASSERT (!signbit (result));
422 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
426 const char input[] = "0xp";
430 result = strtod (input, &ptr);
431 ASSERT (result == 0.0);
432 ASSERT (!signbit (result));
433 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
437 const char input[] = "0x.";
441 result = strtod (input, &ptr);
442 ASSERT (result == 0.0);
443 ASSERT (!signbit (result));
444 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
448 const char input[] = "0xp+";
452 result = strtod (input, &ptr);
453 ASSERT (result == 0.0);
454 ASSERT (!signbit (result));
455 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
459 const char input[] = "0xp+1";
463 result = strtod (input, &ptr);
464 ASSERT (result == 0.0);
465 ASSERT (!signbit (result));
466 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
470 const char input[] = "0x.p+1";
474 result = strtod (input, &ptr);
475 ASSERT (result == 0.0);
476 ASSERT (!signbit (result));
477 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
481 const char input[] = "1p+1";
485 result = strtod (input, &ptr);
486 ASSERT (result == 1.0);
487 ASSERT (ptr == input + 1);
491 /* Overflow/underflow. */
493 const char input[] = "1E1000000";
497 result = strtod (input, &ptr);
498 ASSERT (result == HUGE_VAL);
499 ASSERT (ptr == input + 9); /* OSF/1 5.1 */
500 ASSERT (errno == ERANGE);
503 const char input[] = "-1E1000000";
507 result = strtod (input, &ptr);
508 ASSERT (result == -HUGE_VAL);
509 ASSERT (ptr == input + 10);
510 ASSERT (errno == ERANGE);
513 const char input[] = "1E-100000";
517 result = strtod (input, &ptr);
518 ASSERT (0.0 <= result && result <= DBL_MIN);
519 ASSERT (!signbit (result));
520 ASSERT (ptr == input + 9);
521 ASSERT (errno == ERANGE);
524 const char input[] = "-1E-100000";
528 result = strtod (input, &ptr);
529 ASSERT (-DBL_MIN <= result && result <= 0.0);
531 /* FIXME - this is glibc bug 5995; POSIX allows returning positive
532 0 on negative underflow, even though quality of implementation
533 demands preserving the sign. Disable this test until fixed
534 glibc is more prevalent. */
535 ASSERT (!!signbit (result) == !!signbit (-zero)); /* glibc-2.3.6, mingw */
537 ASSERT (ptr == input + 10);
538 ASSERT (errno == ERANGE);
543 const char input[] = "iNf";
547 result = strtod (input, &ptr);
548 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
549 ASSERT (ptr == input + 3); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
550 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
553 const char input[] = "-InF";
557 result = strtod (input, &ptr);
558 ASSERT (result == -HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
559 ASSERT (ptr == input + 4); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 4.0, Solaris 9, mingw */
560 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
563 const char input[] = "infinite";
567 result = strtod (input, &ptr);
568 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
569 ASSERT (ptr == input + 3); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
570 ASSERT (errno == 0); /* OSF/1 4.0 */
573 const char input[] = "infinitY";
577 result = strtod (input, &ptr);
578 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
579 ASSERT (ptr == input + 8); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
580 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
583 const char input[] = "infinitY.";
587 result = strtod (input, &ptr);
588 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
589 ASSERT (ptr == input + 8); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
590 ASSERT (errno == 0); /* OSF/1 4.0 */
593 /* NaN. Some processors set the sign bit of the default NaN, so all
594 we check is that using a sign changes the result. */
596 const char input[] = "-nan";
602 result1 = strtod (input, &ptr1);
603 result2 = strtod (input + 1, &ptr2);
604 #if 1 /* All known CPUs support NaNs. */
605 ASSERT (isnand (result1)); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
606 ASSERT (isnand (result2)); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
608 /* Sign bits of NaN is a portability sticking point, not worth
610 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
612 ASSERT (ptr1 == input + 4); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
613 ASSERT (ptr2 == input + 4); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
614 ASSERT (errno == 0); /* HP-UX 11.11 */
616 ASSERT (result1 == 0.0);
617 ASSERT (result2 == 0.0);
618 ASSERT (!signbit (result1));
619 ASSERT (!signbit (result2));
620 ASSERT (ptr1 == input);
621 ASSERT (ptr2 == input + 1);
622 ASSERT (errno == 0 || errno == EINVAL);
626 const char input[] = "+nan(";
632 result1 = strtod (input, &ptr1);
633 result2 = strtod (input + 1, &ptr2);
634 #if 1 /* All known CPUs support NaNs. */
635 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
636 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
637 ASSERT (!!signbit (result1) == !!signbit (result2));
638 ASSERT (ptr1 == input + 4); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
639 ASSERT (ptr2 == input + 4); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
642 ASSERT (result1 == 0.0);
643 ASSERT (result2 == 0.0);
644 ASSERT (!signbit (result1));
645 ASSERT (!signbit (result2));
646 ASSERT (ptr1 == input);
647 ASSERT (ptr2 == input + 1);
648 ASSERT (errno == 0 || errno == EINVAL);
652 const char input[] = "-nan()";
658 result1 = strtod (input, &ptr1);
659 result2 = strtod (input + 1, &ptr2);
660 #if 1 /* All known CPUs support NaNs. */
661 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
662 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
664 /* Sign bits of NaN is a portability sticking point, not worth
666 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
668 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 */
669 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 */
672 ASSERT (result1 == 0.0);
673 ASSERT (result2 == 0.0);
674 ASSERT (!signbit (result1));
675 ASSERT (!signbit (result2));
676 ASSERT (ptr1 == input);
677 ASSERT (ptr2 == input + 1);
678 ASSERT (errno == 0 || errno == EINVAL);
682 const char input[] = " nan().";
686 result = strtod (input, &ptr);
687 #if 1 /* All known CPUs support NaNs. */
688 ASSERT (isnand (result)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
689 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 */
692 ASSERT (result == 0.0);
693 ASSERT (!signbit (result));
694 ASSERT (ptr == input);
695 ASSERT (errno == 0 || errno == EINVAL);
699 /* The behavior of nan(0) is implementation-defined, but all
700 implementations we know of which handle optional
701 n-char-sequences handle nan(0) the same as nan(). */
702 const char input[] = "-nan(0).";
708 result1 = strtod (input, &ptr1);
709 result2 = strtod (input + 1, &ptr2);
710 #if 1 /* All known CPUs support NaNs. */
711 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
712 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
714 /* Sign bits of NaN is a portability sticking point, not worth
716 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
718 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 */
719 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 */
722 ASSERT (result1 == 0.0);
723 ASSERT (result2 == 0.0);
724 ASSERT (!signbit (result1));
725 ASSERT (!signbit (result2));
726 ASSERT (ptr1 == input);
727 ASSERT (ptr2 == input + 1);
728 ASSERT (errno == 0 || errno == EINVAL);
734 const char input[] = "0xa";
738 result = strtod (input, &ptr);
739 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 */
740 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 */
744 const char input[] = "0XA";
748 result = strtod (input, &ptr);
749 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 */
750 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 */
754 const char input[] = "0x1p";
758 result = strtod (input, &ptr);
759 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 */
760 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 */
764 const char input[] = "0x1p+";
768 result = strtod (input, &ptr);
769 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 */
770 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 */
774 const char input[] = "0x1p+1";
778 result = strtod (input, &ptr);
779 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 */
780 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 */
784 const char input[] = "0x1p+1a";
788 result = strtod (input, &ptr);
789 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 */
790 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 */
797 char *input = malloc (m + 1);
802 memset (input, '\t', m - 1);
806 result = strtod (input, &ptr);
807 ASSERT (result == 1.0);
808 ASSERT (ptr == input + m);
815 char *input = malloc (m + 1);
820 memset (input, '0', m - 1);
824 result = strtod (input, &ptr);
825 ASSERT (result == 1.0);
826 ASSERT (ptr == input + m);
832 /* Newlib has an artificial limit of 20000 for the exponent. TODO -
833 gnulib should fix this. */
836 char *input = malloc (m + 1);
842 memset (input + 1, '0', m - 10);
854 result = strtod (input, &ptr);
855 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 */
856 ASSERT (ptr == input + m); /* OSF/1 5.1 */
857 ASSERT (errno == 0); /* MacOS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
863 char *input = malloc (m + 1);
869 memset (input + 1, '0', m - 9);
880 result = strtod (input, &ptr);
881 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 */
882 ASSERT (ptr == input + m);
883 ASSERT (errno == 0); /* MacOS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
890 char *input = malloc (m + 1);
899 memset (input + 4, '0', m - 3);
902 result = strtod (input, &ptr);
903 ASSERT (result == 0.0);
904 ASSERT (!!signbit (result) == !!signbit (-zero)); /* IRIX 6.5, OSF/1 4.0 */
905 ASSERT (ptr == input + m);
912 /* TODO - is it worth some tests of rounding for typical IEEE corner
913 cases, such as .5 ULP rounding up to the smallest denormal and
914 not causing underflow, or DBL_MIN - .5 ULP not causing an