2 * Copyright (C) 2008, 2009 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/>. */
22 #include "signature.h"
23 SIGNATURE_CHECK (strtod, double, (char const *, char **));
31 #include "isnand-nolibm.h"
33 #define ASSERT(expr) \
38 fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
40 /* FIXME abort ();*/status = 1; \
45 /* Avoid requiring -lm just for fabs. */
46 #define FABS(d) ((d) < 0.0 ? -(d) : (d))
48 /* HP cc on HP-UX 10.20 has a bug with the constant expression -0.0.
49 So we use -zero instead. */
56 /* Subject sequence empty or invalid. */
58 const char input[] = "";
62 result = strtod (input, &ptr);
63 ASSERT (result == 0.0);
64 ASSERT (!signbit (result));
65 ASSERT (ptr == input);
66 ASSERT (errno == 0 || errno == EINVAL);
69 const char input[] = " ";
73 result = strtod (input, &ptr);
74 ASSERT (result == 0.0);
75 ASSERT (!signbit (result));
76 ASSERT (ptr == input);
77 ASSERT (errno == 0 || errno == EINVAL);
80 const char input[] = " +";
84 result = strtod (input, &ptr);
85 ASSERT (result == 0.0);
86 ASSERT (!signbit (result));
87 ASSERT (ptr == input);
88 ASSERT (errno == 0 || errno == EINVAL);
91 const char input[] = " .";
95 result = strtod (input, &ptr);
96 ASSERT (result == 0.0);
97 ASSERT (!signbit (result));
98 ASSERT (ptr == input);
99 ASSERT (errno == 0 || errno == EINVAL);
102 const char input[] = " .e0";
106 result = strtod (input, &ptr);
107 ASSERT (result == 0.0);
108 ASSERT (!signbit (result));
109 ASSERT (ptr == input); /* IRIX 6.5, OSF/1 5.1 */
110 ASSERT (errno == 0 || errno == EINVAL);
113 const char input[] = " +.e-0";
117 result = strtod (input, &ptr);
118 ASSERT (result == 0.0);
119 ASSERT (!signbit (result));
120 ASSERT (ptr == input); /* IRIX 6.5, OSF/1 5.1 */
121 ASSERT (errno == 0 || errno == EINVAL);
124 const char input[] = " in";
128 result = strtod (input, &ptr);
129 ASSERT (result == 0.0);
130 ASSERT (!signbit (result));
131 ASSERT (ptr == input);
132 ASSERT (errno == 0 || errno == EINVAL);
135 const char input[] = " na";
139 result = strtod (input, &ptr);
140 ASSERT (result == 0.0);
141 ASSERT (!signbit (result));
142 ASSERT (ptr == input);
143 ASSERT (errno == 0 || errno == EINVAL);
146 /* Simple floating point values. */
148 const char input[] = "1";
152 result = strtod (input, &ptr);
153 ASSERT (result == 1.0);
154 ASSERT (ptr == input + 1);
158 const char input[] = "1.";
162 result = strtod (input, &ptr);
163 ASSERT (result == 1.0);
164 ASSERT (ptr == input + 2);
168 const char input[] = ".5";
172 result = strtod (input, &ptr);
173 /* FIXME - gnulib's version is rather inaccurate. It would be
174 nice to guarantee an exact result, but for now, we settle for a
176 ASSERT (FABS (result - 0.5) < DBL_EPSILON);
177 ASSERT (ptr == input + 2);
181 const char input[] = " 1";
185 result = strtod (input, &ptr);
186 ASSERT (result == 1.0);
187 ASSERT (ptr == input + 2);
191 const char input[] = "+1";
195 result = strtod (input, &ptr);
196 ASSERT (result == 1.0);
197 ASSERT (ptr == input + 2);
201 const char input[] = "-1";
205 result = strtod (input, &ptr);
206 ASSERT (result == -1.0);
207 ASSERT (ptr == input + 2);
211 const char input[] = "1e0";
215 result = strtod (input, &ptr);
216 ASSERT (result == 1.0);
217 ASSERT (ptr == input + 3);
221 const char input[] = "1e+0";
225 result = strtod (input, &ptr);
226 ASSERT (result == 1.0);
227 ASSERT (ptr == input + 4);
231 const char input[] = "1e-0";
235 result = strtod (input, &ptr);
236 ASSERT (result == 1.0);
237 ASSERT (ptr == input + 4);
241 const char input[] = "1e1";
245 result = strtod (input, &ptr);
246 ASSERT (result == 10.0);
247 ASSERT (ptr == input + 3);
251 const char input[] = "5e-1";
255 result = strtod (input, &ptr);
256 /* FIXME - gnulib's version is rather inaccurate. It would be
257 nice to guarantee an exact result, but for now, we settle for a
259 ASSERT (FABS (result - 0.5) < DBL_EPSILON);
260 ASSERT (ptr == input + 4);
266 const char input[] = "0";
270 result = strtod (input, &ptr);
271 ASSERT (result == 0.0);
272 ASSERT (!signbit (result));
273 ASSERT (ptr == input + 1);
277 const char input[] = ".0";
281 result = strtod (input, &ptr);
282 ASSERT (result == 0.0);
283 ASSERT (!signbit (result));
284 ASSERT (ptr == input + 2);
288 const char input[] = "0e0";
292 result = strtod (input, &ptr);
293 ASSERT (result == 0.0);
294 ASSERT (!signbit (result));
295 ASSERT (ptr == input + 3);
299 const char input[] = "0e+9999999";
303 result = strtod (input, &ptr);
304 ASSERT (result == 0.0);
305 ASSERT (!signbit (result));
306 ASSERT (ptr == input + 10);
310 const char input[] = "0e-9999999";
314 result = strtod (input, &ptr);
315 ASSERT (result == 0.0);
316 ASSERT (!signbit (result));
317 ASSERT (ptr == input + 10);
321 const char input[] = "-0";
325 result = strtod (input, &ptr);
326 ASSERT (result == 0.0);
327 ASSERT (!!signbit (result) == !!signbit (-zero)); /* IRIX 6.5, OSF/1 4.0 */
328 ASSERT (ptr == input + 2);
334 const char input[] = "1f";
338 result = strtod (input, &ptr);
339 ASSERT (result == 1.0);
340 ASSERT (ptr == input + 1);
344 const char input[] = "1.f";
348 result = strtod (input, &ptr);
349 ASSERT (result == 1.0);
350 ASSERT (ptr == input + 2);
354 const char input[] = "1e";
358 result = strtod (input, &ptr);
359 ASSERT (result == 1.0);
360 ASSERT (ptr == input + 1);
364 const char input[] = "1e+";
368 result = strtod (input, &ptr);
369 ASSERT (result == 1.0);
370 ASSERT (ptr == input + 1);
374 const char input[] = "1e-";
378 result = strtod (input, &ptr);
379 ASSERT (result == 1.0);
380 ASSERT (ptr == input + 1);
384 const char input[] = "1E 2";
388 result = strtod (input, &ptr);
389 ASSERT (result == 1.0); /* HP-UX 11.11, IRIX 6.5, OSF/1 4.0 */
390 ASSERT (ptr == input + 1); /* HP-UX 11.11, IRIX 6.5 */
394 const char input[] = "0x";
398 result = strtod (input, &ptr);
399 ASSERT (result == 0.0);
400 ASSERT (!signbit (result));
401 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
405 const char input[] = "00x1";
409 result = strtod (input, &ptr);
410 ASSERT (result == 0.0);
411 ASSERT (!signbit (result));
412 ASSERT (ptr == input + 2);
416 const char input[] = "-0x";
420 result = strtod (input, &ptr);
421 ASSERT (result == 0.0);
422 ASSERT (!!signbit (result) == !!signbit (-zero)); /* MacOS X 10.3, FreeBSD 6.2, IRIX 6.5, OSF/1 4.0 */
423 ASSERT (ptr == input + 2); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
427 const char input[] = "0xg";
431 result = strtod (input, &ptr);
432 ASSERT (result == 0.0);
433 ASSERT (!signbit (result));
434 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
438 const char input[] = "0xp";
442 result = strtod (input, &ptr);
443 ASSERT (result == 0.0);
444 ASSERT (!signbit (result));
445 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
449 const char input[] = "0x.";
453 result = strtod (input, &ptr);
454 ASSERT (result == 0.0);
455 ASSERT (!signbit (result));
456 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
460 const char input[] = "0xp+";
464 result = strtod (input, &ptr);
465 ASSERT (result == 0.0);
466 ASSERT (!signbit (result));
467 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
471 const char input[] = "0xp+1";
475 result = strtod (input, &ptr);
476 ASSERT (result == 0.0);
477 ASSERT (!signbit (result));
478 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
482 const char input[] = "0x.p+1";
486 result = strtod (input, &ptr);
487 ASSERT (result == 0.0);
488 ASSERT (!signbit (result));
489 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
493 const char input[] = "1p+1";
497 result = strtod (input, &ptr);
498 ASSERT (result == 1.0);
499 ASSERT (ptr == input + 1);
503 /* Overflow/underflow. */
505 const char input[] = "1E1000000";
509 result = strtod (input, &ptr);
510 ASSERT (result == HUGE_VAL);
511 ASSERT (ptr == input + 9); /* OSF/1 5.1 */
512 ASSERT (errno == ERANGE);
515 const char input[] = "-1E1000000";
519 result = strtod (input, &ptr);
520 ASSERT (result == -HUGE_VAL);
521 ASSERT (ptr == input + 10);
522 ASSERT (errno == ERANGE);
525 const char input[] = "1E-100000";
529 result = strtod (input, &ptr);
530 ASSERT (0.0 <= result && result <= DBL_MIN);
531 ASSERT (!signbit (result));
532 ASSERT (ptr == input + 9);
533 ASSERT (errno == ERANGE);
536 const char input[] = "-1E-100000";
540 result = strtod (input, &ptr);
541 ASSERT (-DBL_MIN <= result && result <= 0.0);
543 /* FIXME - this is glibc bug 5995; POSIX allows returning positive
544 0 on negative underflow, even though quality of implementation
545 demands preserving the sign. Disable this test until fixed
546 glibc is more prevalent. */
547 ASSERT (!!signbit (result) == !!signbit (-zero)); /* glibc-2.3.6, mingw */
549 ASSERT (ptr == input + 10);
550 ASSERT (errno == ERANGE);
555 const char input[] = "iNf";
559 result = strtod (input, &ptr);
560 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
561 ASSERT (ptr == input + 3); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
562 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
565 const char input[] = "-InF";
569 result = strtod (input, &ptr);
570 ASSERT (result == -HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
571 ASSERT (ptr == input + 4); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 4.0, Solaris 9, mingw */
572 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
575 const char input[] = "infinite";
579 result = strtod (input, &ptr);
580 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
581 ASSERT (ptr == input + 3); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
582 ASSERT (errno == 0); /* OSF/1 4.0 */
585 const char input[] = "infinitY";
589 result = strtod (input, &ptr);
590 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
591 ASSERT (ptr == input + 8); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
592 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
595 const char input[] = "infinitY.";
599 result = strtod (input, &ptr);
600 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
601 ASSERT (ptr == input + 8); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
602 ASSERT (errno == 0); /* OSF/1 4.0 */
605 /* NaN. Some processors set the sign bit of the default NaN, so all
606 we check is that using a sign changes the result. */
608 const char input[] = "-nan";
614 result1 = strtod (input, &ptr1);
615 result2 = strtod (input + 1, &ptr2);
616 #if 1 /* All known CPUs support NaNs. */
617 ASSERT (isnand (result1)); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
618 ASSERT (isnand (result2)); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
620 /* Sign bits of NaN is a portability sticking point, not worth
622 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
624 ASSERT (ptr1 == input + 4); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
625 ASSERT (ptr2 == input + 4); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
626 ASSERT (errno == 0); /* HP-UX 11.11 */
628 ASSERT (result1 == 0.0);
629 ASSERT (result2 == 0.0);
630 ASSERT (!signbit (result1));
631 ASSERT (!signbit (result2));
632 ASSERT (ptr1 == input);
633 ASSERT (ptr2 == input + 1);
634 ASSERT (errno == 0 || errno == EINVAL);
638 const char input[] = "+nan(";
644 result1 = strtod (input, &ptr1);
645 result2 = strtod (input + 1, &ptr2);
646 #if 1 /* All known CPUs support NaNs. */
647 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
648 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
649 ASSERT (!!signbit (result1) == !!signbit (result2));
650 ASSERT (ptr1 == input + 4); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
651 ASSERT (ptr2 == input + 4); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
654 ASSERT (result1 == 0.0);
655 ASSERT (result2 == 0.0);
656 ASSERT (!signbit (result1));
657 ASSERT (!signbit (result2));
658 ASSERT (ptr1 == input);
659 ASSERT (ptr2 == input + 1);
660 ASSERT (errno == 0 || errno == EINVAL);
664 const char input[] = "-nan()";
670 result1 = strtod (input, &ptr1);
671 result2 = strtod (input + 1, &ptr2);
672 #if 1 /* All known CPUs support NaNs. */
673 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
674 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
676 /* Sign bits of NaN is a portability sticking point, not worth
678 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
680 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 */
681 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 */
684 ASSERT (result1 == 0.0);
685 ASSERT (result2 == 0.0);
686 ASSERT (!signbit (result1));
687 ASSERT (!signbit (result2));
688 ASSERT (ptr1 == input);
689 ASSERT (ptr2 == input + 1);
690 ASSERT (errno == 0 || errno == EINVAL);
694 const char input[] = " nan().";
698 result = strtod (input, &ptr);
699 #if 1 /* All known CPUs support NaNs. */
700 ASSERT (isnand (result)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
701 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 */
704 ASSERT (result == 0.0);
705 ASSERT (!signbit (result));
706 ASSERT (ptr == input);
707 ASSERT (errno == 0 || errno == EINVAL);
711 /* The behavior of nan(0) is implementation-defined, but all
712 implementations we know of which handle optional
713 n-char-sequences handle nan(0) the same as nan(). */
714 const char input[] = "-nan(0).";
720 result1 = strtod (input, &ptr1);
721 result2 = strtod (input + 1, &ptr2);
722 #if 1 /* All known CPUs support NaNs. */
723 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
724 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
726 /* Sign bits of NaN is a portability sticking point, not worth
728 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
730 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 */
731 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 */
734 ASSERT (result1 == 0.0);
735 ASSERT (result2 == 0.0);
736 ASSERT (!signbit (result1));
737 ASSERT (!signbit (result2));
738 ASSERT (ptr1 == input);
739 ASSERT (ptr2 == input + 1);
740 ASSERT (errno == 0 || errno == EINVAL);
746 const char input[] = "0xa";
750 result = strtod (input, &ptr);
751 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 */
752 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 */
756 const char input[] = "0XA";
760 result = strtod (input, &ptr);
761 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 */
762 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 */
766 const char input[] = "0x1p";
770 result = strtod (input, &ptr);
771 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 */
772 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 */
776 const char input[] = "0x1p+";
780 result = strtod (input, &ptr);
781 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 */
782 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 */
786 const char input[] = "0x1p+1";
790 result = strtod (input, &ptr);
791 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 */
792 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 */
796 const char input[] = "0x1p+1a";
800 result = strtod (input, &ptr);
801 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 */
802 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 */
809 char *input = malloc (m + 1);
814 memset (input, '\t', m - 1);
818 result = strtod (input, &ptr);
819 ASSERT (result == 1.0);
820 ASSERT (ptr == input + m);
827 char *input = malloc (m + 1);
832 memset (input, '0', m - 1);
836 result = strtod (input, &ptr);
837 ASSERT (result == 1.0);
838 ASSERT (ptr == input + m);
844 /* Newlib has an artificial limit of 20000 for the exponent. TODO -
845 gnulib should fix this. */
848 char *input = malloc (m + 1);
854 memset (input + 1, '0', m - 10);
866 result = strtod (input, &ptr);
867 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 */
868 ASSERT (ptr == input + m); /* OSF/1 5.1 */
869 ASSERT (errno == 0); /* MacOS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
875 char *input = malloc (m + 1);
881 memset (input + 1, '0', m - 9);
892 result = strtod (input, &ptr);
893 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 */
894 ASSERT (ptr == input + m);
895 ASSERT (errno == 0); /* MacOS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
902 char *input = malloc (m + 1);
911 memset (input + 4, '0', m - 3);
914 result = strtod (input, &ptr);
915 ASSERT (result == 0.0);
916 ASSERT (!!signbit (result) == !!signbit (-zero)); /* IRIX 6.5, OSF/1 4.0 */
917 ASSERT (ptr == input + m);
924 /* TODO - is it worth some tests of rounding for typical IEEE corner
925 cases, such as .5 ULP rounding up to the smallest denormal and
926 not causing underflow, or DBL_MIN - .5 ULP not causing an