2 * Copyright (C) 2008-2011 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"
31 #include "minus-zero.h"
34 /* Avoid requiring -lm just for fabs. */
35 #define FABS(d) ((d) < 0.0 ? -(d) : (d))
41 /* Subject sequence empty or invalid. */
43 const char input[] = "";
47 result = strtod (input, &ptr);
48 ASSERT (result == 0.0);
49 ASSERT (!signbit (result));
50 ASSERT (ptr == input);
51 ASSERT (errno == 0 || errno == EINVAL);
54 const char input[] = " ";
58 result = strtod (input, &ptr);
59 ASSERT (result == 0.0);
60 ASSERT (!signbit (result));
61 ASSERT (ptr == input);
62 ASSERT (errno == 0 || errno == EINVAL);
65 const char input[] = " +";
69 result = strtod (input, &ptr);
70 ASSERT (result == 0.0);
71 ASSERT (!signbit (result));
72 ASSERT (ptr == input);
73 ASSERT (errno == 0 || errno == EINVAL);
76 const char input[] = " .";
80 result = strtod (input, &ptr);
81 ASSERT (result == 0.0);
82 ASSERT (!signbit (result));
83 ASSERT (ptr == input);
84 ASSERT (errno == 0 || errno == EINVAL);
87 const char input[] = " .e0";
91 result = strtod (input, &ptr);
92 ASSERT (result == 0.0);
93 ASSERT (!signbit (result));
94 ASSERT (ptr == input); /* IRIX 6.5, OSF/1 5.1 */
95 ASSERT (errno == 0 || errno == EINVAL);
98 const char input[] = " +.e-0";
102 result = strtod (input, &ptr);
103 ASSERT (result == 0.0);
104 ASSERT (!signbit (result));
105 ASSERT (ptr == input); /* IRIX 6.5, OSF/1 5.1 */
106 ASSERT (errno == 0 || errno == EINVAL);
109 const char input[] = " in";
113 result = strtod (input, &ptr);
114 ASSERT (result == 0.0);
115 ASSERT (!signbit (result));
116 ASSERT (ptr == input);
117 ASSERT (errno == 0 || errno == EINVAL);
120 const char input[] = " na";
124 result = strtod (input, &ptr);
125 ASSERT (result == 0.0);
126 ASSERT (!signbit (result));
127 ASSERT (ptr == input);
128 ASSERT (errno == 0 || errno == EINVAL);
131 /* Simple floating point values. */
133 const char input[] = "1";
137 result = strtod (input, &ptr);
138 ASSERT (result == 1.0);
139 ASSERT (ptr == input + 1);
143 const char input[] = "1.";
147 result = strtod (input, &ptr);
148 ASSERT (result == 1.0);
149 ASSERT (ptr == input + 2);
153 const char input[] = ".5";
157 result = strtod (input, &ptr);
158 /* FIXME - gnulib's version is rather inaccurate. It would be
159 nice to guarantee an exact result, but for now, we settle for a
161 ASSERT (FABS (result - 0.5) < DBL_EPSILON);
162 ASSERT (ptr == input + 2);
166 const char input[] = " 1";
170 result = strtod (input, &ptr);
171 ASSERT (result == 1.0);
172 ASSERT (ptr == input + 2);
176 const char input[] = "+1";
180 result = strtod (input, &ptr);
181 ASSERT (result == 1.0);
182 ASSERT (ptr == input + 2);
186 const char input[] = "-1";
190 result = strtod (input, &ptr);
191 ASSERT (result == -1.0);
192 ASSERT (ptr == input + 2);
196 const char input[] = "1e0";
200 result = strtod (input, &ptr);
201 ASSERT (result == 1.0);
202 ASSERT (ptr == input + 3);
206 const char input[] = "1e+0";
210 result = strtod (input, &ptr);
211 ASSERT (result == 1.0);
212 ASSERT (ptr == input + 4);
216 const char input[] = "1e-0";
220 result = strtod (input, &ptr);
221 ASSERT (result == 1.0);
222 ASSERT (ptr == input + 4);
226 const char input[] = "1e1";
230 result = strtod (input, &ptr);
231 ASSERT (result == 10.0);
232 ASSERT (ptr == input + 3);
236 const char input[] = "5e-1";
240 result = strtod (input, &ptr);
241 /* FIXME - gnulib's version is rather inaccurate. It would be
242 nice to guarantee an exact result, but for now, we settle for a
244 ASSERT (FABS (result - 0.5) < DBL_EPSILON);
245 ASSERT (ptr == input + 4);
251 const char input[] = "0";
255 result = strtod (input, &ptr);
256 ASSERT (result == 0.0);
257 ASSERT (!signbit (result));
258 ASSERT (ptr == input + 1);
262 const char input[] = ".0";
266 result = strtod (input, &ptr);
267 ASSERT (result == 0.0);
268 ASSERT (!signbit (result));
269 ASSERT (ptr == input + 2);
273 const char input[] = "0e0";
277 result = strtod (input, &ptr);
278 ASSERT (result == 0.0);
279 ASSERT (!signbit (result));
280 ASSERT (ptr == input + 3);
284 const char input[] = "0e+9999999";
288 result = strtod (input, &ptr);
289 ASSERT (result == 0.0);
290 ASSERT (!signbit (result));
291 ASSERT (ptr == input + 10);
295 const char input[] = "0e-9999999";
299 result = strtod (input, &ptr);
300 ASSERT (result == 0.0);
301 ASSERT (!signbit (result));
302 ASSERT (ptr == input + 10);
306 const char input[] = "-0";
310 result = strtod (input, &ptr);
311 ASSERT (result == 0.0);
312 ASSERT (!!signbit (result) == !!signbit (minus_zerod)); /* IRIX 6.5, OSF/1 4.0 */
313 ASSERT (ptr == input + 2);
319 const char input[] = "1f";
323 result = strtod (input, &ptr);
324 ASSERT (result == 1.0);
325 ASSERT (ptr == input + 1);
329 const char input[] = "1.f";
333 result = strtod (input, &ptr);
334 ASSERT (result == 1.0);
335 ASSERT (ptr == input + 2);
339 const char input[] = "1e";
343 result = strtod (input, &ptr);
344 ASSERT (result == 1.0);
345 ASSERT (ptr == input + 1);
349 const char input[] = "1e+";
353 result = strtod (input, &ptr);
354 ASSERT (result == 1.0);
355 ASSERT (ptr == input + 1);
359 const char input[] = "1e-";
363 result = strtod (input, &ptr);
364 ASSERT (result == 1.0);
365 ASSERT (ptr == input + 1);
369 const char input[] = "1E 2";
373 result = strtod (input, &ptr);
374 ASSERT (result == 1.0); /* HP-UX 11.11, IRIX 6.5, OSF/1 4.0 */
375 ASSERT (ptr == input + 1); /* HP-UX 11.11, IRIX 6.5 */
379 const char input[] = "0x";
383 result = strtod (input, &ptr);
384 ASSERT (result == 0.0);
385 ASSERT (!signbit (result));
386 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, AIX 7.1 */
390 const char input[] = "00x1";
394 result = strtod (input, &ptr);
395 ASSERT (result == 0.0);
396 ASSERT (!signbit (result));
397 ASSERT (ptr == input + 2);
401 const char input[] = "-0x";
405 result = strtod (input, &ptr);
406 ASSERT (result == 0.0);
407 ASSERT (!!signbit (result) == !!signbit (minus_zerod)); /* MacOS X 10.3, FreeBSD 6.2, IRIX 6.5, OSF/1 4.0 */
408 ASSERT (ptr == input + 2); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, AIX 7.1 */
412 const char input[] = "0xg";
416 result = strtod (input, &ptr);
417 ASSERT (result == 0.0);
418 ASSERT (!signbit (result));
419 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, AIX 7.1 */
423 const char input[] = "0xp";
427 result = strtod (input, &ptr);
428 ASSERT (result == 0.0);
429 ASSERT (!signbit (result));
430 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, AIX 7.1 */
434 const char input[] = "0XP";
438 result = strtod (input, &ptr);
439 ASSERT (result == 0.0);
440 ASSERT (!signbit (result));
441 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, AIX 7.1 */
445 const char input[] = "0x.";
449 result = strtod (input, &ptr);
450 ASSERT (result == 0.0);
451 ASSERT (!signbit (result));
452 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, AIX 7.1 */
456 const char input[] = "0xp+";
460 result = strtod (input, &ptr);
461 ASSERT (result == 0.0);
462 ASSERT (!signbit (result));
463 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, AIX 7.1 */
467 const char input[] = "0xp+1";
471 result = strtod (input, &ptr);
472 ASSERT (result == 0.0);
473 ASSERT (!signbit (result));
474 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, AIX 7.1 */
478 const char input[] = "0x.p+1";
482 result = strtod (input, &ptr);
483 ASSERT (result == 0.0);
484 ASSERT (!signbit (result));
485 ASSERT (ptr == input + 1); /* glibc-2.3.6, MacOS X 10.3, FreeBSD 6.2, AIX 7.1 */
489 const char input[] = "1p+1";
493 result = strtod (input, &ptr);
494 ASSERT (result == 1.0);
495 ASSERT (ptr == input + 1);
499 const char input[] = "1P+1";
503 result = strtod (input, &ptr);
504 ASSERT (result == 1.0);
505 ASSERT (ptr == input + 1);
509 /* Overflow/underflow. */
511 const char input[] = "1E1000000";
515 result = strtod (input, &ptr);
516 ASSERT (result == HUGE_VAL);
517 ASSERT (ptr == input + 9); /* OSF/1 5.1 */
518 ASSERT (errno == ERANGE);
521 const char input[] = "-1E1000000";
525 result = strtod (input, &ptr);
526 ASSERT (result == -HUGE_VAL);
527 ASSERT (ptr == input + 10);
528 ASSERT (errno == ERANGE);
531 const char input[] = "1E-100000";
535 result = strtod (input, &ptr);
536 ASSERT (0.0 <= result && result <= DBL_MIN);
537 ASSERT (!signbit (result));
538 ASSERT (ptr == input + 9);
539 ASSERT (errno == ERANGE);
542 const char input[] = "-1E-100000";
546 result = strtod (input, &ptr);
547 ASSERT (-DBL_MIN <= result && result <= 0.0);
549 /* FIXME - this is glibc bug 5995; POSIX allows returning positive
550 0 on negative underflow, even though quality of implementation
551 demands preserving the sign. Disable this test until fixed
552 glibc is more prevalent. */
553 ASSERT (!!signbit (result) == !!signbit (minus_zerod)); /* glibc-2.3.6, mingw */
555 ASSERT (ptr == input + 10);
556 ASSERT (errno == ERANGE);
559 const char input[] = "1E 1000000";
563 result = strtod (input, &ptr);
564 ASSERT (result == 1.0); /* HP-UX 11.11, IRIX 6.5, OSF/1 4.0 */
565 ASSERT (ptr == input + 1); /* HP-UX 11.11, IRIX 6.5 */
569 const char input[] = "0x1P 1000000";
573 result = strtod (input, &ptr);
574 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 */
575 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 */
581 const char input[] = "iNf";
585 result = strtod (input, &ptr);
586 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
587 ASSERT (ptr == input + 3); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
588 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
591 const char input[] = "-InF";
595 result = strtod (input, &ptr);
596 ASSERT (result == -HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
597 ASSERT (ptr == input + 4); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 4.0, Solaris 9, mingw */
598 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
601 const char input[] = "infinite";
605 result = strtod (input, &ptr);
606 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
607 ASSERT (ptr == input + 3); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
608 ASSERT (errno == 0); /* OSF/1 4.0 */
611 const char input[] = "infinitY";
615 result = strtod (input, &ptr);
616 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
617 ASSERT (ptr == input + 8); /* OpenBSD 4.0, HP-UX 11.00, IRIX 6.5, OSF/1 5.1, Solaris 9, mingw */
618 ASSERT (errno == 0); /* HP-UX 11.11, OSF/1 4.0 */
621 const char input[] = "infinitY.";
625 result = strtod (input, &ptr);
626 ASSERT (result == HUGE_VAL); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
627 ASSERT (ptr == input + 8); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
628 ASSERT (errno == 0); /* OSF/1 4.0 */
631 /* NaN. Some processors set the sign bit of the default NaN, so all
632 we check is that using a sign changes the result. */
634 const char input[] = "-nan";
640 result1 = strtod (input, &ptr1);
641 result2 = strtod (input + 1, &ptr2);
642 #if 1 /* All known CPUs support NaNs. */
643 ASSERT (isnand (result1)); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
644 ASSERT (isnand (result2)); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
646 /* Sign bits of NaN is a portability sticking point, not worth
648 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
650 ASSERT (ptr1 == input + 4); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
651 ASSERT (ptr2 == input + 4); /* OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
652 ASSERT (errno == 0); /* HP-UX 11.11 */
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 */
675 ASSERT (!!signbit (result1) == !!signbit (result2));
676 ASSERT (ptr1 == input + 4); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
677 ASSERT (ptr2 == input + 4); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, Solaris 2.5.1, mingw */
680 ASSERT (result1 == 0.0);
681 ASSERT (result2 == 0.0);
682 ASSERT (!signbit (result1));
683 ASSERT (!signbit (result2));
684 ASSERT (ptr1 == input);
685 ASSERT (ptr2 == input + 1);
686 ASSERT (errno == 0 || errno == EINVAL);
690 const char input[] = "-nan()";
696 result1 = strtod (input, &ptr1);
697 result2 = strtod (input + 1, &ptr2);
698 #if 1 /* All known CPUs support NaNs. */
699 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
700 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
702 /* Sign bits of NaN is a portability sticking point, not worth
704 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
706 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 */
707 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 */
710 ASSERT (result1 == 0.0);
711 ASSERT (result2 == 0.0);
712 ASSERT (!signbit (result1));
713 ASSERT (!signbit (result2));
714 ASSERT (ptr1 == input);
715 ASSERT (ptr2 == input + 1);
716 ASSERT (errno == 0 || errno == EINVAL);
720 const char input[] = " nan().";
724 result = strtod (input, &ptr);
725 #if 1 /* All known CPUs support NaNs. */
726 ASSERT (isnand (result)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
727 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 */
730 ASSERT (result == 0.0);
731 ASSERT (!signbit (result));
732 ASSERT (ptr == input);
733 ASSERT (errno == 0 || errno == EINVAL);
737 /* The behavior of nan(0) is implementation-defined, but all
738 implementations we know of which handle optional
739 n-char-sequences handle nan(0) the same as nan(). */
740 const char input[] = "-nan(0).";
746 result1 = strtod (input, &ptr1);
747 result2 = strtod (input + 1, &ptr2);
748 #if 1 /* All known CPUs support NaNs. */
749 ASSERT (isnand (result1)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
750 ASSERT (isnand (result2)); /* OpenBSD 4.0, HP-UX 11.11, IRIX 6.5, OSF/1 5.1, mingw */
752 /* Sign bits of NaN is a portability sticking point, not worth
754 ASSERT (!!signbit (result1) != !!signbit (result2)); /* glibc-2.3.6, IRIX 6.5, OSF/1 5.1, mingw */
756 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 */
757 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 */
760 ASSERT (result1 == 0.0);
761 ASSERT (result2 == 0.0);
762 ASSERT (!signbit (result1));
763 ASSERT (!signbit (result2));
764 ASSERT (ptr1 == input);
765 ASSERT (ptr2 == input + 1);
766 ASSERT (errno == 0 || errno == EINVAL);
772 const char input[] = "0xa";
776 result = strtod (input, &ptr);
777 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 */
778 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 */
782 const char input[] = "0XA";
786 result = strtod (input, &ptr);
787 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 */
788 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 */
792 const char input[] = "0x1p";
796 result = strtod (input, &ptr);
797 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 */
798 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 */
802 const char input[] = "0x1p+";
806 result = strtod (input, &ptr);
807 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 */
808 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 */
812 const char input[] = "0x1P+";
816 result = strtod (input, &ptr);
817 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 */
818 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 */
822 const char input[] = "0x1p+1";
826 result = strtod (input, &ptr);
827 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 */
828 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 */
832 const char input[] = "0X1P+1";
836 result = strtod (input, &ptr);
837 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 */
838 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 */
842 const char input[] = "0x1p+1a";
846 result = strtod (input, &ptr);
847 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 */
848 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 */
852 const char input[] = "0x1p 2";
856 result = strtod (input, &ptr);
857 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 */
858 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 */
865 char *input = malloc (m + 1);
870 memset (input, '\t', m - 1);
874 result = strtod (input, &ptr);
875 ASSERT (result == 1.0);
876 ASSERT (ptr == input + m);
883 char *input = malloc (m + 1);
888 memset (input, '0', m - 1);
892 result = strtod (input, &ptr);
893 ASSERT (result == 1.0);
894 ASSERT (ptr == input + m);
900 /* Newlib has an artificial limit of 20000 for the exponent. TODO -
901 gnulib should fix this. */
904 char *input = malloc (m + 1);
910 memset (input + 1, '0', m - 10);
922 result = strtod (input, &ptr);
923 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 */
924 ASSERT (ptr == input + m); /* OSF/1 5.1 */
925 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);
937 memset (input + 1, '0', m - 9);
948 result = strtod (input, &ptr);
949 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 */
950 ASSERT (ptr == input + m);
951 ASSERT (errno == 0); /* MacOS X 10.3, FreeBSD 6.2, NetBSD 3.0, OpenBSD 4.0, IRIX 6.5, OSF/1 5.1, mingw */
958 char *input = malloc (m + 1);
967 memset (input + 4, '0', m - 3);
970 result = strtod (input, &ptr);
971 ASSERT (result == 0.0);
972 ASSERT (!!signbit (result) == !!signbit (minus_zerod)); /* IRIX 6.5, OSF/1 4.0 */
973 ASSERT (ptr == input + m);
980 /* TODO - is it worth some tests of rounding for typical IEEE corner
981 cases, such as .5 ULP rounding up to the smallest denormal and
982 not causing underflow, or DBL_MIN - .5 ULP not causing an