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, AIX 7.1 */
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, AIX 7.1 */
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, AIX 7.1 */
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, AIX 7.1 */
437 const char input[] = "0XP";
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, AIX 7.1 */
448 const char input[] = "0x.";
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, AIX 7.1 */
459 const char input[] = "0xp+";
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, AIX 7.1 */
470 const char input[] = "0xp+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, AIX 7.1 */
481 const char input[] = "0x.p+1";
485 result = strtod (input, &ptr);
486 ASSERT (result == 0.0);
487 ASSERT (!signbit (result));
488 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, AIX 7.1 */
492 const char input[] = "1p+1";
496 result = strtod (input, &ptr);
497 ASSERT (result == 1.0);
498 ASSERT (ptr == input + 1);
502 const char input[] = "1P+1";
506 result = strtod (input, &ptr);
507 ASSERT (result == 1.0);
508 ASSERT (ptr == input + 1);
512 /* Overflow/underflow. */
514 const char input[] = "1E1000000";
518 result = strtod (input, &ptr);
519 ASSERT (result == HUGE_VAL);
520 ASSERT (ptr == input + 9); /* OSF/1 5.1 */
521 ASSERT (errno == ERANGE);
524 const char input[] = "-1E1000000";
528 result = strtod (input, &ptr);
529 ASSERT (result == -HUGE_VAL);
530 ASSERT (ptr == input + 10);
531 ASSERT (errno == ERANGE);
534 const char input[] = "1E-100000";
538 result = strtod (input, &ptr);
539 ASSERT (0.0 <= result && result <= DBL_MIN);
540 ASSERT (!signbit (result));
541 ASSERT (ptr == input + 9);
542 ASSERT (errno == ERANGE);
545 const char input[] = "-1E-100000";
549 result = strtod (input, &ptr);
550 ASSERT (-DBL_MIN <= result && result <= 0.0);
552 /* FIXME - this is glibc bug 5995; POSIX allows returning positive
553 0 on negative underflow, even though quality of implementation
554 demands preserving the sign. Disable this test until fixed
555 glibc is more prevalent. */
556 ASSERT (!!signbit (result) == !!signbit (-zero)); /* glibc-2.3.6, mingw */
558 ASSERT (ptr == input + 10);
559 ASSERT (errno == ERANGE);
564 const char input[] = "iNf";
568 result = strtod (input, &ptr);
569 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
570 ASSERT (ptr == input + 3); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
571 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
574 const char input[] = "-InF";
578 result = strtod (input, &ptr);
579 ASSERT (result == -HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
580 ASSERT (ptr == input + 4); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 4.0, Solaris 9, mingw */
581 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
584 const char input[] = "infinite";
588 result = strtod (input, &ptr);
589 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
590 ASSERT (ptr == input + 3); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
591 ASSERT (errno == 0); /* OSF/1 4.0 */
594 const char input[] = "infinitY";
598 result = strtod (input, &ptr);
599 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
600 ASSERT (ptr == input + 8); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
601 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
604 const char input[] = "infinitY.";
608 result = strtod (input, &ptr);
609 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
610 ASSERT (ptr == input + 8); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
611 ASSERT (errno == 0); /* OSF/1 4.0 */
614 /* NaN. Some processors set the sign bit of the default NaN, so all
615 we check is that using a sign changes the result. */
617 const char input[] = "-nan";
623 result1 = strtod (input, &ptr1);
624 result2 = strtod (input + 1, &ptr2);
625 #if 1 /* All known CPUs support NaNs. */
626 ASSERT (isnand (result1)); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
627 ASSERT (isnand (result2)); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
629 /* Sign bits of NaN is a portability sticking point, not worth
631 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
633 ASSERT (ptr1 == input + 4); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
634 ASSERT (ptr2 == input + 4); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
635 ASSERT (errno == 0); /* HP-UX 11.11 */
637 ASSERT (result1 == 0.0);
638 ASSERT (result2 == 0.0);
639 ASSERT (!signbit (result1));
640 ASSERT (!signbit (result2));
641 ASSERT (ptr1 == input);
642 ASSERT (ptr2 == input + 1);
643 ASSERT (errno == 0 || errno == EINVAL);
647 const char input[] = "+nan(";
653 result1 = strtod (input, &ptr1);
654 result2 = strtod (input + 1, &ptr2);
655 #if 1 /* All known CPUs support NaNs. */
656 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
657 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
658 ASSERT (!!signbit (result1) == !!signbit (result2));
659 ASSERT (ptr1 == input + 4); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
660 ASSERT (ptr2 == input + 4); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
663 ASSERT (result1 == 0.0);
664 ASSERT (result2 == 0.0);
665 ASSERT (!signbit (result1));
666 ASSERT (!signbit (result2));
667 ASSERT (ptr1 == input);
668 ASSERT (ptr2 == input + 1);
669 ASSERT (errno == 0 || errno == EINVAL);
673 const char input[] = "-nan()";
679 result1 = strtod (input, &ptr1);
680 result2 = strtod (input + 1, &ptr2);
681 #if 1 /* All known CPUs support NaNs. */
682 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
683 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
685 /* Sign bits of NaN is a portability sticking point, not worth
687 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
689 ASSERT (ptr1 == input + 6); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
690 ASSERT (ptr2 == input + 6); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
693 ASSERT (result1 == 0.0);
694 ASSERT (result2 == 0.0);
695 ASSERT (!signbit (result1));
696 ASSERT (!signbit (result2));
697 ASSERT (ptr1 == input);
698 ASSERT (ptr2 == input + 1);
699 ASSERT (errno == 0 || errno == EINVAL);
703 const char input[] = " nan().";
707 result = strtod (input, &ptr);
708 #if 1 /* All known CPUs support NaNs. */
709 ASSERT (isnand (result)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
710 ASSERT (ptr == input + 6); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
713 ASSERT (result == 0.0);
714 ASSERT (!signbit (result));
715 ASSERT (ptr == input);
716 ASSERT (errno == 0 || errno == EINVAL);
720 /* The behavior of nan(0) is implementation-defined, but all
721 implementations we know of which handle optional
722 n-char-sequences handle nan(0) the same as nan(). */
723 const char input[] = "-nan(0).";
729 result1 = strtod (input, &ptr1);
730 result2 = strtod (input + 1, &ptr2);
731 #if 1 /* All known CPUs support NaNs. */
732 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
733 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
735 /* Sign bits of NaN is a portability sticking point, not worth
737 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
739 ASSERT (ptr1 == input + 7); /* glibc-2.3.6, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
740 ASSERT (ptr2 == input + 7); /* glibc-2.3.6, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
743 ASSERT (result1 == 0.0);
744 ASSERT (result2 == 0.0);
745 ASSERT (!signbit (result1));
746 ASSERT (!signbit (result2));
747 ASSERT (ptr1 == input);
748 ASSERT (ptr2 == input + 1);
749 ASSERT (errno == 0 || errno == EINVAL);
755 const char input[] = "0xa";
759 result = strtod (input, &ptr);
760 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 */
761 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 */
765 const char input[] = "0XA";
769 result = strtod (input, &ptr);
770 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 */
771 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 */
775 const char input[] = "0x1p";
779 result = strtod (input, &ptr);
780 ASSERT (result == 1.0); /* NetBSD 3.0, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
781 ASSERT (ptr == input + 3); /* NetBSD 3.0, OpenBSD 4.0, AIX 7.1, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 10, mingw */
785 const char input[] = "0x1p+";
789 result = strtod (input, &ptr);
790 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 */
791 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 */
795 const char input[] = "0x1P+";
799 result = strtod (input, &ptr);
800 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 */
801 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 */
805 const char input[] = "0x1p+1";
809 result = strtod (input, &ptr);
810 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 */
811 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 */
815 const char input[] = "0X1P+1";
819 result = strtod (input, &ptr);
820 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 */
821 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 */
825 const char input[] = "0x1p+1a";
829 result = strtod (input, &ptr);
830 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 */
831 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 */
838 char *input = malloc (m + 1);
843 memset (input, '\t', m - 1);
847 result = strtod (input, &ptr);
848 ASSERT (result == 1.0);
849 ASSERT (ptr == input + m);
856 char *input = malloc (m + 1);
861 memset (input, '0', m - 1);
865 result = strtod (input, &ptr);
866 ASSERT (result == 1.0);
867 ASSERT (ptr == input + m);
873 /* Newlib has an artificial limit of 20000 for the exponent. TODO -
874 gnulib should fix this. */
877 char *input = malloc (m + 1);
883 memset (input + 1, '0', m - 10);
895 result = strtod (input, &ptr);
896 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 */
897 ASSERT (ptr == input + m); /* OSF/1 5.1 */
898 ASSERT (errno == 0); /* MacOS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
904 char *input = malloc (m + 1);
910 memset (input + 1, '0', m - 9);
921 result = strtod (input, &ptr);
922 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 */
923 ASSERT (ptr == input + m);
924 ASSERT (errno == 0); /* MacOS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
931 char *input = malloc (m + 1);
940 memset (input + 4, '0', m - 3);
943 result = strtod (input, &ptr);
944 ASSERT (result == 0.0);
945 ASSERT (!!signbit (result) == !!signbit (-zero)); /* IRIX 6.5, OSF/1 4.0 */
946 ASSERT (ptr == input + m);
953 /* TODO - is it worth some tests of rounding for typical IEEE corner
954 cases, such as .5 ULP rounding up to the smallest denormal and
955 not causing underflow, or DBL_MIN - .5 ULP not causing an