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/>. */
30 #define ASSERT(expr) \
35 fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
37 /* FIXME abort ();*/status = 1; \
46 /* Subject sequence empty or invalid. */
48 const char input[] = "";
52 result = strtod (input, &ptr);
53 ASSERT (result == 0.0);
54 ASSERT (!signbit (result));
55 ASSERT (ptr == input);
56 ASSERT (errno == 0 || errno == EINVAL);
59 const char input[] = " ";
63 result = strtod (input, &ptr);
64 ASSERT (result == 0.0);
65 ASSERT (!signbit (result));
66 ASSERT (ptr == input);
67 ASSERT (errno == 0 || errno == EINVAL);
70 const char input[] = " +";
74 result = strtod (input, &ptr);
75 ASSERT (result == 0.0);
76 ASSERT (!signbit (result));
77 ASSERT (ptr == input);
78 ASSERT (errno == 0 || errno == EINVAL);
81 const char input[] = " .";
85 result = strtod (input, &ptr);
86 ASSERT (result == 0.0);
87 ASSERT (!signbit (result));
88 ASSERT (ptr == input);
89 ASSERT (errno == 0 || errno == EINVAL);
92 const char input[] = " .e0";
96 result = strtod (input, &ptr);
97 ASSERT (result == 0.0);
98 ASSERT (!signbit (result));
99 ASSERT (ptr == input); /* IRIX 6.5, OSF/1 5.1 */
100 ASSERT (errno == 0 || errno == EINVAL);
103 const char input[] = " +.e-0";
107 result = strtod (input, &ptr);
108 ASSERT (result == 0.0);
109 ASSERT (!signbit (result));
110 ASSERT (ptr == input); /* IRIX 6.5, OSF/1 5.1 */
111 ASSERT (errno == 0 || errno == EINVAL);
114 const char input[] = " in";
118 result = strtod (input, &ptr);
119 ASSERT (result == 0.0);
120 ASSERT (!signbit (result));
121 ASSERT (ptr == input);
122 ASSERT (errno == 0 || errno == EINVAL);
125 const char input[] = " na";
129 result = strtod (input, &ptr);
130 ASSERT (result == 0.0);
131 ASSERT (!signbit (result));
132 ASSERT (ptr == input);
133 ASSERT (errno == 0 || errno == EINVAL);
136 /* Simple floating point values. */
138 const char input[] = "1";
142 result = strtod (input, &ptr);
143 ASSERT (result == 1.0);
144 ASSERT (ptr == input + 1);
148 const char input[] = "1.";
152 result = strtod (input, &ptr);
153 ASSERT (result == 1.0);
154 ASSERT (ptr == input + 2);
158 const char input[] = ".5";
162 result = strtod (input, &ptr);
163 /* FIXME - gnulib's version is rather inaccurate. It would be
164 nice to guarantee an exact result, but for now, we settle for a
166 ASSERT (fabs (result - 0.5) < DBL_EPSILON);
167 ASSERT (ptr == input + 2);
171 const char input[] = " 1";
175 result = strtod (input, &ptr);
176 ASSERT (result == 1.0);
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[] = "1e0";
205 result = strtod (input, &ptr);
206 ASSERT (result == 1.0);
207 ASSERT (ptr == input + 3);
211 const char input[] = "1e+0";
215 result = strtod (input, &ptr);
216 ASSERT (result == 1.0);
217 ASSERT (ptr == input + 4);
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[] = "1e1";
235 result = strtod (input, &ptr);
236 ASSERT (result == 10.0);
237 ASSERT (ptr == input + 3);
241 const char input[] = "5e-1";
245 result = strtod (input, &ptr);
246 /* FIXME - gnulib's version is rather inaccurate. It would be
247 nice to guarantee an exact result, but for now, we settle for a
249 ASSERT (fabs (result - 0.5) < DBL_EPSILON);
250 ASSERT (ptr == input + 4);
256 const char input[] = "0";
260 result = strtod (input, &ptr);
261 ASSERT (result == 0.0);
262 ASSERT (!signbit (result));
263 ASSERT (ptr == input + 1);
267 const char input[] = ".0";
271 result = strtod (input, &ptr);
272 ASSERT (result == 0.0);
273 ASSERT (!signbit (result));
274 ASSERT (ptr == input + 2);
278 const char input[] = "0e0";
282 result = strtod (input, &ptr);
283 ASSERT (result == 0.0);
284 ASSERT (!signbit (result));
285 ASSERT (ptr == input + 3);
289 const char input[] = "0e+9999999";
293 result = strtod (input, &ptr);
294 ASSERT (result == 0.0);
295 ASSERT (!signbit (result));
296 ASSERT (ptr == input + 10);
300 const char input[] = "0e-9999999";
304 result = strtod (input, &ptr);
305 ASSERT (result == 0.0);
306 ASSERT (!signbit (result));
307 ASSERT (ptr == input + 10);
311 const char input[] = "-0";
315 result = strtod (input, &ptr);
316 ASSERT (result == 0.0);
317 ASSERT (!!signbit (result) == !!signbit (-0.0)); /* IRIX 6.5, OSF/1 4.0 */
318 ASSERT (ptr == input + 2);
324 const char input[] = "1f";
328 result = strtod (input, &ptr);
329 ASSERT (result == 1.0);
330 ASSERT (ptr == input + 1);
334 const char input[] = "1.f";
338 result = strtod (input, &ptr);
339 ASSERT (result == 1.0);
340 ASSERT (ptr == input + 2);
344 const char input[] = "1e";
348 result = strtod (input, &ptr);
349 ASSERT (result == 1.0);
350 ASSERT (ptr == input + 1);
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 2";
378 result = strtod (input, &ptr);
379 ASSERT (result == 1.0); /* HP-UX 11.11, IRIX 6.5, OSF/1 4.0 */
380 ASSERT (ptr == input + 1); /* HP-UX 11.11, IRIX 6.5 */
384 const char input[] = "0x";
388 result = strtod (input, &ptr);
389 ASSERT (result == 0.0);
390 ASSERT (!signbit (result));
391 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
395 const char input[] = "00x1";
399 result = strtod (input, &ptr);
400 ASSERT (result == 0.0);
401 ASSERT (!signbit (result));
402 ASSERT (ptr == input + 2);
406 const char input[] = "-0x";
410 result = strtod (input, &ptr);
411 ASSERT (result == 0.0);
412 ASSERT (!!signbit (result) == !!signbit (-0.0)); /* MacOS X 10.3, FreeBSD 6.2, IRIX 6.5, OSF/1 4.0 */
413 ASSERT (ptr == input + 2); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
417 const char input[] = "0xg";
421 result = strtod (input, &ptr);
422 ASSERT (result == 0.0);
423 ASSERT (!signbit (result));
424 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
428 const char input[] = "0xp";
432 result = strtod (input, &ptr);
433 ASSERT (result == 0.0);
434 ASSERT (!signbit (result));
435 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
439 const char input[] = "0x.";
443 result = strtod (input, &ptr);
444 ASSERT (result == 0.0);
445 ASSERT (!signbit (result));
446 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
450 const char input[] = "0xp+";
454 result = strtod (input, &ptr);
455 ASSERT (result == 0.0);
456 ASSERT (!signbit (result));
457 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
461 const char input[] = "0xp+1";
465 result = strtod (input, &ptr);
466 ASSERT (result == 0.0);
467 ASSERT (!signbit (result));
468 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
472 const char input[] = "0x.p+1";
476 result = strtod (input, &ptr);
477 ASSERT (result == 0.0);
478 ASSERT (!signbit (result));
479 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2 */
483 const char input[] = "1p+1";
487 result = strtod (input, &ptr);
488 ASSERT (result == 1.0);
489 ASSERT (ptr == input + 1);
493 /* Overflow/underflow. */
495 const char input[] = "1E1000000";
499 result = strtod (input, &ptr);
500 ASSERT (result == HUGE_VAL);
501 ASSERT (ptr == input + 9); /* OSF/1 5.1 */
502 ASSERT (errno == ERANGE);
505 const char input[] = "-1E1000000";
509 result = strtod (input, &ptr);
510 ASSERT (result == -HUGE_VAL);
511 ASSERT (ptr == input + 10);
512 ASSERT (errno == ERANGE);
515 const char input[] = "1E-100000";
519 result = strtod (input, &ptr);
520 ASSERT (0.0 <= result && result <= DBL_MIN);
521 ASSERT (!signbit (result));
522 ASSERT (ptr == input + 9);
523 ASSERT (errno == ERANGE);
526 const char input[] = "-1E-100000";
530 result = strtod (input, &ptr);
531 ASSERT (-DBL_MIN <= result && result <= 0.0);
533 /* FIXME - this is glibc bug 5995; POSIX allows returning positive
534 0 on negative underflow, even though quality of implementation
535 demands preserving the sign. Disable this test until fixed
536 glibc is more prevalent. */
537 ASSERT (!!signbit (result) == !!signbit (-0.0)); /* glibc-2.3.6, mingw */
539 ASSERT (ptr == input + 10);
540 ASSERT (errno == ERANGE);
545 const char input[] = "iNf";
549 result = strtod (input, &ptr);
550 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
551 ASSERT (ptr == input + 3); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
552 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
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 + 4); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 4.0, Solaris 9, mingw */
562 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
565 const char input[] = "infinite";
569 result = strtod (input, &ptr);
570 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
571 ASSERT (ptr == input + 3); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
572 ASSERT (errno == 0); /* OSF/1 4.0 */
575 const char input[] = "infinitY";
579 result = strtod (input, &ptr);
580 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
581 ASSERT (ptr == input + 8); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
582 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
585 const char input[] = "infinitY.";
589 result = strtod (input, &ptr);
590 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
591 ASSERT (ptr == input + 8); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
592 ASSERT (errno == 0); /* OSF/1 4.0 */
595 /* NaN. Some processors set the sign bit of the default NaN, so all
596 we check is that using a sign changes the result. */
598 const char input[] = "-nan";
604 result1 = strtod (input, &ptr1);
605 result2 = strtod (input + 1, &ptr2);
606 #if 1 /* All known CPUs support NaNs. */
607 ASSERT (isnand (result1)); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
608 ASSERT (isnand (result2)); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
610 /* Sign bits of NaN is a portability sticking point, not worth
612 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
614 ASSERT (ptr1 == input + 4); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
615 ASSERT (ptr2 == input + 4); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
616 ASSERT (errno == 0); /* HP-UX 11.11 */
618 ASSERT (result1 == 0.0);
619 ASSERT (result2 == 0.0);
620 ASSERT (!signbit (result1));
621 ASSERT (!signbit (result2));
622 ASSERT (ptr1 == input);
623 ASSERT (ptr2 == input + 1);
624 ASSERT (errno == 0 || errno == EINVAL);
628 const char input[] = "+nan(";
634 result1 = strtod (input, &ptr1);
635 result2 = strtod (input + 1, &ptr2);
636 #if 1 /* All known CPUs support NaNs. */
637 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
638 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
639 ASSERT (!!signbit (result1) == !!signbit (result2));
640 ASSERT (ptr1 == input + 4); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
641 ASSERT (ptr2 == input + 4); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
644 ASSERT (result1 == 0.0);
645 ASSERT (result2 == 0.0);
646 ASSERT (!signbit (result1));
647 ASSERT (!signbit (result2));
648 ASSERT (ptr1 == input);
649 ASSERT (ptr2 == input + 1);
650 ASSERT (errno == 0 || errno == EINVAL);
654 const char input[] = "-nan()";
660 result1 = strtod (input, &ptr1);
661 result2 = strtod (input + 1, &ptr2);
662 #if 1 /* All known CPUs support NaNs. */
663 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
664 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
666 /* Sign bits of NaN is a portability sticking point, not worth
668 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
670 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 */
671 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 */
674 ASSERT (result1 == 0.0);
675 ASSERT (result2 == 0.0);
676 ASSERT (!signbit (result1));
677 ASSERT (!signbit (result2));
678 ASSERT (ptr1 == input);
679 ASSERT (ptr2 == input + 1);
680 ASSERT (errno == 0 || errno == EINVAL);
684 const char input[] = " nan().";
688 result = strtod (input, &ptr);
689 #if 1 /* All known CPUs support NaNs. */
690 ASSERT (isnand (result)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
691 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 */
694 ASSERT (result == 0.0);
695 ASSERT (!signbit (result));
696 ASSERT (ptr == input);
697 ASSERT (errno == 0 || errno == EINVAL);
701 /* The behavior of nan(0) is implementation-defined, but all
702 implementations we know of which handle optional
703 n-char-sequences handle nan(0) the same as nan(). */
704 const char input[] = "-nan(0).";
710 result1 = strtod (input, &ptr1);
711 result2 = strtod (input + 1, &ptr2);
712 #if 1 /* All known CPUs support NaNs. */
713 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
714 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
716 /* Sign bits of NaN is a portability sticking point, not worth
718 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
720 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 */
721 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 */
724 ASSERT (result1 == 0.0);
725 ASSERT (result2 == 0.0);
726 ASSERT (!signbit (result1));
727 ASSERT (!signbit (result2));
728 ASSERT (ptr1 == input);
729 ASSERT (ptr2 == input + 1);
730 ASSERT (errno == 0 || errno == EINVAL);
736 const char input[] = "0xa";
740 result = strtod (input, &ptr);
741 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 */
742 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 */
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[] = "0x1p";
760 result = strtod (input, &ptr);
761 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 */
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+1";
780 result = strtod (input, &ptr);
781 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 */
782 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 */
786 const char input[] = "0x1p+1a";
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 */
799 char *input = malloc (m + 1);
804 memset (input, '\t', m - 1);
808 result = strtod (input, &ptr);
809 ASSERT (result == 1.0);
810 ASSERT (ptr == input + m);
817 char *input = malloc (m + 1);
822 memset (input, '0', m - 1);
826 result = strtod (input, &ptr);
827 ASSERT (result == 1.0);
828 ASSERT (ptr == input + m);
834 /* Newlib has an artificial limit of 20000 for the exponent. TODO -
835 gnulib should fix this. */
838 char *input = malloc (m + 1);
844 memset (input + 1, '0', m - 10);
856 result = strtod (input, &ptr);
857 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 */
858 ASSERT (ptr == input + m); /* OSF/1 5.1 */
859 ASSERT (errno == 0); /* MacOS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
865 char *input = malloc (m + 1);
871 memset (input + 1, '0', m - 9);
882 result = strtod (input, &ptr);
883 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 */
884 ASSERT (ptr == input + m);
885 ASSERT (errno == 0); /* MacOS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
892 char *input = malloc (m + 1);
901 memset (input + 4, '0', m - 3);
904 result = strtod (input, &ptr);
905 ASSERT (result == 0.0);
906 ASSERT (!!signbit (result) == !!signbit (-0.0)); /* IRIX 6.5, OSF/1 4.0 */
907 ASSERT (ptr == input + m);
914 /* TODO - is it worth some tests of rounding for typical IEEE corner
915 cases, such as .5 ULP rounding up to the smallest denormal and
916 not causing underflow, or DBL_MIN - .5 ULP not causing an