2 * Copyright (C) 2008-2017 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, Mac OS 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
)); /* Mac OS X 10.3, FreeBSD 6.2, IRIX 6.5, OSF/1 4.0 */
408 ASSERT (ptr
== input
+ 2); /* glibc-2.3.6, Mac OS 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, Mac OS 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, Mac OS 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, Mac OS 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, Mac OS 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, Mac OS 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, Mac OS 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, Mac OS 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, Mac OS 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, Mac OS 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, Mac OS 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); /* Mac OS 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); /* Mac OS 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); /* Mac OS 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); /* Mac OS 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