octave-lojdl/gnulib-hg: tests/test-vasprintf-posix.c annotate

annotate tests/test-vasprintf-posix.c @ 16935:498a2211d839

Write "Mac OS X" instead of "MacOS X". * README: Write "Mac OS X" instead of "MacOS X". * build-aux/bootstrap: Likewise. * build-aux/install-reloc: Likewise. * lib/acl-internal.h: Likewise. * lib/acl_entries.c: Likewise. * lib/argp-ba.c: Likewise. * lib/argp-pv.c: Likewise. * lib/config.charset: Likewise. * lib/copy-acl.c: Likewise. * lib/csharpexec.c: Likewise. * lib/euidaccess.c: Likewise. * lib/fbufmode.c: Likewise. * lib/fflush.c: Likewise. * lib/file-has-acl.c: Likewise. * lib/filemode.h: Likewise. * lib/fpurge.c: Likewise. * lib/freadable.c: Likewise. * lib/freadahead.c: Likewise. * lib/freading.c: Likewise. * lib/freadptr.c: Likewise. * lib/freadseek.c: Likewise. * lib/fseeko.c: Likewise. * lib/fseterr.c: Likewise. * lib/fsusage.c: Likewise. * lib/fwritable.c: Likewise. * lib/fwriting.c: Likewise. * lib/get-rusage-as.c: Likewise. * lib/get-rusage-data.c: Likewise. * lib/getdomainname.c: Likewise. * lib/idpriv-drop.c: Likewise. * lib/idpriv-droptemp.c: Likewise. * lib/localcharset.c: Likewise. * lib/locale.in.h: Likewise. * lib/localename.c: Likewise. * lib/mbsrtowcs-state.c: Likewise. * lib/nproc.c: Likewise. * lib/passfd.c: Likewise. * lib/posix_openpt.c: Likewise. * lib/printf-parse.c: Likewise. * lib/progreloc.c: Likewise. * lib/safe-read.h: Likewise. * lib/safe-write.h: Likewise. * lib/sched.in.h: Likewise. * lib/set-mode-acl.c: Likewise. * lib/signal.in.h: Likewise. * lib/stdint.in.h: Likewise. * lib/stdio-impl.h: Likewise. * lib/stdlib.in.h: Likewise. * lib/strtod.c: Likewise. * lib/sys_select.in.h: Likewise. * lib/tcgetsid.c: Likewise. * lib/unistd.in.h: Likewise. * lib/unlockpt.c: Likewise. * lib/vasnprintf.c: Likewise. * lib/vma-iter.c: Likewise. * lib/wcsrtombs-state.c: Likewise. * m4/acl.m4: Likewise. * m4/acosl.m4: Likewise. * m4/asinl.m4: Likewise. * m4/atanl.m4: Likewise. * m4/c-stack.m4: Likewise. * m4/cosl.m4: Likewise. * m4/expl.m4: Likewise. * m4/extensions.m4: Likewise. * m4/fdatasync.m4: Likewise. * m4/fmal.m4: Likewise. * m4/frexp.m4: Likewise. * m4/frexpf.m4: Likewise. * m4/frexpl.m4: Likewise. * m4/fsusage.m4: Likewise. * m4/getdomainname.m4: Likewise. * m4/getloadavg.m4: Likewise. * m4/getopt.m4: Likewise. * m4/gettext.m4: Likewise. * m4/gnulib-common.m4: Likewise. * m4/intdiv0.m4: Likewise. * m4/intlmacosx.m4: Likewise. * m4/largefile.m4: Likewise. * m4/ldexpl.m4: Likewise. * m4/link-follow.m4: Likewise. * m4/locale-ar.m4: Likewise. * m4/locale-fr.m4: Likewise. * m4/locale-ja.m4: Likewise. * m4/locale-tr.m4: Likewise. * m4/locale-zh.m4: Likewise. * m4/locale_h.m4: Likewise. * m4/lock.m4: Likewise. * m4/logl.m4: Likewise. * m4/mathfunc.m4: Likewise. * m4/minus-zero.m4: Likewise. * m4/mktime.m4: Likewise. * m4/mmap-anon.m4: Likewise. * m4/multiarch.m4: Likewise. * m4/nanosleep.m4: Likewise. * m4/nocrash.m4: Likewise. * m4/poll.m4: Likewise. * m4/printf-frexpl.m4: Likewise. * m4/printf.m4: Likewise. * m4/signbit.m4: Likewise. * m4/sinl.m4: Likewise. * m4/sqrtl.m4: Likewise. * m4/strerror_r.m4: Likewise. * m4/tanl.m4: Likewise. * m4/threadlib.m4: Likewise. * m4/ttyname_r.m4: Likewise. * m4/unlink.m4: Likewise. * m4/visibility.m4: Likewise. * m4/wcwidth.m4: Likewise. * tests/minus-zero.h: Likewise. * tests/test-alloca-opt.c: Likewise. * tests/test-copy-acl.sh: Likewise. * tests/test-copy-file.sh: Likewise. * tests/test-fdatasync.c: Likewise. * tests/test-file-has-acl.sh: Likewise. * tests/test-flock.c: Likewise. * tests/test-fsync.c: Likewise. * tests/test-localename.c: Likewise. * tests/test-malloca.c: Likewise. * tests/test-nonblocking-pipe.h: Likewise. * tests/test-nonblocking-socket.h: Likewise. * tests/test-openpty.c: Likewise. * tests/test-posix_openpt.c: Likewise. * tests/test-ptsname.c: Likewise. * tests/test-ptsname_r.c: Likewise. * tests/test-sameacls.c: Likewise. * tests/test-select.h: Likewise. * tests/test-set-mode-acl.sh: Likewise. * tests/test-snprintf-posix.h: Likewise. * tests/test-sprintf-posix.h: Likewise. * tests/test-strtod.c: Likewise. * tests/test-time.c: Likewise. * tests/test-vasnprintf-posix.c: Likewise. * tests/test-vasprintf-posix.c: Likewise. * doc/acl-resources.txt: Likewise. * doc/**/*.texi: Likewise. Reported by Max Horn <max@quendi.de>.

author	Bruno Haible <bruno@clisp.org>
date	Fri, 22 Jun 2012 13:26:07 +0200
parents	8250f2777afc
children	e542fd46ad6f

rev	line source
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	1 /* Test of POSIX compatible vasprintf() and asprintf() functions.
16201 8250f2777afc maint: update all copyright year number ranges Jim Meyering <meyering@redhat.com> parents: 15906 diff changeset	2 Copyright (C) 2007-2012 Free Software Foundation, Inc.
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3
9309 bbbbbf4cd1c5 Change copyright notice from GPLv2+ to GPLv3+. Bruno Haible <bruno@clisp.org> parents: 8919 diff changeset	4 This program is free software: you can redistribute it and/or modify
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	5 it under the terms of the GNU General Public License as published by
9309 bbbbbf4cd1c5 Change copyright notice from GPLv2+ to GPLv3+. Bruno Haible <bruno@clisp.org> parents: 8919 diff changeset	6 the Free Software Foundation; either version 3 of the License, or
bbbbbf4cd1c5 Change copyright notice from GPLv2+ to GPLv3+. Bruno Haible <bruno@clisp.org> parents: 8919 diff changeset	7 (at your option) any later version.
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	8
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	9 This program is distributed in the hope that it will be useful,
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	10 but WITHOUT ANY WARRANTY; without even the implied warranty of
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	12 GNU General Public License for more details.
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	13
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	14 You should have received a copy of the GNU General Public License
9309 bbbbbf4cd1c5 Change copyright notice from GPLv2+ to GPLv3+. Bruno Haible <bruno@clisp.org> parents: 8919 diff changeset	15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	16
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	17 /* Written by Bruno Haible <bruno@clisp.org>, 2007. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	18
8891 633babea5f62 Unconditionally include <config.h> in unit tests. Eric Blake <ebb9@byu.net> parents: 8870 diff changeset	19 #include <config.h>
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	20
8570 4175c39ba7cc Move vasprintf prototypes to stdio. Simon Josefsson <simon@josefsson.org> parents: 8543 diff changeset	21 #include <stdio.h>
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	22
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	23 #include <float.h>
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	24 #include <stdarg.h>
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	25 #include <stddef.h>
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	26 #include <stdint.h>
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	27 #include <stdlib.h>
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	28 #include <string.h>
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	29
12496 a48d3d749ca5 Refactor common macros used in tests. Bruno Haible <bruno@clisp.org> parents: 12421 diff changeset	30 #include "macros.h"
13834 108bbfd6f03b frexp, tests: work around ICC bug with -zero Eric Blake <eblake@redhat.com> parents: 12559 diff changeset	31 #include "minus-zero.h"
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	32 #include "infinity.h"
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	33 #include "nan.h"
baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	34
8852 df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	35 /* The SGI MIPS floating-point format does not distinguish 0.0 and -0.0. */
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	36 static int
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	37 have_minus_zero ()
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	38 {
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	39 static double plus_zero = 0.0;
13834 108bbfd6f03b frexp, tests: work around ICC bug with -zero Eric Blake <eblake@redhat.com> parents: 12559 diff changeset	40 double minus_zero = minus_zerod;
8852 df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	41 return memcmp (&plus_zero, &minus_zero, sizeof (double)) != 0;
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	42 }
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	43
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	44 /* Representation of an 80-bit 'long double' as an initializer for a sequence
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	45 of 'unsigned int' words. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	46 #ifdef WORDS_BIGENDIAN
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	47 # define LDBL80_WORDS(exponent,manthi,mantlo) \
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	48 { ((unsigned int) (exponent) << 16) \| ((unsigned int) (manthi) >> 16), \
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	49 ((unsigned int) (manthi) << 16) \| (unsigned int) (mantlo) >> 16), \
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	50 (unsigned int) (mantlo) << 16 \
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	51 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	52 #else
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	53 # define LDBL80_WORDS(exponent,manthi,mantlo) \
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	54 { mantlo, manthi, exponent }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	55 #endif
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	56
8834 4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	57 static int
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	58 strmatch (const char pattern, const char string)
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	59 {
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	60 if (strlen (pattern) != strlen (string))
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	61 return 0;
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	62 for (; *pattern != '\0'; pattern++, string++)
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	63 if (pattern != '' && string != pattern)
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	64 return 0;
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	65 return 1;
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	66 }
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	67
8865 9e203d8ade65 Stricter check for printf result for NaN arguments. Bruno Haible <bruno@clisp.org> parents: 8857 diff changeset	68 /* Test whether string[start_index..end_index-1] is a valid textual
9e203d8ade65 Stricter check for printf result for NaN arguments. Bruno Haible <bruno@clisp.org> parents: 8857 diff changeset	69 representation of NaN. */
9e203d8ade65 Stricter check for printf result for NaN arguments. Bruno Haible <bruno@clisp.org> parents: 8857 diff changeset	70 static int
9e203d8ade65 Stricter check for printf result for NaN arguments. Bruno Haible <bruno@clisp.org> parents: 8857 diff changeset	71 strisnan (const char *string, size_t start_index, size_t end_index, int uppercase)
9e203d8ade65 Stricter check for printf result for NaN arguments. Bruno Haible <bruno@clisp.org> parents: 8857 diff changeset	72 {
9e203d8ade65 Stricter check for printf result for NaN arguments. Bruno Haible <bruno@clisp.org> parents: 8857 diff changeset	73 if (start_index < end_index)
9e203d8ade65 Stricter check for printf result for NaN arguments. Bruno Haible <bruno@clisp.org> parents: 8857 diff changeset	74 {
9e203d8ade65 Stricter check for printf result for NaN arguments. Bruno Haible <bruno@clisp.org> parents: 8857 diff changeset	75 if (string[start_index] == '-')
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	76 start_index++;
8865 9e203d8ade65 Stricter check for printf result for NaN arguments. Bruno Haible <bruno@clisp.org> parents: 8857 diff changeset	77 if (start_index + 3 <= end_index
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	78 && memcmp (string + start_index, uppercase ? "NAN" : "nan", 3) == 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	79 {
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	80 start_index += 3;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	81 if (start_index == end_index
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	82 \|\| (string[start_index] == '(' && string[end_index - 1] == ')'))
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	83 return 1;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	84 }
8865 9e203d8ade65 Stricter check for printf result for NaN arguments. Bruno Haible <bruno@clisp.org> parents: 8857 diff changeset	85 }
9e203d8ade65 Stricter check for printf result for NaN arguments. Bruno Haible <bruno@clisp.org> parents: 8857 diff changeset	86 return 0;
9e203d8ade65 Stricter check for printf result for NaN arguments. Bruno Haible <bruno@clisp.org> parents: 8857 diff changeset	87 }
9850 7f3ed6b093be Guarantee a definition of NAN. Eric Blake <ebb9@byu.net> parents: 9674 diff changeset	88
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	89 static void
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	90 test_function (int (my_asprintf) (char , const char , ...))
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	91 {
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	92 int repeat;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	93
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	94 /* Test return value convention. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	95
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	96 for (repeat = 0; repeat <= 8; repeat++)
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	97 {
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	98 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	99 int retval = asprintf (&result, "%d", 12345);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	100 ASSERT (retval == 5);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	101 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	102 ASSERT (strcmp (result, "12345") == 0);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	103 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	104 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	105
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	106 /* Test support of size specifiers as in C99. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	107
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	108 {
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	109 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	110 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	111 my_asprintf (&result, "%ju %d", (uintmax_t) 12345671, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	112 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	113 ASSERT (strcmp (result, "12345671 33") == 0);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	114 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	115 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	116 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	117
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	118 {
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	119 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	120 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	121 my_asprintf (&result, "%zu %d", (size_t) 12345672, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	122 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	123 ASSERT (strcmp (result, "12345672 33") == 0);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	124 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	125 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	126 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	127
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	128 {
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	129 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	130 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	131 my_asprintf (&result, "%tu %d", (ptrdiff_t) 12345673, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	132 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	133 ASSERT (strcmp (result, "12345673 33") == 0);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	134 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	135 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	136 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	137
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	138 {
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	139 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	140 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	141 my_asprintf (&result, "%Lg %d", (long double) 1.5, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	142 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	143 ASSERT (strcmp (result, "1.5 33") == 0);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	144 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	145 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	146 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	147
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	148 /* Test the support of the 'a' and 'A' conversion specifier for hexadecimal
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	149 output of floating-point numbers. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	150
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	151 { /* A positive number. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	152 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	153 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	154 my_asprintf (&result, "%a %d", 3.1416015625, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	155 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	156 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	157 \|\| strcmp (result, "0x3.244p+0 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	158 \|\| strcmp (result, "0x6.488p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	159 \|\| strcmp (result, "0xc.91p-2 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	160 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	161 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	162 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	163
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	164 { /* A negative number. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	165 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	166 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	167 my_asprintf (&result, "%A %d", -3.1416015625, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	168 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	169 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	170 \|\| strcmp (result, "-0X3.244P+0 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	171 \|\| strcmp (result, "-0X6.488P-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	172 \|\| strcmp (result, "-0XC.91P-2 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	173 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	174 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	175 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	176
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	177 { /* Positive zero. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	178 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	179 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	180 my_asprintf (&result, "%a %d", 0.0, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	181 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	182 ASSERT (strcmp (result, "0x0p+0 33") == 0);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	183 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	184 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	185 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	186
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	187 { /* Negative zero. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	188 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	189 int retval =
13834 108bbfd6f03b frexp, tests: work around ICC bug with -zero Eric Blake <eblake@redhat.com> parents: 12559 diff changeset	190 my_asprintf (&result, "%a %d", minus_zerod, 33, 44, 55);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	191 ASSERT (result != NULL);
8852 df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	192 if (have_minus_zero ())
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	193 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	194 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	195 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	196 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	197
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	198 { /* Positive infinity. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	199 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	200 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	201 my_asprintf (&result, "%a %d", Infinityd (), 33, 44, 55);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	202 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	203 ASSERT (strcmp (result, "inf 33") == 0);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	204 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	205 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	206 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	207
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	208 { /* Negative infinity. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	209 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	210 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	211 my_asprintf (&result, "%a %d", - Infinityd (), 33, 44, 55);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	212 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	213 ASSERT (strcmp (result, "-inf 33") == 0);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	214 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	215 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	216 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	217
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	218 { /* NaN. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	219 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	220 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	221 my_asprintf (&result, "%a %d", NaNd (), 33, 44, 55);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	222 ASSERT (result != NULL);
8850 d1fe16dfbfee Avoid test failures on IRIX 6.5. Bruno Haible <bruno@clisp.org> parents: 8839 diff changeset	223 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	224 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	225 && strcmp (result + strlen (result) - 3, " 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	226 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	227 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	228 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	229
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	230 { /* Rounding near the decimal point. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	231 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	232 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	233 my_asprintf (&result, "%.0a %d", 1.5, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	234 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	235 ASSERT (strcmp (result, "0x2p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	236 \|\| strcmp (result, "0x3p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	237 \|\| strcmp (result, "0x6p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	238 \|\| strcmp (result, "0xcp-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	239 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	240 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	241 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	242
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	243 { /* Rounding with precision 0. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	244 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	245 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	246 my_asprintf (&result, "%.0a %d", 1.51, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	247 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	248 ASSERT (strcmp (result, "0x2p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	249 \|\| strcmp (result, "0x3p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	250 \|\| strcmp (result, "0x6p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	251 \|\| strcmp (result, "0xcp-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	252 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	253 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	254 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	255
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	256 { /* Rounding with precision 1. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	257 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	258 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	259 my_asprintf (&result, "%.1a %d", 1.51, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	260 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	261 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	262 \|\| strcmp (result, "0x3.0p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	263 \|\| strcmp (result, "0x6.1p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	264 \|\| strcmp (result, "0xc.1p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	265 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	266 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	267 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	268
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	269 { /* Rounding with precision 2. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	270 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	271 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	272 my_asprintf (&result, "%.2a %d", 1.51, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	273 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	274 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	275 \|\| strcmp (result, "0x3.05p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	276 \|\| strcmp (result, "0x6.0ap-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	277 \|\| strcmp (result, "0xc.14p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	278 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	279 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	280 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	281
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	282 { /* Rounding with precision 3. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	283 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	284 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	285 my_asprintf (&result, "%.3a %d", 1.51, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	286 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	287 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	288 \|\| strcmp (result, "0x3.052p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	289 \|\| strcmp (result, "0x6.0a4p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	290 \|\| strcmp (result, "0xc.148p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	291 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	292 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	293 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	294
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	295 { /* Rounding can turn a ...FFF into a ...000. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	296 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	297 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	298 my_asprintf (&result, "%.3a %d", 1.49999, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	299 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	300 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	301 \|\| strcmp (result, "0x3.000p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	302 \|\| strcmp (result, "0x6.000p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	303 \|\| strcmp (result, "0xc.000p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	304 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	305 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	306 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	307
8344 c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	308 { /* Rounding can turn a ...FFF into a ...000.
16935 498a2211d839 Write "Mac OS X" instead of "MacOS X". Bruno Haible <bruno@clisp.org> parents: 16201 diff changeset	309 This shows a Mac OS X 10.3.9 (Darwin 7.9) bug. */
8344 c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	310 char *result;
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	311 int retval =
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	312 my_asprintf (&result, "%.1a %d", 1.999, 33, 44, 55);
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	313 ASSERT (result != NULL);
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	314 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	315 \|\| strcmp (result, "0x2.0p+0 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	316 \|\| strcmp (result, "0x4.0p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	317 \|\| strcmp (result, "0x8.0p-2 33") == 0);
8344 c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	318 ASSERT (retval == strlen (result));
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	319 free (result);
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	320 }
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	321
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	322 { /* Width. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	323 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	324 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	325 my_asprintf (&result, "%10a %d", 1.75, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	326 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	327 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	328 \|\| strcmp (result, " 0x3.8p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	329 \|\| strcmp (result, " 0x7p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	330 \|\| strcmp (result, " 0xep-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	331 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	332 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	333 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	334
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	335 { /* Small precision. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	336 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	337 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	338 my_asprintf (&result, "%.10a %d", 1.75, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	339 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	340 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	341 \|\| strcmp (result, "0x3.8000000000p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	342 \|\| strcmp (result, "0x7.0000000000p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	343 \|\| strcmp (result, "0xe.0000000000p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	344 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	345 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	346 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	347
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	348 { /* Large precision. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	349 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	350 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	351 my_asprintf (&result, "%.50a %d", 1.75, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	352 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	353 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	354 \|\| strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	355 \|\| strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	356 \|\| strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	357 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	358 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	359 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	360
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	361 { /* FLAG_LEFT. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	362 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	363 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	364 my_asprintf (&result, "%-10a %d", 1.75, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	365 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	366 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	367 \|\| strcmp (result, "0x3.8p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	368 \|\| strcmp (result, "0x7p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	369 \|\| strcmp (result, "0xep-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	370 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	371 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	372 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	373
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	374 { /* FLAG_SHOWSIGN. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	375 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	376 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	377 my_asprintf (&result, "%+a %d", 1.75, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	378 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	379 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	380 \|\| strcmp (result, "+0x3.8p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	381 \|\| strcmp (result, "+0x7p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	382 \|\| strcmp (result, "+0xep-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	383 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	384 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	385 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	386
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	387 { /* FLAG_SPACE. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	388 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	389 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	390 my_asprintf (&result, "% a %d", 1.75, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	391 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	392 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	393 \|\| strcmp (result, " 0x3.8p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	394 \|\| strcmp (result, " 0x7p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	395 \|\| strcmp (result, " 0xep-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	396 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	397 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	398 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	399
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	400 { /* FLAG_ALT. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	401 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	402 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	403 my_asprintf (&result, "%#a %d", 1.75, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	404 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	405 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	406 \|\| strcmp (result, "0x3.8p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	407 \|\| strcmp (result, "0x7.p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	408 \|\| strcmp (result, "0xe.p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	409 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	410 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	411 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	412
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	413 { /* FLAG_ALT. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	414 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	415 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	416 my_asprintf (&result, "%#a %d", 1.0, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	417 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	418 ASSERT (strcmp (result, "0x1.p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	419 \|\| strcmp (result, "0x2.p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	420 \|\| strcmp (result, "0x4.p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	421 \|\| strcmp (result, "0x8.p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	422 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	423 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	424 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	425
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	426 { /* FLAG_ZERO with finite number. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	427 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	428 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	429 my_asprintf (&result, "%010a %d", 1.75, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	430 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	431 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	432 \|\| strcmp (result, "0x003.8p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	433 \|\| strcmp (result, "0x00007p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	434 \|\| strcmp (result, "0x0000ep-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	435 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	436 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	437 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	438
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	439 { /* FLAG_ZERO with infinite number. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	440 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	441 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	442 my_asprintf (&result, "%010a %d", Infinityd (), 33, 44, 55);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	443 ASSERT (result != NULL);
8662 023aa5c883a7 Guard against FreeBSD 6.1 bug. Bruno Haible <bruno@clisp.org> parents: 8648 diff changeset	444 /* "0000000inf 33" is not a valid result; see
023aa5c883a7 Guard against FreeBSD 6.1 bug. Bruno Haible <bruno@clisp.org> parents: 8648 diff changeset	445 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
023aa5c883a7 Guard against FreeBSD 6.1 bug. Bruno Haible <bruno@clisp.org> parents: 8648 diff changeset	446 ASSERT (strcmp (result, " inf 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	447 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	448 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	449 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	450
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	451 { /* FLAG_ZERO with NaN. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	452 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	453 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	454 my_asprintf (&result, "%050a %d", NaNd (), 33, 44, 55);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	455 ASSERT (result != NULL);
8662 023aa5c883a7 Guard against FreeBSD 6.1 bug. Bruno Haible <bruno@clisp.org> parents: 8648 diff changeset	456 /* "0000000nan 33" is not a valid result; see
023aa5c883a7 Guard against FreeBSD 6.1 bug. Bruno Haible <bruno@clisp.org> parents: 8648 diff changeset	457 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
8870 4e1f2ea486b4 Allow for a longer printed representation of NaN. Bruno Haible <bruno@clisp.org> parents: 8865 diff changeset	458 ASSERT (strlen (result) == 50 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	459 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	460 && strcmp (result + strlen (result) - 3, " 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	461 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	462 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	463 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	464
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	465 { /* A positive number. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	466 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	467 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	468 my_asprintf (&result, "%La %d", 3.1416015625L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	469 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	470 ASSERT (strcmp (result, "0x1.922p+1 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	471 \|\| strcmp (result, "0x3.244p+0 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	472 \|\| strcmp (result, "0x6.488p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	473 \|\| strcmp (result, "0xc.91p-2 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	474 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	475 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	476 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	477
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	478 { /* A negative number. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	479 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	480 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	481 my_asprintf (&result, "%LA %d", -3.1416015625L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	482 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	483 ASSERT (strcmp (result, "-0X1.922P+1 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	484 \|\| strcmp (result, "-0X3.244P+0 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	485 \|\| strcmp (result, "-0X6.488P-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	486 \|\| strcmp (result, "-0XC.91P-2 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	487 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	488 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	489 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	490
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	491 { /* Positive zero. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	492 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	493 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	494 my_asprintf (&result, "%La %d", 0.0L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	495 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	496 ASSERT (strcmp (result, "0x0p+0 33") == 0);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	497 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	498 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	499 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	500
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	501 { /* Negative zero. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	502 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	503 int retval =
10601 ca053fa79cd3 Use a more portable replacement expression for -0.0L. Bruno Haible <bruno@clisp.org> parents: 10458 diff changeset	504 my_asprintf (&result, "%La %d", minus_zerol, 33, 44, 55);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	505 ASSERT (result != NULL);
8852 df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	506 if (have_minus_zero ())
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	507 ASSERT (strcmp (result, "-0x0p+0 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	508 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	509 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	510 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	511
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	512 { /* Positive infinity. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	513 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	514 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	515 my_asprintf (&result, "%La %d", Infinityl (), 33, 44, 55);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	516 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	517 ASSERT (strcmp (result, "inf 33") == 0);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	518 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	519 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	520 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	521
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	522 { /* Negative infinity. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	523 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	524 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	525 my_asprintf (&result, "%La %d", - Infinityl (), 33, 44, 55);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	526 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	527 ASSERT (strcmp (result, "-inf 33") == 0);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	528 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	529 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	530 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	531
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	532 { /* NaN. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	533 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	534 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	535 my_asprintf (&result, "%La %d", NaNl (), 33, 44, 55);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	536 ASSERT (result != NULL);
8850 d1fe16dfbfee Avoid test failures on IRIX 6.5. Bruno Haible <bruno@clisp.org> parents: 8839 diff changeset	537 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	538 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	539 && strcmp (result + strlen (result) - 3, " 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	540 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	541 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	542 }
15906 400649d35651 printf-posix tests: Fix for platforms where 'long double' == 'double'. Bruno Haible <bruno@clisp.org>* parents: 15595 diff changeset	543 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) \|\| (defined __x86_64__ \|\| defined __amd64__) \|\| (defined __i386 \|\| defined __i386__ \|\| defined _I386 \|\| defined _M_IX86 \|\| defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	544 { /* Quiet NaN. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	545 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	546 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	547 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	548 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	549 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	550 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	551 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	552 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	553 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	554 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	555 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	556 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	557 {
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	558 /* Signalling NaN. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	559 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	560 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	561 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	562 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	563 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	564 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	565 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	566 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	567 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	568 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	569 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	570 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	571 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	572 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	573 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	574 Application Architecture.
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	575 Table 5-2 "Floating-Point Register Encodings"
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	576 Figure 5-6 "Memory to Floating-Point Register Data Translation"
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	577 */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	578 { /* Pseudo-NaN. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	579 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	580 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	581 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	582 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	583 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	584 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	585 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	586 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	587 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	588 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	589 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	590 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	591 { /* Pseudo-Infinity. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	592 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	593 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	594 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	595 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	596 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	597 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	598 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	599 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	600 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	601 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	602 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	603 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	604 { /* Pseudo-Zero. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	605 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	606 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	607 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	608 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	609 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	610 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	611 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	612 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	613 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	614 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	615 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	616 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	617 { /* Unnormalized number. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	618 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	619 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	620 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	621 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	622 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	623 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	624 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	625 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	626 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	627 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	628 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	629 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	630 { /* Pseudo-Denormal. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	631 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	632 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	633 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	634 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	635 my_asprintf (&result, "%La %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	636 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	637 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	638 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	639 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	640 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	641 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	642 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	643 #endif
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	644
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	645 { /* Rounding near the decimal point. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	646 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	647 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	648 my_asprintf (&result, "%.0La %d", 1.5L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	649 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	650 ASSERT (strcmp (result, "0x2p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	651 \|\| strcmp (result, "0x3p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	652 \|\| strcmp (result, "0x6p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	653 \|\| strcmp (result, "0xcp-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	654 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	655 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	656 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	657
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	658 { /* Rounding with precision 0. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	659 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	660 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	661 my_asprintf (&result, "%.0La %d", 1.51L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	662 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	663 ASSERT (strcmp (result, "0x2p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	664 \|\| strcmp (result, "0x3p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	665 \|\| strcmp (result, "0x6p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	666 \|\| strcmp (result, "0xcp-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	667 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	668 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	669 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	670
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	671 { /* Rounding with precision 1. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	672 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	673 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	674 my_asprintf (&result, "%.1La %d", 1.51L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	675 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	676 ASSERT (strcmp (result, "0x1.8p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	677 \|\| strcmp (result, "0x3.0p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	678 \|\| strcmp (result, "0x6.1p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	679 \|\| strcmp (result, "0xc.1p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	680 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	681 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	682 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	683
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	684 { /* Rounding with precision 2. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	685 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	686 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	687 my_asprintf (&result, "%.2La %d", 1.51L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	688 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	689 ASSERT (strcmp (result, "0x1.83p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	690 \|\| strcmp (result, "0x3.05p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	691 \|\| strcmp (result, "0x6.0ap-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	692 \|\| strcmp (result, "0xc.14p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	693 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	694 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	695 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	696
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	697 { /* Rounding with precision 3. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	698 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	699 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	700 my_asprintf (&result, "%.3La %d", 1.51L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	701 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	702 ASSERT (strcmp (result, "0x1.829p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	703 \|\| strcmp (result, "0x3.052p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	704 \|\| strcmp (result, "0x6.0a4p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	705 \|\| strcmp (result, "0xc.148p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	706 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	707 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	708 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	709
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	710 { /* Rounding can turn a ...FFF into a ...000. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	711 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	712 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	713 my_asprintf (&result, "%.3La %d", 1.49999L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	714 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	715 ASSERT (strcmp (result, "0x1.800p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	716 \|\| strcmp (result, "0x3.000p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	717 \|\| strcmp (result, "0x6.000p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	718 \|\| strcmp (result, "0xc.000p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	719 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	720 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	721 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	722
8344 c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	723 { /* Rounding can turn a ...FFF into a ...000.
16935 498a2211d839 Write "Mac OS X" instead of "MacOS X". Bruno Haible <bruno@clisp.org> parents: 16201 diff changeset	724 This shows a Mac OS X 10.3.9 (Darwin 7.9) bug and a
8344 c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	725 glibc 2.4 bug <http://sourceware.org/bugzilla/show_bug.cgi?id=2908>. */
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	726 char *result;
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	727 int retval =
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	728 my_asprintf (&result, "%.1La %d", 1.999L, 33, 44, 55);
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	729 ASSERT (result != NULL);
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	730 ASSERT (strcmp (result, "0x1.0p+1 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	731 \|\| strcmp (result, "0x2.0p+0 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	732 \|\| strcmp (result, "0x4.0p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	733 \|\| strcmp (result, "0x8.0p-2 33") == 0);
8344 c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	734 ASSERT (retval == strlen (result));
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	735 free (result);
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	736 }
c8055280f68e Test a corner case. Exclude two buggy implementations. Bruno Haible <bruno@clisp.org> parents: 8342 diff changeset	737
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	738 { /* Width. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	739 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	740 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	741 my_asprintf (&result, "%10La %d", 1.75L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	742 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	743 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	744 \|\| strcmp (result, " 0x3.8p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	745 \|\| strcmp (result, " 0x7p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	746 \|\| strcmp (result, " 0xep-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	747 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	748 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	749 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	750
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	751 { /* Small precision. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	752 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	753 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	754 my_asprintf (&result, "%.10La %d", 1.75L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	755 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	756 ASSERT (strcmp (result, "0x1.c000000000p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	757 \|\| strcmp (result, "0x3.8000000000p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	758 \|\| strcmp (result, "0x7.0000000000p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	759 \|\| strcmp (result, "0xe.0000000000p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	760 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	761 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	762 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	763
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	764 { /* Large precision. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	765 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	766 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	767 my_asprintf (&result, "%.50La %d", 1.75L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	768 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	769 ASSERT (strcmp (result, "0x1.c0000000000000000000000000000000000000000000000000p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	770 \|\| strcmp (result, "0x3.80000000000000000000000000000000000000000000000000p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	771 \|\| strcmp (result, "0x7.00000000000000000000000000000000000000000000000000p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	772 \|\| strcmp (result, "0xe.00000000000000000000000000000000000000000000000000p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	773 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	774 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	775 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	776
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	777 { /* FLAG_LEFT. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	778 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	779 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	780 my_asprintf (&result, "%-10La %d", 1.75L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	781 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	782 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	783 \|\| strcmp (result, "0x3.8p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	784 \|\| strcmp (result, "0x7p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	785 \|\| strcmp (result, "0xep-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	786 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	787 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	788 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	789
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	790 { /* FLAG_SHOWSIGN. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	791 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	792 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	793 my_asprintf (&result, "%+La %d", 1.75L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	794 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	795 ASSERT (strcmp (result, "+0x1.cp+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	796 \|\| strcmp (result, "+0x3.8p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	797 \|\| strcmp (result, "+0x7p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	798 \|\| strcmp (result, "+0xep-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	799 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	800 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	801 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	802
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	803 { /* FLAG_SPACE. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	804 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	805 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	806 my_asprintf (&result, "% La %d", 1.75L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	807 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	808 ASSERT (strcmp (result, " 0x1.cp+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	809 \|\| strcmp (result, " 0x3.8p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	810 \|\| strcmp (result, " 0x7p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	811 \|\| strcmp (result, " 0xep-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	812 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	813 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	814 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	815
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	816 { /* FLAG_ALT. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	817 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	818 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	819 my_asprintf (&result, "%#La %d", 1.75L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	820 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	821 ASSERT (strcmp (result, "0x1.cp+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	822 \|\| strcmp (result, "0x3.8p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	823 \|\| strcmp (result, "0x7.p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	824 \|\| strcmp (result, "0xe.p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	825 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	826 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	827 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	828
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	829 { /* FLAG_ALT. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	830 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	831 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	832 my_asprintf (&result, "%#La %d", 1.0L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	833 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	834 ASSERT (strcmp (result, "0x1.p+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	835 \|\| strcmp (result, "0x2.p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	836 \|\| strcmp (result, "0x4.p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	837 \|\| strcmp (result, "0x8.p-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	838 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	839 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	840 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	841
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	842 { /* FLAG_ZERO with finite number. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	843 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	844 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	845 my_asprintf (&result, "%010La %d", 1.75L, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	846 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	847 ASSERT (strcmp (result, "0x001.cp+0 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	848 \|\| strcmp (result, "0x003.8p-1 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	849 \|\| strcmp (result, "0x00007p-2 33") == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	850 \|\| strcmp (result, "0x0000ep-3 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	851 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	852 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	853 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	854
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	855 { /* FLAG_ZERO with infinite number. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	856 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	857 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	858 my_asprintf (&result, "%010La %d", Infinityl (), 33, 44, 55);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	859 ASSERT (result != NULL);
8662 023aa5c883a7 Guard against FreeBSD 6.1 bug. Bruno Haible <bruno@clisp.org> parents: 8648 diff changeset	860 /* "0000000inf 33" is not a valid result; see
023aa5c883a7 Guard against FreeBSD 6.1 bug. Bruno Haible <bruno@clisp.org> parents: 8648 diff changeset	861 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
023aa5c883a7 Guard against FreeBSD 6.1 bug. Bruno Haible <bruno@clisp.org> parents: 8648 diff changeset	862 ASSERT (strcmp (result, " inf 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	863 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	864 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	865 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	866
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	867 { /* FLAG_ZERO with NaN. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	868 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	869 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	870 my_asprintf (&result, "%050La %d", NaNl (), 33, 44, 55);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	871 ASSERT (result != NULL);
8662 023aa5c883a7 Guard against FreeBSD 6.1 bug. Bruno Haible <bruno@clisp.org> parents: 8648 diff changeset	872 /* "0000000nan 33" is not a valid result; see
023aa5c883a7 Guard against FreeBSD 6.1 bug. Bruno Haible <bruno@clisp.org> parents: 8648 diff changeset	873 <http://lists.gnu.org/archive/html/bug-gnulib/2007-04/msg00107.html> */
8870 4e1f2ea486b4 Allow for a longer printed representation of NaN. Bruno Haible <bruno@clisp.org> parents: 8865 diff changeset	874 ASSERT (strlen (result) == 50 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	875 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	876 && strcmp (result + strlen (result) - 3, " 33") == 0);
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	877 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	878 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	879 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	880
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	881 /* Test the support of the %f format directive. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	882
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	883 { /* A positive number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	884 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	885 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	886 my_asprintf (&result, "%f %d", 12.75, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	887 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	888 ASSERT (strcmp (result, "12.750000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	889 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	890 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	891 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	892
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	893 { /* A larger positive number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	894 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	895 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	896 my_asprintf (&result, "%f %d", 1234567.0, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	897 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	898 ASSERT (strcmp (result, "1234567.000000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	899 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	900 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	901 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	902
8834 4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	903 { /* Small and large positive numbers. */
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	904 static struct { double value; const char *string; } data[] =
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	905 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	906 { 1.234321234321234e-37, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	907 { 1.234321234321234e-36, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	908 { 1.234321234321234e-35, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	909 { 1.234321234321234e-34, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	910 { 1.234321234321234e-33, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	911 { 1.234321234321234e-32, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	912 { 1.234321234321234e-31, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	913 { 1.234321234321234e-30, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	914 { 1.234321234321234e-29, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	915 { 1.234321234321234e-28, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	916 { 1.234321234321234e-27, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	917 { 1.234321234321234e-26, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	918 { 1.234321234321234e-25, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	919 { 1.234321234321234e-24, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	920 { 1.234321234321234e-23, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	921 { 1.234321234321234e-22, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	922 { 1.234321234321234e-21, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	923 { 1.234321234321234e-20, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	924 { 1.234321234321234e-19, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	925 { 1.234321234321234e-18, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	926 { 1.234321234321234e-17, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	927 { 1.234321234321234e-16, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	928 { 1.234321234321234e-15, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	929 { 1.234321234321234e-14, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	930 { 1.234321234321234e-13, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	931 { 1.234321234321234e-12, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	932 { 1.234321234321234e-11, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	933 { 1.234321234321234e-10, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	934 { 1.234321234321234e-9, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	935 { 1.234321234321234e-8, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	936 { 1.234321234321234e-7, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	937 { 1.234321234321234e-6, "0.000001" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	938 { 1.234321234321234e-5, "0.000012" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	939 { 1.234321234321234e-4, "0.000123" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	940 { 1.234321234321234e-3, "0.001234" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	941 { 1.234321234321234e-2, "0.012343" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	942 { 1.234321234321234e-1, "0.123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	943 { 1.234321234321234, "1.234321" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	944 { 1.234321234321234e1, "12.343212" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	945 { 1.234321234321234e2, "123.432123" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	946 { 1.234321234321234e3, "1234.321234" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	947 { 1.234321234321234e4, "12343.212343" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	948 { 1.234321234321234e5, "123432.123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	949 { 1.234321234321234e6, "1234321.234321" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	950 { 1.234321234321234e7, "12343212.343212" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	951 { 1.234321234321234e8, "123432123.432123" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	952 { 1.234321234321234e9, "1234321234.321234" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	953 { 1.234321234321234e10, "12343212343.2123**" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	954 { 1.234321234321234e11, "123432123432.123***" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	955 { 1.234321234321234e12, "1234321234321.23****" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	956 { 1.234321234321234e13, "12343212343212.3*****" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	957 { 1.234321234321234e14, "123432123432123.******" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	958 { 1.234321234321234e15, "1234321234321234.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	959 { 1.234321234321234e16, "123432123432123**.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	960 { 1.234321234321234e17, "123432123432123***.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	961 { 1.234321234321234e18, "123432123432123****.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	962 { 1.234321234321234e19, "123432123432123*****.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	963 { 1.234321234321234e20, "123432123432123******.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	964 { 1.234321234321234e21, "123432123432123*******.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	965 { 1.234321234321234e22, "123432123432123********.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	966 { 1.234321234321234e23, "123432123432123*********.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	967 { 1.234321234321234e24, "123432123432123**********.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	968 { 1.234321234321234e25, "123432123432123***********.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	969 { 1.234321234321234e26, "123432123432123************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	970 { 1.234321234321234e27, "123432123432123*************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	971 { 1.234321234321234e28, "123432123432123**************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	972 { 1.234321234321234e29, "123432123432123***************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	973 { 1.234321234321234e30, "123432123432123****************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	974 { 1.234321234321234e31, "123432123432123*****************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	975 { 1.234321234321234e32, "123432123432123******************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	976 { 1.234321234321234e33, "123432123432123*******************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	977 { 1.234321234321234e34, "123432123432123********************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	978 { 1.234321234321234e35, "123432123432123*********************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	979 { 1.234321234321234e36, "123432123432123**********************.000000" }
8834 4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	980 };
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	981 size_t k;
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	982 for (k = 0; k < SIZEOF (data); k++)
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	983 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	984 char *result;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	985 int retval =
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	986 my_asprintf (&result, "%f", data[k].value);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	987 ASSERT (result != NULL);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	988 ASSERT (strmatch (data[k].string, result));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	989 ASSERT (retval == strlen (result));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	990 free (result);
8834 4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	991 }
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	992 }
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	993
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	994 { /* A negative number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	995 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	996 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	997 my_asprintf (&result, "%f %d", -0.03125, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	998 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	999 ASSERT (strcmp (result, "-0.031250 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1000 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1001 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1002 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1003
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1004 { /* Positive zero. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1005 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1006 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1007 my_asprintf (&result, "%f %d", 0.0, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1008 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1009 ASSERT (strcmp (result, "0.000000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1010 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1011 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1012 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1013
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1014 { /* Negative zero. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1015 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1016 int retval =
13834 108bbfd6f03b frexp, tests: work around ICC bug with -zero Eric Blake <eblake@redhat.com> parents: 12559 diff changeset	1017 my_asprintf (&result, "%f %d", minus_zerod, 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1018 ASSERT (result != NULL);
8852 df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	1019 if (have_minus_zero ())
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	1020 ASSERT (strcmp (result, "-0.000000 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1021 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1022 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1023 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1024
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1025 { /* Positive infinity. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1026 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1027 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	1028 my_asprintf (&result, "%f %d", Infinityd (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1029 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1030 ASSERT (strcmp (result, "inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1031 \|\| strcmp (result, "infinity 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1032 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1033 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1034 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1035
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1036 { /* Negative infinity. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1037 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1038 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	1039 my_asprintf (&result, "%f %d", - Infinityd (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1040 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1041 ASSERT (strcmp (result, "-inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1042 \|\| strcmp (result, "-infinity 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1043 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1044 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1045 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1046
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1047 { /* NaN. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1048 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1049 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	1050 my_asprintf (&result, "%f %d", NaNd (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1051 ASSERT (result != NULL);
8850 d1fe16dfbfee Avoid test failures on IRIX 6.5. Bruno Haible <bruno@clisp.org> parents: 8839 diff changeset	1052 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1053 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1054 && strcmp (result + strlen (result) - 3, " 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1055 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1056 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1057 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1058
8804 6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1059 { /* Width. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1060 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1061 int retval =
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1062 my_asprintf (&result, "%10f %d", 1.75, 33, 44, 55);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1063 ASSERT (result != NULL);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1064 ASSERT (strcmp (result, " 1.750000 33") == 0);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1065 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1066 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1067 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1068
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1069 { /* FLAG_LEFT. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1070 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1071 int retval =
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1072 my_asprintf (&result, "%-10f %d", 1.75, 33, 44, 55);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1073 ASSERT (result != NULL);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1074 ASSERT (strcmp (result, "1.750000 33") == 0);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1075 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1076 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1077 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1078
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1079 { /* FLAG_SHOWSIGN. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1080 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1081 int retval =
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1082 my_asprintf (&result, "%+f %d", 1.75, 33, 44, 55);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1083 ASSERT (result != NULL);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1084 ASSERT (strcmp (result, "+1.750000 33") == 0);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1085 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1086 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1087 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1088
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1089 { /* FLAG_SPACE. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1090 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1091 int retval =
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1092 my_asprintf (&result, "% f %d", 1.75, 33, 44, 55);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1093 ASSERT (result != NULL);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1094 ASSERT (strcmp (result, " 1.750000 33") == 0);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1095 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1096 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1097 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1098
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1099 { /* FLAG_ALT. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1100 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1101 int retval =
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1102 my_asprintf (&result, "%#f %d", 1.75, 33, 44, 55);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1103 ASSERT (result != NULL);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1104 ASSERT (strcmp (result, "1.750000 33") == 0);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1105 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1106 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1107 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1108
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1109 { /* FLAG_ALT. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1110 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1111 int retval =
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1112 my_asprintf (&result, "%#.f %d", 1.75, 33, 44, 55);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1113 ASSERT (result != NULL);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1114 ASSERT (strcmp (result, "2. 33") == 0);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1115 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1116 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1117 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1118
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1119 { /* FLAG_ZERO with finite number. */
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1120 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1121 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1122 my_asprintf (&result, "%015f %d", 1234.0, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1123 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1124 ASSERT (strcmp (result, "00001234.000000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1125 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1126 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1127 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1128
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1129 { /* FLAG_ZERO with infinite number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1130 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1131 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	1132 my_asprintf (&result, "%015f %d", - Infinityd (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1133 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1134 ASSERT (strcmp (result, " -inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1135 \|\| strcmp (result, " -infinity 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1136 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1137 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1138 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1139
8804 6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1140 { /* FLAG_ZERO with NaN. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1141 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1142 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	1143 my_asprintf (&result, "%050f %d", NaNd (), 33, 44, 55);
8804 6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1144 ASSERT (result != NULL);
8870 4e1f2ea486b4 Allow for a longer printed representation of NaN. Bruno Haible <bruno@clisp.org> parents: 8865 diff changeset	1145 ASSERT (strlen (result) == 50 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1146 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1147 && strcmp (result + strlen (result) - 3, " 33") == 0);
8804 6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1148 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1149 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1150 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1151
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1152 { /* Precision. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1153 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1154 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1155 my_asprintf (&result, "%.f %d", 1234.0, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1156 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1157 ASSERT (strcmp (result, "1234 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1158 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1159 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1160 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1161
9938 9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1162 { /* Precision with no rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1163 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1164 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1165 my_asprintf (&result, "%.2f %d", 999.951, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1166 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1167 ASSERT (strcmp (result, "999.95 33") == 0);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1168 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1169 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1170 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1171
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1172 { /* Precision with rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1173 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1174 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1175 my_asprintf (&result, "%.2f %d", 999.996, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1176 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1177 ASSERT (strcmp (result, "1000.00 33") == 0);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1178 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1179 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1180 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1181
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1182 { /* A positive number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1183 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1184 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1185 my_asprintf (&result, "%Lf %d", 12.75L, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1186 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1187 ASSERT (strcmp (result, "12.750000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1188 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1189 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1190 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1191
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1192 { /* A larger positive number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1193 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1194 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1195 my_asprintf (&result, "%Lf %d", 1234567.0L, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1196 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1197 ASSERT (strcmp (result, "1234567.000000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1198 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1199 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1200 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1201
8834 4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	1202 { /* Small and large positive numbers. */
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	1203 static struct { long double value; const char *string; } data[] =
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	1204 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1205 { 1.234321234321234e-37L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1206 { 1.234321234321234e-36L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1207 { 1.234321234321234e-35L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1208 { 1.234321234321234e-34L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1209 { 1.234321234321234e-33L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1210 { 1.234321234321234e-32L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1211 { 1.234321234321234e-31L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1212 { 1.234321234321234e-30L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1213 { 1.234321234321234e-29L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1214 { 1.234321234321234e-28L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1215 { 1.234321234321234e-27L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1216 { 1.234321234321234e-26L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1217 { 1.234321234321234e-25L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1218 { 1.234321234321234e-24L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1219 { 1.234321234321234e-23L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1220 { 1.234321234321234e-22L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1221 { 1.234321234321234e-21L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1222 { 1.234321234321234e-20L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1223 { 1.234321234321234e-19L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1224 { 1.234321234321234e-18L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1225 { 1.234321234321234e-17L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1226 { 1.234321234321234e-16L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1227 { 1.234321234321234e-15L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1228 { 1.234321234321234e-14L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1229 { 1.234321234321234e-13L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1230 { 1.234321234321234e-12L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1231 { 1.234321234321234e-11L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1232 { 1.234321234321234e-10L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1233 { 1.234321234321234e-9L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1234 { 1.234321234321234e-8L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1235 { 1.234321234321234e-7L, "0.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1236 { 1.234321234321234e-6L, "0.000001" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1237 { 1.234321234321234e-5L, "0.000012" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1238 { 1.234321234321234e-4L, "0.000123" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1239 { 1.234321234321234e-3L, "0.001234" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1240 { 1.234321234321234e-2L, "0.012343" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1241 { 1.234321234321234e-1L, "0.123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1242 { 1.234321234321234L, "1.234321" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1243 { 1.234321234321234e1L, "12.343212" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1244 { 1.234321234321234e2L, "123.432123" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1245 { 1.234321234321234e3L, "1234.321234" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1246 { 1.234321234321234e4L, "12343.212343" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1247 { 1.234321234321234e5L, "123432.123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1248 { 1.234321234321234e6L, "1234321.234321" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1249 { 1.234321234321234e7L, "12343212.343212" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1250 { 1.234321234321234e8L, "123432123.432123" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1251 { 1.234321234321234e9L, "1234321234.321234" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1252 { 1.234321234321234e10L, "12343212343.2123**" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1253 { 1.234321234321234e11L, "123432123432.123***" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1254 { 1.234321234321234e12L, "1234321234321.23****" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1255 { 1.234321234321234e13L, "12343212343212.3*****" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1256 { 1.234321234321234e14L, "123432123432123.******" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1257 { 1.234321234321234e15L, "1234321234321234.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1258 { 1.234321234321234e16L, "123432123432123**.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1259 { 1.234321234321234e17L, "123432123432123***.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1260 { 1.234321234321234e18L, "123432123432123****.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1261 { 1.234321234321234e19L, "123432123432123*****.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1262 { 1.234321234321234e20L, "123432123432123******.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1263 { 1.234321234321234e21L, "123432123432123*******.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1264 { 1.234321234321234e22L, "123432123432123********.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1265 { 1.234321234321234e23L, "123432123432123*********.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1266 { 1.234321234321234e24L, "123432123432123**********.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1267 { 1.234321234321234e25L, "123432123432123***********.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1268 { 1.234321234321234e26L, "123432123432123************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1269 { 1.234321234321234e27L, "123432123432123*************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1270 { 1.234321234321234e28L, "123432123432123**************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1271 { 1.234321234321234e29L, "123432123432123***************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1272 { 1.234321234321234e30L, "123432123432123****************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1273 { 1.234321234321234e31L, "123432123432123*****************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1274 { 1.234321234321234e32L, "123432123432123******************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1275 { 1.234321234321234e33L, "123432123432123*******************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1276 { 1.234321234321234e34L, "123432123432123********************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1277 { 1.234321234321234e35L, "123432123432123*********************.000000" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1278 { 1.234321234321234e36L, "123432123432123**********************.000000" }
8834 4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	1279 };
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	1280 size_t k;
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	1281 for (k = 0; k < SIZEOF (data); k++)
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	1282 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1283 char *result;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1284 int retval =
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1285 my_asprintf (&result, "%Lf", data[k].value);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1286 ASSERT (result != NULL);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1287 ASSERT (strmatch (data[k].string, result));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1288 ASSERT (retval == strlen (result));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1289 free (result);
8834 4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	1290 }
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	1291 }
4c705f82cd20 More tests of printf %f. Bruno Haible <bruno@clisp.org> parents: 8804 diff changeset	1292
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1293 { /* A negative number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1294 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1295 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1296 my_asprintf (&result, "%Lf %d", -0.03125L, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1297 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1298 ASSERT (strcmp (result, "-0.031250 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1299 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1300 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1301 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1302
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1303 { /* Positive zero. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1304 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1305 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1306 my_asprintf (&result, "%Lf %d", 0.0L, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1307 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1308 ASSERT (strcmp (result, "0.000000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1309 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1310 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1311 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1312
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1313 { /* Negative zero. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1314 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1315 int retval =
10601 ca053fa79cd3 Use a more portable replacement expression for -0.0L. Bruno Haible <bruno@clisp.org> parents: 10458 diff changeset	1316 my_asprintf (&result, "%Lf %d", minus_zerol, 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1317 ASSERT (result != NULL);
8852 df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	1318 if (have_minus_zero ())
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	1319 ASSERT (strcmp (result, "-0.000000 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1320 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1321 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1322 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1323
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1324 { /* Positive infinity. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1325 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1326 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	1327 my_asprintf (&result, "%Lf %d", Infinityl (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1328 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1329 ASSERT (strcmp (result, "inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1330 \|\| strcmp (result, "infinity 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1331 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1332 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1333 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1334
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1335 { /* Negative infinity. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1336 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1337 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	1338 my_asprintf (&result, "%Lf %d", - Infinityl (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1339 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1340 ASSERT (strcmp (result, "-inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1341 \|\| strcmp (result, "-infinity 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1342 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1343 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1344 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1345
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1346 { /* NaN. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1347 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1348 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	1349 my_asprintf (&result, "%Lf %d", NaNl (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1350 ASSERT (result != NULL);
8850 d1fe16dfbfee Avoid test failures on IRIX 6.5. Bruno Haible <bruno@clisp.org> parents: 8839 diff changeset	1351 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1352 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1353 && strcmp (result + strlen (result) - 3, " 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1354 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1355 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1356 }
15906 400649d35651 printf-posix tests: Fix for platforms where 'long double' == 'double'. Bruno Haible <bruno@clisp.org>* parents: 15595 diff changeset	1357 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) \|\| (defined __x86_64__ \|\| defined __amd64__) \|\| (defined __i386 \|\| defined __i386__ \|\| defined _I386 \|\| defined _M_IX86 \|\| defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1358 { /* Quiet NaN. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1359 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1360 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1361 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1362 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1363 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1364 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1365 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1366 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1367 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1368 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1369 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1370 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1371 {
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1372 /* Signalling NaN. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1373 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1374 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1375 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1376 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1377 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1378 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1379 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1380 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1381 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1382 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1383 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1384 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1385 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1386 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1387 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1388 Application Architecture.
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1389 Table 5-2 "Floating-Point Register Encodings"
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1390 Figure 5-6 "Memory to Floating-Point Register Data Translation"
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1391 */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1392 { /* Pseudo-NaN. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1393 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1394 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1395 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1396 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1397 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1398 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1399 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1400 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1401 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1402 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1403 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1404 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1405 { /* Pseudo-Infinity. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1406 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1407 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1408 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1409 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1410 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1411 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1412 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1413 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1414 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1415 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1416 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1417 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1418 { /* Pseudo-Zero. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1419 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1420 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1421 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1422 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1423 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1424 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1425 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1426 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1427 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1428 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1429 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1430 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1431 { /* Unnormalized number. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1432 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1433 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1434 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1435 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1436 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1437 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1438 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1439 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1440 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1441 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1442 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1443 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1444 { /* Pseudo-Denormal. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1445 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1446 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1447 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1448 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1449 my_asprintf (&result, "%Lf %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1450 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1451 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1452 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1453 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1454 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1455 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1456 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	1457 #endif
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1458
8804 6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1459 { /* Width. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1460 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1461 int retval =
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1462 my_asprintf (&result, "%10Lf %d", 1.75L, 33, 44, 55);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1463 ASSERT (result != NULL);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1464 ASSERT (strcmp (result, " 1.750000 33") == 0);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1465 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1466 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1467 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1468
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1469 { /* FLAG_LEFT. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1470 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1471 int retval =
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1472 my_asprintf (&result, "%-10Lf %d", 1.75L, 33, 44, 55);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1473 ASSERT (result != NULL);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1474 ASSERT (strcmp (result, "1.750000 33") == 0);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1475 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1476 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1477 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1478
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1479 { /* FLAG_SHOWSIGN. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1480 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1481 int retval =
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1482 my_asprintf (&result, "%+Lf %d", 1.75L, 33, 44, 55);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1483 ASSERT (result != NULL);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1484 ASSERT (strcmp (result, "+1.750000 33") == 0);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1485 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1486 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1487 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1488
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1489 { /* FLAG_SPACE. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1490 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1491 int retval =
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1492 my_asprintf (&result, "% Lf %d", 1.75L, 33, 44, 55);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1493 ASSERT (result != NULL);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1494 ASSERT (strcmp (result, " 1.750000 33") == 0);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1495 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1496 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1497 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1498
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1499 { /* FLAG_ALT. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1500 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1501 int retval =
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1502 my_asprintf (&result, "%#Lf %d", 1.75L, 33, 44, 55);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1503 ASSERT (result != NULL);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1504 ASSERT (strcmp (result, "1.750000 33") == 0);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1505 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1506 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1507 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1508
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1509 { /* FLAG_ALT. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1510 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1511 int retval =
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1512 my_asprintf (&result, "%#.Lf %d", 1.75L, 33, 44, 55);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1513 ASSERT (result != NULL);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1514 ASSERT (strcmp (result, "2. 33") == 0);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1515 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1516 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1517 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1518
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1519 { /* FLAG_ZERO with finite number. */
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1520 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1521 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1522 my_asprintf (&result, "%015Lf %d", 1234.0L, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1523 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1524 ASSERT (strcmp (result, "00001234.000000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1525 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1526 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1527 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1528
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1529 { /* FLAG_ZERO with infinite number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1530 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1531 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	1532 my_asprintf (&result, "%015Lf %d", - Infinityl (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1533 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1534 ASSERT (strcmp (result, " -inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1535 \|\| strcmp (result, " -infinity 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1536 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1537 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1538 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1539
8804 6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1540 { /* FLAG_ZERO with NaN. */
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1541 char *result;
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1542 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	1543 my_asprintf (&result, "%050Lf %d", NaNl (), 33, 44, 55);
8804 6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1544 ASSERT (result != NULL);
8870 4e1f2ea486b4 Allow for a longer printed representation of NaN. Bruno Haible <bruno@clisp.org> parents: 8865 diff changeset	1545 ASSERT (strlen (result) == 50 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1546 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1547 && strcmp (result + strlen (result) - 3, " 33") == 0);
8804 6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1548 ASSERT (retval == strlen (result));
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1549 free (result);
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1550 }
6ce313658b4d Work around an incorrect implementation of the 0 flag on most platforms. Bruno Haible <bruno@clisp.org> parents: 8803 diff changeset	1551
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1552 { /* Precision. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1553 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1554 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1555 my_asprintf (&result, "%.Lf %d", 1234.0L, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1556 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1557 ASSERT (strcmp (result, "1234 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1558 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1559 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1560 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1561
9938 9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1562 { /* Precision with no rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1563 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1564 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1565 my_asprintf (&result, "%.2Lf %d", 999.951L, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1566 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1567 ASSERT (strcmp (result, "999.95 33") == 0);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1568 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1569 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1570 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1571
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1572 { /* Precision with rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1573 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1574 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1575 my_asprintf (&result, "%.2Lf %d", 999.996L, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1576 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1577 ASSERT (strcmp (result, "1000.00 33") == 0);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1578 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1579 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1580 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1581
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1582 /* Test the support of the %F format directive. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1583
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1584 { /* A positive number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1585 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1586 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1587 my_asprintf (&result, "%F %d", 12.75, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1588 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1589 ASSERT (strcmp (result, "12.750000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1590 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1591 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1592 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1593
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1594 { /* A larger positive number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1595 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1596 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1597 my_asprintf (&result, "%F %d", 1234567.0, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1598 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1599 ASSERT (strcmp (result, "1234567.000000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1600 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1601 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1602 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1603
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1604 { /* A negative number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1605 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1606 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1607 my_asprintf (&result, "%F %d", -0.03125, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1608 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1609 ASSERT (strcmp (result, "-0.031250 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1610 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1611 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1612 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1613
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1614 { /* Positive zero. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1615 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1616 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1617 my_asprintf (&result, "%F %d", 0.0, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1618 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1619 ASSERT (strcmp (result, "0.000000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1620 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1621 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1622 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1623
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1624 { /* Negative zero. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1625 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1626 int retval =
13834 108bbfd6f03b frexp, tests: work around ICC bug with -zero Eric Blake <eblake@redhat.com> parents: 12559 diff changeset	1627 my_asprintf (&result, "%F %d", minus_zerod, 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1628 ASSERT (result != NULL);
8852 df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	1629 if (have_minus_zero ())
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	1630 ASSERT (strcmp (result, "-0.000000 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1631 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1632 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1633 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1634
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1635 { /* Positive infinity. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1636 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1637 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	1638 my_asprintf (&result, "%F %d", Infinityd (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1639 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1640 ASSERT (strcmp (result, "INF 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1641 \|\| strcmp (result, "INFINITY 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1642 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1643 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1644 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1645
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1646 { /* Negative infinity. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1647 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1648 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	1649 my_asprintf (&result, "%F %d", - Infinityd (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1650 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1651 ASSERT (strcmp (result, "-INF 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1652 \|\| strcmp (result, "-INFINITY 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1653 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1654 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1655 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1656
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1657 { /* NaN. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1658 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1659 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	1660 my_asprintf (&result, "%F %d", NaNd (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1661 ASSERT (result != NULL);
8850 d1fe16dfbfee Avoid test failures on IRIX 6.5. Bruno Haible <bruno@clisp.org> parents: 8839 diff changeset	1662 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1663 && strisnan (result, 0, strlen (result) - 3, 1)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1664 && strcmp (result + strlen (result) - 3, " 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1665 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1666 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1667 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1668
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1669 { /* FLAG_ZERO. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1670 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1671 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1672 my_asprintf (&result, "%015F %d", 1234.0, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1673 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1674 ASSERT (strcmp (result, "00001234.000000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1675 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1676 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1677 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1678
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1679 { /* FLAG_ZERO with infinite number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1680 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1681 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	1682 my_asprintf (&result, "%015F %d", - Infinityd (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1683 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1684 ASSERT (strcmp (result, " -INF 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1685 \|\| strcmp (result, " -INFINITY 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1686 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1687 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1688 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1689
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1690 { /* Precision. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1691 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1692 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1693 my_asprintf (&result, "%.F %d", 1234.0, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1694 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1695 ASSERT (strcmp (result, "1234 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1696 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1697 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1698 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1699
9938 9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1700 { /* Precision with no rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1701 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1702 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1703 my_asprintf (&result, "%.2F %d", 999.951, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1704 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1705 ASSERT (strcmp (result, "999.95 33") == 0);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1706 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1707 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1708 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1709
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1710 { /* Precision with rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1711 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1712 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1713 my_asprintf (&result, "%.2F %d", 999.996, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1714 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1715 ASSERT (strcmp (result, "1000.00 33") == 0);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1716 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1717 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1718 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1719
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1720 { /* A positive number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1721 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1722 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1723 my_asprintf (&result, "%LF %d", 12.75L, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1724 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1725 ASSERT (strcmp (result, "12.750000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1726 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1727 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1728 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1729
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1730 { /* A larger positive number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1731 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1732 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1733 my_asprintf (&result, "%LF %d", 1234567.0L, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1734 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1735 ASSERT (strcmp (result, "1234567.000000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1736 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1737 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1738 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1739
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1740 { /* A negative number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1741 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1742 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1743 my_asprintf (&result, "%LF %d", -0.03125L, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1744 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1745 ASSERT (strcmp (result, "-0.031250 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1746 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1747 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1748 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1749
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1750 { /* Positive zero. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1751 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1752 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1753 my_asprintf (&result, "%LF %d", 0.0L, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1754 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1755 ASSERT (strcmp (result, "0.000000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1756 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1757 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1758 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1759
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1760 { /* Negative zero. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1761 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1762 int retval =
10601 ca053fa79cd3 Use a more portable replacement expression for -0.0L. Bruno Haible <bruno@clisp.org> parents: 10458 diff changeset	1763 my_asprintf (&result, "%LF %d", minus_zerol, 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1764 ASSERT (result != NULL);
8852 df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	1765 if (have_minus_zero ())
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	1766 ASSERT (strcmp (result, "-0.000000 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1767 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1768 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1769 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1770
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1771 { /* Positive infinity. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1772 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1773 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	1774 my_asprintf (&result, "%LF %d", Infinityl (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1775 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1776 ASSERT (strcmp (result, "INF 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1777 \|\| strcmp (result, "INFINITY 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1778 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1779 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1780 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1781
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1782 { /* Negative infinity. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1783 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1784 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	1785 my_asprintf (&result, "%LF %d", - Infinityl (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1786 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1787 ASSERT (strcmp (result, "-INF 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1788 \|\| strcmp (result, "-INFINITY 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1789 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1790 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1791 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1792
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1793 { /* NaN. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1794 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1795 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	1796 my_asprintf (&result, "%LF %d", NaNl (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1797 ASSERT (result != NULL);
8850 d1fe16dfbfee Avoid test failures on IRIX 6.5. Bruno Haible <bruno@clisp.org> parents: 8839 diff changeset	1798 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1799 && strisnan (result, 0, strlen (result) - 3, 1)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1800 && strcmp (result + strlen (result) - 3, " 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1801 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1802 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1803 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1804
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1805 { /* FLAG_ZERO. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1806 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1807 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1808 my_asprintf (&result, "%015LF %d", 1234.0L, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1809 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1810 ASSERT (strcmp (result, "00001234.000000 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1811 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1812 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1813 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1814
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1815 { /* FLAG_ZERO with infinite number. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1816 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1817 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	1818 my_asprintf (&result, "%015LF %d", - Infinityl (), 33, 44, 55);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1819 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1820 ASSERT (strcmp (result, " -INF 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1821 \|\| strcmp (result, " -INFINITY 33") == 0);
8684 9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1822 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1823 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1824 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1825
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1826 { /* Precision. */
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1827 char *result;
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1828 int retval =
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1829 my_asprintf (&result, "%.LF %d", 1234.0L, 33, 44, 55);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1830 ASSERT (result != NULL);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1831 ASSERT (strcmp (result, "1234 33") == 0);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1832 ASSERT (retval == strlen (result));
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1833 free (result);
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1834 }
9ea5590b49d1 Add tests for %f and %F directives. Bruno Haible <bruno@clisp.org> parents: 8662 diff changeset	1835
9938 9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1836 { /* Precision with no rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1837 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1838 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1839 my_asprintf (&result, "%.2LF %d", 999.951L, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1840 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1841 ASSERT (strcmp (result, "999.95 33") == 0);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1842 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1843 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1844 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1845
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1846 { /* Precision with rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1847 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1848 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1849 my_asprintf (&result, "%.2LF %d", 999.996L, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1850 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1851 ASSERT (strcmp (result, "1000.00 33") == 0);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1852 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1853 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1854 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	1855
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1856 /* Test the support of the %e format directive. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1857
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1858 { /* A positive number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1859 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1860 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1861 my_asprintf (&result, "%e %d", 12.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1862 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	1863 ASSERT (strcmp (result, "1.275000e+01 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1864 \|\| strcmp (result, "1.275000e+001 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1865 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1866 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1867 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1868
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1869 { /* A larger positive number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1870 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1871 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1872 my_asprintf (&result, "%e %d", 1234567.0, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1873 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	1874 ASSERT (strcmp (result, "1.234567e+06 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1875 \|\| strcmp (result, "1.234567e+006 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1876 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1877 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1878 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1879
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1880 { /* Small and large positive numbers. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1881 static struct { double value; const char *string; } data[] =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1882 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1883 { 1.234321234321234e-37, "1.234321e-37" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1884 { 1.234321234321234e-36, "1.234321e-36" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1885 { 1.234321234321234e-35, "1.234321e-35" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1886 { 1.234321234321234e-34, "1.234321e-34" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1887 { 1.234321234321234e-33, "1.234321e-33" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1888 { 1.234321234321234e-32, "1.234321e-32" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1889 { 1.234321234321234e-31, "1.234321e-31" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1890 { 1.234321234321234e-30, "1.234321e-30" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1891 { 1.234321234321234e-29, "1.234321e-29" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1892 { 1.234321234321234e-28, "1.234321e-28" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1893 { 1.234321234321234e-27, "1.234321e-27" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1894 { 1.234321234321234e-26, "1.234321e-26" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1895 { 1.234321234321234e-25, "1.234321e-25" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1896 { 1.234321234321234e-24, "1.234321e-24" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1897 { 1.234321234321234e-23, "1.234321e-23" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1898 { 1.234321234321234e-22, "1.234321e-22" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1899 { 1.234321234321234e-21, "1.234321e-21" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1900 { 1.234321234321234e-20, "1.234321e-20" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1901 { 1.234321234321234e-19, "1.234321e-19" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1902 { 1.234321234321234e-18, "1.234321e-18" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1903 { 1.234321234321234e-17, "1.234321e-17" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1904 { 1.234321234321234e-16, "1.234321e-16" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1905 { 1.234321234321234e-15, "1.234321e-15" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1906 { 1.234321234321234e-14, "1.234321e-14" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1907 { 1.234321234321234e-13, "1.234321e-13" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1908 { 1.234321234321234e-12, "1.234321e-12" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1909 { 1.234321234321234e-11, "1.234321e-11" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1910 { 1.234321234321234e-10, "1.234321e-10" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1911 { 1.234321234321234e-9, "1.234321e-09" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1912 { 1.234321234321234e-8, "1.234321e-08" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1913 { 1.234321234321234e-7, "1.234321e-07" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1914 { 1.234321234321234e-6, "1.234321e-06" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1915 { 1.234321234321234e-5, "1.234321e-05" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1916 { 1.234321234321234e-4, "1.234321e-04" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1917 { 1.234321234321234e-3, "1.234321e-03" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1918 { 1.234321234321234e-2, "1.234321e-02" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1919 { 1.234321234321234e-1, "1.234321e-01" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1920 { 1.234321234321234, "1.234321e+00" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1921 { 1.234321234321234e1, "1.234321e+01" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1922 { 1.234321234321234e2, "1.234321e+02" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1923 { 1.234321234321234e3, "1.234321e+03" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1924 { 1.234321234321234e4, "1.234321e+04" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1925 { 1.234321234321234e5, "1.234321e+05" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1926 { 1.234321234321234e6, "1.234321e+06" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1927 { 1.234321234321234e7, "1.234321e+07" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1928 { 1.234321234321234e8, "1.234321e+08" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1929 { 1.234321234321234e9, "1.234321e+09" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1930 { 1.234321234321234e10, "1.234321e+10" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1931 { 1.234321234321234e11, "1.234321e+11" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1932 { 1.234321234321234e12, "1.234321e+12" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1933 { 1.234321234321234e13, "1.234321e+13" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1934 { 1.234321234321234e14, "1.234321e+14" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1935 { 1.234321234321234e15, "1.234321e+15" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1936 { 1.234321234321234e16, "1.234321e+16" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1937 { 1.234321234321234e17, "1.234321e+17" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1938 { 1.234321234321234e18, "1.234321e+18" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1939 { 1.234321234321234e19, "1.234321e+19" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1940 { 1.234321234321234e20, "1.234321e+20" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1941 { 1.234321234321234e21, "1.234321e+21" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1942 { 1.234321234321234e22, "1.234321e+22" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1943 { 1.234321234321234e23, "1.234321e+23" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1944 { 1.234321234321234e24, "1.234321e+24" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1945 { 1.234321234321234e25, "1.234321e+25" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1946 { 1.234321234321234e26, "1.234321e+26" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1947 { 1.234321234321234e27, "1.234321e+27" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1948 { 1.234321234321234e28, "1.234321e+28" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1949 { 1.234321234321234e29, "1.234321e+29" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1950 { 1.234321234321234e30, "1.234321e+30" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1951 { 1.234321234321234e31, "1.234321e+31" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1952 { 1.234321234321234e32, "1.234321e+32" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1953 { 1.234321234321234e33, "1.234321e+33" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1954 { 1.234321234321234e34, "1.234321e+34" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1955 { 1.234321234321234e35, "1.234321e+35" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1956 { 1.234321234321234e36, "1.234321e+36" }
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1957 };
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1958 size_t k;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1959 for (k = 0; k < SIZEOF (data); k++)
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1960 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1961 char *result;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1962 int retval =
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1963 my_asprintf (&result, "%e", data[k].value);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1964 const char *expected = data[k].string;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1965 ASSERT (result != NULL);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1966 ASSERT (strcmp (result, expected) == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1967 /* Some implementations produce exponents with 3 digits. */
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1968 \|\| (strlen (result) == strlen (expected) + 1
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1969 && memcmp (result, expected, strlen (expected) - 2) == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1970 && result[strlen (expected) - 2] == '0'
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1971 && strcmp (result + strlen (expected) - 1,
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1972 expected + strlen (expected) - 2)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1973 == 0));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1974 ASSERT (retval == strlen (result));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1975 free (result);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1976 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1977 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1978
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1979 { /* A negative number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1980 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1981 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1982 my_asprintf (&result, "%e %d", -0.03125, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1983 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	1984 ASSERT (strcmp (result, "-3.125000e-02 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1985 \|\| strcmp (result, "-3.125000e-002 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1986 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1987 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1988 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1989
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1990 { /* Positive zero. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1991 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1992 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1993 my_asprintf (&result, "%e %d", 0.0, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1994 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	1995 ASSERT (strcmp (result, "0.000000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	1996 \|\| strcmp (result, "0.000000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1997 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1998 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	1999 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2000
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2001 { /* Negative zero. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2002 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2003 int retval =
13834 108bbfd6f03b frexp, tests: work around ICC bug with -zero Eric Blake <eblake@redhat.com> parents: 12559 diff changeset	2004 my_asprintf (&result, "%e %d", minus_zerod, 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2005 ASSERT (result != NULL);
8852 df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	2006 if (have_minus_zero ())
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	2007 ASSERT (strcmp (result, "-0.000000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2008 \|\| strcmp (result, "-0.000000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2009 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2010 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2011 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2012
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2013 { /* Positive infinity. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2014 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2015 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	2016 my_asprintf (&result, "%e %d", Infinityd (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2017 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2018 ASSERT (strcmp (result, "inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2019 \|\| strcmp (result, "infinity 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2020 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2021 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2022 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2023
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2024 { /* Negative infinity. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2025 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2026 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	2027 my_asprintf (&result, "%e %d", - Infinityd (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2028 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2029 ASSERT (strcmp (result, "-inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2030 \|\| strcmp (result, "-infinity 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2031 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2032 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2033 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2034
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2035 { /* NaN. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2036 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2037 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	2038 my_asprintf (&result, "%e %d", NaNd (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2039 ASSERT (result != NULL);
8850 d1fe16dfbfee Avoid test failures on IRIX 6.5. Bruno Haible <bruno@clisp.org> parents: 8839 diff changeset	2040 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2041 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2042 && strcmp (result + strlen (result) - 3, " 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2043 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2044 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2045 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2046
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2047 { /* Width. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2048 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2049 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2050 my_asprintf (&result, "%15e %d", 1.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2051 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	2052 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2053 \|\| strcmp (result, " 1.750000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2054 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2055 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2056 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2057
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2058 { /* FLAG_LEFT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2059 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2060 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2061 my_asprintf (&result, "%-15e %d", 1.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2062 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	2063 ASSERT (strcmp (result, "1.750000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2064 \|\| strcmp (result, "1.750000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2065 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2066 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2067 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2068
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2069 { /* FLAG_SHOWSIGN. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2070 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2071 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2072 my_asprintf (&result, "%+e %d", 1.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2073 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	2074 ASSERT (strcmp (result, "+1.750000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2075 \|\| strcmp (result, "+1.750000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2076 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2077 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2078 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2079
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2080 { /* FLAG_SPACE. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2081 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2082 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2083 my_asprintf (&result, "% e %d", 1.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2084 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	2085 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2086 \|\| strcmp (result, " 1.750000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2087 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2088 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2089 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2090
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2091 { /* FLAG_ALT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2092 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2093 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2094 my_asprintf (&result, "%#e %d", 1.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2095 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	2096 ASSERT (strcmp (result, "1.750000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2097 \|\| strcmp (result, "1.750000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2098 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2099 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2100 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2101
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2102 { /* FLAG_ALT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2103 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2104 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2105 my_asprintf (&result, "%#.e %d", 1.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2106 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	2107 ASSERT (strcmp (result, "2.e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2108 \|\| strcmp (result, "2.e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2109 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2110 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2111 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2112
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2113 { /* FLAG_ALT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2114 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2115 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2116 my_asprintf (&result, "%#.e %d", 9.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2117 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	2118 ASSERT (strcmp (result, "1.e+01 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2119 \|\| strcmp (result, "1.e+001 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2120 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2121 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2122 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2123
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2124 { /* FLAG_ZERO with finite number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2125 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2126 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2127 my_asprintf (&result, "%015e %d", 1234.0, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2128 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	2129 ASSERT (strcmp (result, "0001.234000e+03 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2130 \|\| strcmp (result, "001.234000e+003 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2131 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2132 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2133 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2134
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2135 { /* FLAG_ZERO with infinite number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2136 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2137 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	2138 my_asprintf (&result, "%015e %d", - Infinityd (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2139 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2140 ASSERT (strcmp (result, " -inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2141 \|\| strcmp (result, " -infinity 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2142 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2143 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2144 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2145
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2146 { /* FLAG_ZERO with NaN. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2147 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2148 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	2149 my_asprintf (&result, "%050e %d", NaNd (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2150 ASSERT (result != NULL);
8870 4e1f2ea486b4 Allow for a longer printed representation of NaN. Bruno Haible <bruno@clisp.org> parents: 8865 diff changeset	2151 ASSERT (strlen (result) == 50 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2152 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2153 && strcmp (result + strlen (result) - 3, " 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2154 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2155 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2156 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2157
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2158 { /* Precision. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2159 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2160 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2161 my_asprintf (&result, "%.e %d", 1234.0, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2162 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	2163 ASSERT (strcmp (result, "1e+03 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2164 \|\| strcmp (result, "1e+003 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2165 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2166 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2167 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2168
9938 9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2169 { /* Precision with no rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2170 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2171 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2172 my_asprintf (&result, "%.4e %d", 999.951, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2173 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2174 ASSERT (strcmp (result, "9.9995e+02 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2175 \|\| strcmp (result, "9.9995e+002 33") == 0);
9938 9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2176 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2177 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2178 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2179
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2180 { /* Precision with rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2181 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2182 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2183 my_asprintf (&result, "%.4e %d", 999.996, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2184 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2185 ASSERT (strcmp (result, "1.0000e+03 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2186 \|\| strcmp (result, "1.0000e+003 33") == 0);
9938 9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2187 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2188 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2189 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2190
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2191 { /* A positive number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2192 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2193 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2194 my_asprintf (&result, "%Le %d", 12.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2195 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2196 ASSERT (strcmp (result, "1.275000e+01 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2197 \|\| strcmp (result, "1.275000e+001 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2198 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2199 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2200 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2201
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2202 { /* A larger positive number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2203 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2204 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2205 my_asprintf (&result, "%Le %d", 1234567.0L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2206 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2207 ASSERT (strcmp (result, "1.234567e+06 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2208 \|\| strcmp (result, "1.234567e+006 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2209 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2210 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2211 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2212
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2213 { /* Small and large positive numbers. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2214 static struct { long double value; const char *string; } data[] =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2215 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2216 { 1.234321234321234e-37L, "1.234321e-37" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2217 { 1.234321234321234e-36L, "1.234321e-36" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2218 { 1.234321234321234e-35L, "1.234321e-35" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2219 { 1.234321234321234e-34L, "1.234321e-34" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2220 { 1.234321234321234e-33L, "1.234321e-33" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2221 { 1.234321234321234e-32L, "1.234321e-32" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2222 { 1.234321234321234e-31L, "1.234321e-31" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2223 { 1.234321234321234e-30L, "1.234321e-30" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2224 { 1.234321234321234e-29L, "1.234321e-29" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2225 { 1.234321234321234e-28L, "1.234321e-28" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2226 { 1.234321234321234e-27L, "1.234321e-27" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2227 { 1.234321234321234e-26L, "1.234321e-26" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2228 { 1.234321234321234e-25L, "1.234321e-25" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2229 { 1.234321234321234e-24L, "1.234321e-24" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2230 { 1.234321234321234e-23L, "1.234321e-23" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2231 { 1.234321234321234e-22L, "1.234321e-22" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2232 { 1.234321234321234e-21L, "1.234321e-21" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2233 { 1.234321234321234e-20L, "1.234321e-20" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2234 { 1.234321234321234e-19L, "1.234321e-19" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2235 { 1.234321234321234e-18L, "1.234321e-18" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2236 { 1.234321234321234e-17L, "1.234321e-17" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2237 { 1.234321234321234e-16L, "1.234321e-16" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2238 { 1.234321234321234e-15L, "1.234321e-15" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2239 { 1.234321234321234e-14L, "1.234321e-14" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2240 { 1.234321234321234e-13L, "1.234321e-13" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2241 { 1.234321234321234e-12L, "1.234321e-12" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2242 { 1.234321234321234e-11L, "1.234321e-11" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2243 { 1.234321234321234e-10L, "1.234321e-10" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2244 { 1.234321234321234e-9L, "1.234321e-09" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2245 { 1.234321234321234e-8L, "1.234321e-08" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2246 { 1.234321234321234e-7L, "1.234321e-07" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2247 { 1.234321234321234e-6L, "1.234321e-06" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2248 { 1.234321234321234e-5L, "1.234321e-05" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2249 { 1.234321234321234e-4L, "1.234321e-04" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2250 { 1.234321234321234e-3L, "1.234321e-03" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2251 { 1.234321234321234e-2L, "1.234321e-02" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2252 { 1.234321234321234e-1L, "1.234321e-01" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2253 { 1.234321234321234L, "1.234321e+00" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2254 { 1.234321234321234e1L, "1.234321e+01" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2255 { 1.234321234321234e2L, "1.234321e+02" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2256 { 1.234321234321234e3L, "1.234321e+03" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2257 { 1.234321234321234e4L, "1.234321e+04" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2258 { 1.234321234321234e5L, "1.234321e+05" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2259 { 1.234321234321234e6L, "1.234321e+06" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2260 { 1.234321234321234e7L, "1.234321e+07" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2261 { 1.234321234321234e8L, "1.234321e+08" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2262 { 1.234321234321234e9L, "1.234321e+09" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2263 { 1.234321234321234e10L, "1.234321e+10" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2264 { 1.234321234321234e11L, "1.234321e+11" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2265 { 1.234321234321234e12L, "1.234321e+12" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2266 { 1.234321234321234e13L, "1.234321e+13" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2267 { 1.234321234321234e14L, "1.234321e+14" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2268 { 1.234321234321234e15L, "1.234321e+15" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2269 { 1.234321234321234e16L, "1.234321e+16" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2270 { 1.234321234321234e17L, "1.234321e+17" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2271 { 1.234321234321234e18L, "1.234321e+18" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2272 { 1.234321234321234e19L, "1.234321e+19" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2273 { 1.234321234321234e20L, "1.234321e+20" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2274 { 1.234321234321234e21L, "1.234321e+21" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2275 { 1.234321234321234e22L, "1.234321e+22" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2276 { 1.234321234321234e23L, "1.234321e+23" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2277 { 1.234321234321234e24L, "1.234321e+24" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2278 { 1.234321234321234e25L, "1.234321e+25" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2279 { 1.234321234321234e26L, "1.234321e+26" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2280 { 1.234321234321234e27L, "1.234321e+27" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2281 { 1.234321234321234e28L, "1.234321e+28" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2282 { 1.234321234321234e29L, "1.234321e+29" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2283 { 1.234321234321234e30L, "1.234321e+30" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2284 { 1.234321234321234e31L, "1.234321e+31" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2285 { 1.234321234321234e32L, "1.234321e+32" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2286 { 1.234321234321234e33L, "1.234321e+33" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2287 { 1.234321234321234e34L, "1.234321e+34" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2288 { 1.234321234321234e35L, "1.234321e+35" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2289 { 1.234321234321234e36L, "1.234321e+36" }
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2290 };
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2291 size_t k;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2292 for (k = 0; k < SIZEOF (data); k++)
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2293 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2294 char *result;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2295 int retval =
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2296 my_asprintf (&result, "%Le", data[k].value);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2297 const char *expected = data[k].string;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2298 ASSERT (result != NULL);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2299 ASSERT (strcmp (result, expected) == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2300 /* Some implementations produce exponents with 3 digits. */
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2301 \|\| (strlen (result) == strlen (expected) + 1
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2302 && memcmp (result, expected, strlen (expected) - 2) == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2303 && result[strlen (expected) - 2] == '0'
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2304 && strcmp (result + strlen (expected) - 1,
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2305 expected + strlen (expected) - 2)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2306 == 0));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2307 ASSERT (retval == strlen (result));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2308 free (result);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2309 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2310 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2311
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2312 { /* A negative number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2313 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2314 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2315 my_asprintf (&result, "%Le %d", -0.03125L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2316 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2317 ASSERT (strcmp (result, "-3.125000e-02 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2318 \|\| strcmp (result, "-3.125000e-002 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2319 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2320 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2321 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2322
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2323 { /* Positive zero. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2324 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2325 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2326 my_asprintf (&result, "%Le %d", 0.0L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2327 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2328 ASSERT (strcmp (result, "0.000000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2329 \|\| strcmp (result, "0.000000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2330 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2331 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2332 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2333
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2334 { /* Negative zero. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2335 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2336 int retval =
10601 ca053fa79cd3 Use a more portable replacement expression for -0.0L. Bruno Haible <bruno@clisp.org> parents: 10458 diff changeset	2337 my_asprintf (&result, "%Le %d", minus_zerol, 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2338 ASSERT (result != NULL);
8852 df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	2339 if (have_minus_zero ())
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2340 ASSERT (strcmp (result, "-0.000000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2341 \|\| strcmp (result, "-0.000000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2342 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2343 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2344 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2345
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2346 { /* Positive infinity. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2347 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2348 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	2349 my_asprintf (&result, "%Le %d", Infinityl (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2350 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2351 ASSERT (strcmp (result, "inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2352 \|\| strcmp (result, "infinity 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2353 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2354 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2355 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2356
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2357 { /* Negative infinity. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2358 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2359 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	2360 my_asprintf (&result, "%Le %d", - Infinityl (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2361 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2362 ASSERT (strcmp (result, "-inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2363 \|\| strcmp (result, "-infinity 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2364 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2365 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2366 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2367
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2368 { /* NaN. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2369 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2370 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	2371 my_asprintf (&result, "%Le %d", NaNl (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2372 ASSERT (result != NULL);
8850 d1fe16dfbfee Avoid test failures on IRIX 6.5. Bruno Haible <bruno@clisp.org> parents: 8839 diff changeset	2373 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2374 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2375 && strcmp (result + strlen (result) - 3, " 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2376 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2377 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2378 }
15906 400649d35651 printf-posix tests: Fix for platforms where 'long double' == 'double'. Bruno Haible <bruno@clisp.org>* parents: 15595 diff changeset	2379 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) \|\| (defined __x86_64__ \|\| defined __amd64__) \|\| (defined __i386 \|\| defined __i386__ \|\| defined _I386 \|\| defined _M_IX86 \|\| defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2380 { /* Quiet NaN. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2381 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2382 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2383 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2384 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2385 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2386 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2387 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2388 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2389 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2390 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2391 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2392 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2393 {
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2394 /* Signalling NaN. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2395 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2396 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2397 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2398 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2399 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2400 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2401 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2402 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2403 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2404 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2405 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2406 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2407 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2408 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2409 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2410 Application Architecture.
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2411 Table 5-2 "Floating-Point Register Encodings"
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2412 Figure 5-6 "Memory to Floating-Point Register Data Translation"
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2413 */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2414 { /* Pseudo-NaN. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2415 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2416 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2417 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2418 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2419 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2420 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2421 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2422 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2423 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2424 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2425 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2426 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2427 { /* Pseudo-Infinity. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2428 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2429 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2430 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2431 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2432 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2433 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2434 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2435 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2436 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2437 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2438 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2439 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2440 { /* Pseudo-Zero. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2441 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2442 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2443 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2444 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2445 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2446 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2447 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2448 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2449 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2450 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2451 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2452 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2453 { /* Unnormalized number. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2454 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2455 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2456 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2457 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2458 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2459 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2460 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2461 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2462 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2463 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2464 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2465 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2466 { /* Pseudo-Denormal. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2467 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2468 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2469 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2470 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2471 my_asprintf (&result, "%Le %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2472 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2473 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2474 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2475 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2476 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2477 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2478 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	2479 #endif
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2480
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2481 { /* Width. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2482 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2483 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2484 my_asprintf (&result, "%15Le %d", 1.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2485 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2486 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2487 \|\| strcmp (result, " 1.750000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2488 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2489 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2490 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2491
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2492 { /* FLAG_LEFT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2493 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2494 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2495 my_asprintf (&result, "%-15Le %d", 1.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2496 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2497 ASSERT (strcmp (result, "1.750000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2498 \|\| strcmp (result, "1.750000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2499 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2500 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2501 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2502
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2503 { /* FLAG_SHOWSIGN. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2504 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2505 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2506 my_asprintf (&result, "%+Le %d", 1.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2507 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2508 ASSERT (strcmp (result, "+1.750000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2509 \|\| strcmp (result, "+1.750000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2510 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2511 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2512 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2513
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2514 { /* FLAG_SPACE. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2515 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2516 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2517 my_asprintf (&result, "% Le %d", 1.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2518 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2519 ASSERT (strcmp (result, " 1.750000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2520 \|\| strcmp (result, " 1.750000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2521 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2522 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2523 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2524
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2525 { /* FLAG_ALT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2526 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2527 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2528 my_asprintf (&result, "%#Le %d", 1.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2529 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2530 ASSERT (strcmp (result, "1.750000e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2531 \|\| strcmp (result, "1.750000e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2532 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2533 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2534 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2535
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2536 { /* FLAG_ALT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2537 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2538 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2539 my_asprintf (&result, "%#.Le %d", 1.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2540 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2541 ASSERT (strcmp (result, "2.e+00 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2542 \|\| strcmp (result, "2.e+000 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2543 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2544 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2545 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2546
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2547 { /* FLAG_ALT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2548 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2549 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2550 my_asprintf (&result, "%#.Le %d", 9.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2551 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2552 ASSERT (strcmp (result, "1.e+01 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2553 \|\| strcmp (result, "1.e+001 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2554 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2555 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2556 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2557
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2558 { /* FLAG_ZERO with finite number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2559 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2560 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2561 my_asprintf (&result, "%015Le %d", 1234.0L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2562 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2563 ASSERT (strcmp (result, "0001.234000e+03 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2564 \|\| strcmp (result, "001.234000e+003 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2565 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2566 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2567 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2568
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2569 { /* FLAG_ZERO with infinite number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2570 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2571 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	2572 my_asprintf (&result, "%015Le %d", - Infinityl (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2573 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2574 ASSERT (strcmp (result, " -inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2575 \|\| strcmp (result, " -infinity 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2576 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2577 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2578 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2579
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2580 { /* FLAG_ZERO with NaN. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2581 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2582 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	2583 my_asprintf (&result, "%050Le %d", NaNl (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2584 ASSERT (result != NULL);
8870 4e1f2ea486b4 Allow for a longer printed representation of NaN. Bruno Haible <bruno@clisp.org> parents: 8865 diff changeset	2585 ASSERT (strlen (result) == 50 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2586 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2587 && strcmp (result + strlen (result) - 3, " 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2588 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2589 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2590 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2591
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2592 { /* Precision. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2593 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2594 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2595 my_asprintf (&result, "%.Le %d", 1234.0L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2596 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2597 ASSERT (strcmp (result, "1e+03 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2598 \|\| strcmp (result, "1e+003 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2599 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2600 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2601 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2602
9938 9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2603 { /* Precision with no rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2604 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2605 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2606 my_asprintf (&result, "%.4Le %d", 999.951L, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2607 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2608 ASSERT (strcmp (result, "9.9995e+02 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2609 \|\| strcmp (result, "9.9995e+002 33") == 0);
9938 9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2610 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2611 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2612 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2613
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2614 { /* Precision with rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2615 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2616 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2617 my_asprintf (&result, "%.4Le %d", 999.996L, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2618 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2619 ASSERT (strcmp (result, "1.0000e+03 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2620 \|\| strcmp (result, "1.0000e+003 33") == 0);
9938 9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2621 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2622 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2623 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2624
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2625 /* Test the support of the %g format directive. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2626
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2627 { /* A positive number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2628 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2629 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2630 my_asprintf (&result, "%g %d", 12.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2631 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2632 ASSERT (strcmp (result, "12.75 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2633 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2634 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2635 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2636
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2637 { /* A larger positive number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2638 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2639 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2640 my_asprintf (&result, "%g %d", 1234567.0, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2641 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	2642 ASSERT (strcmp (result, "1.23457e+06 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2643 \|\| strcmp (result, "1.23457e+006 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2644 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2645 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2646 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2647
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2648 { /* Small and large positive numbers. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2649 static struct { double value; const char *string; } data[] =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2650 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2651 { 1.234321234321234e-37, "1.23432e-37" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2652 { 1.234321234321234e-36, "1.23432e-36" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2653 { 1.234321234321234e-35, "1.23432e-35" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2654 { 1.234321234321234e-34, "1.23432e-34" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2655 { 1.234321234321234e-33, "1.23432e-33" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2656 { 1.234321234321234e-32, "1.23432e-32" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2657 { 1.234321234321234e-31, "1.23432e-31" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2658 { 1.234321234321234e-30, "1.23432e-30" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2659 { 1.234321234321234e-29, "1.23432e-29" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2660 { 1.234321234321234e-28, "1.23432e-28" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2661 { 1.234321234321234e-27, "1.23432e-27" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2662 { 1.234321234321234e-26, "1.23432e-26" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2663 { 1.234321234321234e-25, "1.23432e-25" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2664 { 1.234321234321234e-24, "1.23432e-24" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2665 { 1.234321234321234e-23, "1.23432e-23" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2666 { 1.234321234321234e-22, "1.23432e-22" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2667 { 1.234321234321234e-21, "1.23432e-21" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2668 { 1.234321234321234e-20, "1.23432e-20" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2669 { 1.234321234321234e-19, "1.23432e-19" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2670 { 1.234321234321234e-18, "1.23432e-18" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2671 { 1.234321234321234e-17, "1.23432e-17" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2672 { 1.234321234321234e-16, "1.23432e-16" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2673 { 1.234321234321234e-15, "1.23432e-15" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2674 { 1.234321234321234e-14, "1.23432e-14" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2675 { 1.234321234321234e-13, "1.23432e-13" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2676 { 1.234321234321234e-12, "1.23432e-12" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2677 { 1.234321234321234e-11, "1.23432e-11" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2678 { 1.234321234321234e-10, "1.23432e-10" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2679 { 1.234321234321234e-9, "1.23432e-09" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2680 { 1.234321234321234e-8, "1.23432e-08" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2681 { 1.234321234321234e-7, "1.23432e-07" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2682 { 1.234321234321234e-6, "1.23432e-06" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2683 { 1.234321234321234e-5, "1.23432e-05" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2684 { 1.234321234321234e-4, "0.000123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2685 { 1.234321234321234e-3, "0.00123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2686 { 1.234321234321234e-2, "0.0123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2687 { 1.234321234321234e-1, "0.123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2688 { 1.234321234321234, "1.23432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2689 { 1.234321234321234e1, "12.3432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2690 { 1.234321234321234e2, "123.432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2691 { 1.234321234321234e3, "1234.32" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2692 { 1.234321234321234e4, "12343.2" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2693 { 1.234321234321234e5, "123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2694 { 1.234321234321234e6, "1.23432e+06" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2695 { 1.234321234321234e7, "1.23432e+07" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2696 { 1.234321234321234e8, "1.23432e+08" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2697 { 1.234321234321234e9, "1.23432e+09" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2698 { 1.234321234321234e10, "1.23432e+10" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2699 { 1.234321234321234e11, "1.23432e+11" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2700 { 1.234321234321234e12, "1.23432e+12" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2701 { 1.234321234321234e13, "1.23432e+13" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2702 { 1.234321234321234e14, "1.23432e+14" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2703 { 1.234321234321234e15, "1.23432e+15" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2704 { 1.234321234321234e16, "1.23432e+16" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2705 { 1.234321234321234e17, "1.23432e+17" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2706 { 1.234321234321234e18, "1.23432e+18" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2707 { 1.234321234321234e19, "1.23432e+19" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2708 { 1.234321234321234e20, "1.23432e+20" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2709 { 1.234321234321234e21, "1.23432e+21" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2710 { 1.234321234321234e22, "1.23432e+22" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2711 { 1.234321234321234e23, "1.23432e+23" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2712 { 1.234321234321234e24, "1.23432e+24" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2713 { 1.234321234321234e25, "1.23432e+25" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2714 { 1.234321234321234e26, "1.23432e+26" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2715 { 1.234321234321234e27, "1.23432e+27" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2716 { 1.234321234321234e28, "1.23432e+28" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2717 { 1.234321234321234e29, "1.23432e+29" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2718 { 1.234321234321234e30, "1.23432e+30" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2719 { 1.234321234321234e31, "1.23432e+31" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2720 { 1.234321234321234e32, "1.23432e+32" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2721 { 1.234321234321234e33, "1.23432e+33" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2722 { 1.234321234321234e34, "1.23432e+34" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2723 { 1.234321234321234e35, "1.23432e+35" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2724 { 1.234321234321234e36, "1.23432e+36" }
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2725 };
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2726 size_t k;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2727 for (k = 0; k < SIZEOF (data); k++)
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2728 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2729 char *result;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2730 int retval =
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2731 my_asprintf (&result, "%g", data[k].value);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2732 const char *expected = data[k].string;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2733 ASSERT (result != NULL);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2734 ASSERT (strcmp (result, expected) == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2735 /* Some implementations produce exponents with 3 digits. */
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2736 \|\| (expected[strlen (expected) - 4] == 'e'
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2737 && strlen (result) == strlen (expected) + 1
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2738 && memcmp (result, expected, strlen (expected) - 2) == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2739 && result[strlen (expected) - 2] == '0'
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2740 && strcmp (result + strlen (expected) - 1,
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2741 expected + strlen (expected) - 2)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2742 == 0));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2743 ASSERT (retval == strlen (result));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2744 free (result);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2745 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2746 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2747
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2748 { /* A negative number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2749 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2750 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2751 my_asprintf (&result, "%g %d", -0.03125, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2752 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2753 ASSERT (strcmp (result, "-0.03125 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2754 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2755 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2756 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2757
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2758 { /* Positive zero. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2759 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2760 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2761 my_asprintf (&result, "%g %d", 0.0, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2762 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2763 ASSERT (strcmp (result, "0 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2764 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2765 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2766 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2767
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2768 { /* Negative zero. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2769 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2770 int retval =
13834 108bbfd6f03b frexp, tests: work around ICC bug with -zero Eric Blake <eblake@redhat.com> parents: 12559 diff changeset	2771 my_asprintf (&result, "%g %d", minus_zerod, 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2772 ASSERT (result != NULL);
8852 df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	2773 if (have_minus_zero ())
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	2774 ASSERT (strcmp (result, "-0 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2775 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2776 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2777 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2778
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2779 { /* Positive infinity. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2780 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2781 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	2782 my_asprintf (&result, "%g %d", Infinityd (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2783 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2784 ASSERT (strcmp (result, "inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2785 \|\| strcmp (result, "infinity 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2786 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2787 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2788 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2789
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2790 { /* Negative infinity. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2791 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2792 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	2793 my_asprintf (&result, "%g %d", - Infinityd (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2794 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2795 ASSERT (strcmp (result, "-inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2796 \|\| strcmp (result, "-infinity 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2797 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2798 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2799 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2800
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2801 { /* NaN. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2802 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2803 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	2804 my_asprintf (&result, "%g %d", NaNd (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2805 ASSERT (result != NULL);
8850 d1fe16dfbfee Avoid test failures on IRIX 6.5. Bruno Haible <bruno@clisp.org> parents: 8839 diff changeset	2806 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2807 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2808 && strcmp (result + strlen (result) - 3, " 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2809 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2810 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2811 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2812
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2813 { /* Width. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2814 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2815 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2816 my_asprintf (&result, "%10g %d", 1.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2817 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2818 ASSERT (strcmp (result, " 1.75 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2819 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2820 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2821 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2822
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2823 { /* FLAG_LEFT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2824 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2825 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2826 my_asprintf (&result, "%-10g %d", 1.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2827 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2828 ASSERT (strcmp (result, "1.75 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2829 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2830 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2831 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2832
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2833 { /* FLAG_SHOWSIGN. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2834 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2835 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2836 my_asprintf (&result, "%+g %d", 1.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2837 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2838 ASSERT (strcmp (result, "+1.75 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2839 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2840 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2841 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2842
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2843 { /* FLAG_SPACE. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2844 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2845 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2846 my_asprintf (&result, "% g %d", 1.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2847 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2848 ASSERT (strcmp (result, " 1.75 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2849 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2850 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2851 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2852
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2853 { /* FLAG_ALT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2854 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2855 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2856 my_asprintf (&result, "%#g %d", 1.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2857 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2858 ASSERT (strcmp (result, "1.75000 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2859 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2860 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2861 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2862
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2863 { /* FLAG_ALT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2864 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2865 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2866 my_asprintf (&result, "%#.g %d", 1.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2867 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2868 ASSERT (strcmp (result, "2. 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2869 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2870 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2871 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2872
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2873 { /* FLAG_ALT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2874 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2875 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2876 my_asprintf (&result, "%#.g %d", 9.75, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2877 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	2878 ASSERT (strcmp (result, "1.e+01 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2879 \|\| strcmp (result, "1.e+001 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2880 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2881 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2882 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2883
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2884 { /* FLAG_ZERO with finite number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2885 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2886 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2887 my_asprintf (&result, "%010g %d", 1234.0, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2888 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2889 ASSERT (strcmp (result, "0000001234 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2890 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2891 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2892 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2893
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2894 { /* FLAG_ZERO with infinite number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2895 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2896 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	2897 my_asprintf (&result, "%015g %d", - Infinityd (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2898 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2899 ASSERT (strcmp (result, " -inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2900 \|\| strcmp (result, " -infinity 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2901 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2902 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2903 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2904
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2905 { /* FLAG_ZERO with NaN. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2906 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2907 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	2908 my_asprintf (&result, "%050g %d", NaNd (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2909 ASSERT (result != NULL);
8870 4e1f2ea486b4 Allow for a longer printed representation of NaN. Bruno Haible <bruno@clisp.org> parents: 8865 diff changeset	2910 ASSERT (strlen (result) == 50 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2911 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2912 && strcmp (result + strlen (result) - 3, " 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2913 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2914 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2915 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2916
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2917 { /* Precision. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2918 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2919 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2920 my_asprintf (&result, "%.g %d", 1234.0, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2921 ASSERT (result != NULL);
8839 5efc1d668039 Accomodate for implementations that produce 3 exponent digits in %e and %g. Bruno Haible <bruno@clisp.org> parents: 8836 diff changeset	2922 ASSERT (strcmp (result, "1e+03 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2923 \|\| strcmp (result, "1e+003 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2924 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2925 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2926 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2927
9938 9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2928 { /* Precision with no rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2929 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2930 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2931 my_asprintf (&result, "%.5g %d", 999.951, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2932 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2933 ASSERT (strcmp (result, "999.95 33") == 0);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2934 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2935 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2936 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2937
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2938 { /* Precision with rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2939 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2940 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2941 my_asprintf (&result, "%.5g %d", 999.996, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2942 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2943 ASSERT (strcmp (result, "1000 33") == 0);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2944 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2945 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2946 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	2947
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2948 { /* A positive number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2949 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2950 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2951 my_asprintf (&result, "%Lg %d", 12.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2952 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2953 ASSERT (strcmp (result, "12.75 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2954 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2955 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2956 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2957
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2958 { /* A larger positive number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2959 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2960 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2961 my_asprintf (&result, "%Lg %d", 1234567.0L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2962 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	2963 ASSERT (strcmp (result, "1.23457e+06 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2964 \|\| strcmp (result, "1.23457e+006 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2965 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2966 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2967 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2968
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2969 { /* Small and large positive numbers. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2970 static struct { long double value; const char *string; } data[] =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	2971 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2972 { 1.234321234321234e-37L, "1.23432e-37" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2973 { 1.234321234321234e-36L, "1.23432e-36" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2974 { 1.234321234321234e-35L, "1.23432e-35" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2975 { 1.234321234321234e-34L, "1.23432e-34" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2976 { 1.234321234321234e-33L, "1.23432e-33" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2977 { 1.234321234321234e-32L, "1.23432e-32" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2978 { 1.234321234321234e-31L, "1.23432e-31" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2979 { 1.234321234321234e-30L, "1.23432e-30" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2980 { 1.234321234321234e-29L, "1.23432e-29" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2981 { 1.234321234321234e-28L, "1.23432e-28" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2982 { 1.234321234321234e-27L, "1.23432e-27" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2983 { 1.234321234321234e-26L, "1.23432e-26" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2984 { 1.234321234321234e-25L, "1.23432e-25" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2985 { 1.234321234321234e-24L, "1.23432e-24" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2986 { 1.234321234321234e-23L, "1.23432e-23" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2987 { 1.234321234321234e-22L, "1.23432e-22" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2988 { 1.234321234321234e-21L, "1.23432e-21" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2989 { 1.234321234321234e-20L, "1.23432e-20" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2990 { 1.234321234321234e-19L, "1.23432e-19" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2991 { 1.234321234321234e-18L, "1.23432e-18" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2992 { 1.234321234321234e-17L, "1.23432e-17" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2993 { 1.234321234321234e-16L, "1.23432e-16" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2994 { 1.234321234321234e-15L, "1.23432e-15" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2995 { 1.234321234321234e-14L, "1.23432e-14" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2996 { 1.234321234321234e-13L, "1.23432e-13" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2997 { 1.234321234321234e-12L, "1.23432e-12" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2998 { 1.234321234321234e-11L, "1.23432e-11" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	2999 { 1.234321234321234e-10L, "1.23432e-10" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3000 { 1.234321234321234e-9L, "1.23432e-09" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3001 { 1.234321234321234e-8L, "1.23432e-08" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3002 { 1.234321234321234e-7L, "1.23432e-07" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3003 { 1.234321234321234e-6L, "1.23432e-06" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3004 { 1.234321234321234e-5L, "1.23432e-05" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3005 { 1.234321234321234e-4L, "0.000123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3006 { 1.234321234321234e-3L, "0.00123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3007 { 1.234321234321234e-2L, "0.0123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3008 { 1.234321234321234e-1L, "0.123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3009 { 1.234321234321234L, "1.23432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3010 { 1.234321234321234e1L, "12.3432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3011 { 1.234321234321234e2L, "123.432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3012 { 1.234321234321234e3L, "1234.32" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3013 { 1.234321234321234e4L, "12343.2" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3014 { 1.234321234321234e5L, "123432" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3015 { 1.234321234321234e6L, "1.23432e+06" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3016 { 1.234321234321234e7L, "1.23432e+07" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3017 { 1.234321234321234e8L, "1.23432e+08" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3018 { 1.234321234321234e9L, "1.23432e+09" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3019 { 1.234321234321234e10L, "1.23432e+10" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3020 { 1.234321234321234e11L, "1.23432e+11" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3021 { 1.234321234321234e12L, "1.23432e+12" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3022 { 1.234321234321234e13L, "1.23432e+13" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3023 { 1.234321234321234e14L, "1.23432e+14" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3024 { 1.234321234321234e15L, "1.23432e+15" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3025 { 1.234321234321234e16L, "1.23432e+16" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3026 { 1.234321234321234e17L, "1.23432e+17" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3027 { 1.234321234321234e18L, "1.23432e+18" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3028 { 1.234321234321234e19L, "1.23432e+19" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3029 { 1.234321234321234e20L, "1.23432e+20" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3030 { 1.234321234321234e21L, "1.23432e+21" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3031 { 1.234321234321234e22L, "1.23432e+22" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3032 { 1.234321234321234e23L, "1.23432e+23" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3033 { 1.234321234321234e24L, "1.23432e+24" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3034 { 1.234321234321234e25L, "1.23432e+25" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3035 { 1.234321234321234e26L, "1.23432e+26" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3036 { 1.234321234321234e27L, "1.23432e+27" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3037 { 1.234321234321234e28L, "1.23432e+28" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3038 { 1.234321234321234e29L, "1.23432e+29" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3039 { 1.234321234321234e30L, "1.23432e+30" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3040 { 1.234321234321234e31L, "1.23432e+31" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3041 { 1.234321234321234e32L, "1.23432e+32" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3042 { 1.234321234321234e33L, "1.23432e+33" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3043 { 1.234321234321234e34L, "1.23432e+34" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3044 { 1.234321234321234e35L, "1.23432e+35" },
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3045 { 1.234321234321234e36L, "1.23432e+36" }
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3046 };
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3047 size_t k;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3048 for (k = 0; k < SIZEOF (data); k++)
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3049 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3050 char *result;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3051 int retval =
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3052 my_asprintf (&result, "%Lg", data[k].value);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3053 const char *expected = data[k].string;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3054 ASSERT (result != NULL);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3055 ASSERT (strcmp (result, expected) == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3056 /* Some implementations produce exponents with 3 digits. */
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3057 \|\| (expected[strlen (expected) - 4] == 'e'
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3058 && strlen (result) == strlen (expected) + 1
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3059 && memcmp (result, expected, strlen (expected) - 2) == 0
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3060 && result[strlen (expected) - 2] == '0'
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3061 && strcmp (result + strlen (expected) - 1,
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3062 expected + strlen (expected) - 2)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3063 == 0));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3064 ASSERT (retval == strlen (result));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3065 free (result);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3066 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3067 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3068
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3069 { /* A negative number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3070 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3071 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3072 my_asprintf (&result, "%Lg %d", -0.03125L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3073 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3074 ASSERT (strcmp (result, "-0.03125 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3075 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3076 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3077 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3078
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3079 { /* Positive zero. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3080 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3081 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3082 my_asprintf (&result, "%Lg %d", 0.0L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3083 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3084 ASSERT (strcmp (result, "0 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3085 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3086 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3087 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3088
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3089 { /* Negative zero. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3090 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3091 int retval =
10601 ca053fa79cd3 Use a more portable replacement expression for -0.0L. Bruno Haible <bruno@clisp.org> parents: 10458 diff changeset	3092 my_asprintf (&result, "%Lg %d", minus_zerol, 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3093 ASSERT (result != NULL);
8852 df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	3094 if (have_minus_zero ())
df0b5e8ea770 Avoid test failures on platforms where -0.0 and 0.0 are identical. Bruno Haible <bruno@clisp.org> parents: 8850 diff changeset	3095 ASSERT (strcmp (result, "-0 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3096 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3097 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3098 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3099
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3100 { /* Positive infinity. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3101 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3102 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	3103 my_asprintf (&result, "%Lg %d", Infinityl (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3104 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3105 ASSERT (strcmp (result, "inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3106 \|\| strcmp (result, "infinity 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3107 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3108 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3109 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3110
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3111 { /* Negative infinity. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3112 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3113 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	3114 my_asprintf (&result, "%Lg %d", - Infinityl (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3115 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3116 ASSERT (strcmp (result, "-inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3117 \|\| strcmp (result, "-infinity 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3118 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3119 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3120 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3121
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3122 { /* NaN. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3123 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3124 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	3125 my_asprintf (&result, "%Lg %d", NaNl (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3126 ASSERT (result != NULL);
8850 d1fe16dfbfee Avoid test failures on IRIX 6.5. Bruno Haible <bruno@clisp.org> parents: 8839 diff changeset	3127 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3128 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3129 && strcmp (result + strlen (result) - 3, " 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3130 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3131 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3132 }
15906 400649d35651 printf-posix tests: Fix for platforms where 'long double' == 'double'. Bruno Haible <bruno@clisp.org>* parents: 15595 diff changeset	3133 #if CHECK_PRINTF_SAFE && ((defined __ia64 && LDBL_MANT_DIG == 64) \|\| (defined __x86_64__ \|\| defined __amd64__) \|\| (defined __i386 \|\| defined __i386__ \|\| defined _I386 \|\| defined _M_IX86 \|\| defined _X86_)) && !HAVE_SAME_LONG_DOUBLE_AS_DOUBLE
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3134 { /* Quiet NaN. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3135 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3136 { LDBL80_WORDS (0xFFFF, 0xC3333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3137 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3138 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3139 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3140 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3141 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3142 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3143 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3144 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3145 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3146 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3147 {
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3148 /* Signalling NaN. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3149 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3150 { LDBL80_WORDS (0xFFFF, 0x83333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3151 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3152 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3153 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3154 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3155 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3156 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3157 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3158 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3159 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3160 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3161 /* The isnanl function should recognize Pseudo-NaNs, Pseudo-Infinities,
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3162 Pseudo-Zeroes, Unnormalized Numbers, and Pseudo-Denormals, as defined in
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3163 Intel IA-64 Architecture Software Developer's Manual, Volume 1:
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3164 Application Architecture.
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3165 Table 5-2 "Floating-Point Register Encodings"
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3166 Figure 5-6 "Memory to Floating-Point Register Data Translation"
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3167 */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3168 { /* Pseudo-NaN. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3169 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3170 { LDBL80_WORDS (0xFFFF, 0x40000001, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3171 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3172 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3173 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3174 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3175 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3176 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3177 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3178 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3179 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3180 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3181 { /* Pseudo-Infinity. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3182 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3183 { LDBL80_WORDS (0xFFFF, 0x00000000, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3184 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3185 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3186 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3187 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3188 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3189 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3190 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3191 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3192 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3193 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3194 { /* Pseudo-Zero. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3195 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3196 { LDBL80_WORDS (0x4004, 0x00000000, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3197 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3198 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3199 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3200 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3201 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3202 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3203 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3204 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3205 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3206 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3207 { /* Unnormalized number. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3208 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3209 { LDBL80_WORDS (0x4000, 0x63333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3210 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3211 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3212 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3213 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3214 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3215 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3216 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3217 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3218 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3219 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3220 { /* Pseudo-Denormal. */
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3221 static union { unsigned int word[4]; long double value; } x =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3222 { LDBL80_WORDS (0x0000, 0x83333333, 0x00000000) };
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3223 char *result;
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3224 int retval =
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3225 my_asprintf (&result, "%Lg %d", x.value, 33, 44, 55);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3226 ASSERT (result != NULL);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3227 ASSERT (strlen (result) >= 3 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3228 && strisnan (result, 0, strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3229 && strcmp (result + strlen (result) - 3, " 33") == 0);
8919 42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3230 ASSERT (retval == strlen (result));
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3231 free (result);
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3232 }
42e2847583f9 Fix printf so that it recognizes non-IEEE numbers on i386, x86_64, ia64. Bruno Haible <bruno@clisp.org>* parents: 8891 diff changeset	3233 #endif
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3234
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3235 { /* Width. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3236 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3237 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3238 my_asprintf (&result, "%10Lg %d", 1.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3239 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3240 ASSERT (strcmp (result, " 1.75 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3241 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3242 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3243 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3244
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3245 { /* FLAG_LEFT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3246 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3247 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3248 my_asprintf (&result, "%-10Lg %d", 1.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3249 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3250 ASSERT (strcmp (result, "1.75 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3251 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3252 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3253 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3254
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3255 { /* FLAG_SHOWSIGN. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3256 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3257 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3258 my_asprintf (&result, "%+Lg %d", 1.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3259 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3260 ASSERT (strcmp (result, "+1.75 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3261 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3262 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3263 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3264
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3265 { /* FLAG_SPACE. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3266 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3267 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3268 my_asprintf (&result, "% Lg %d", 1.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3269 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3270 ASSERT (strcmp (result, " 1.75 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3271 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3272 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3273 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3274
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3275 { /* FLAG_ALT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3276 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3277 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3278 my_asprintf (&result, "%#Lg %d", 1.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3279 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3280 ASSERT (strcmp (result, "1.75000 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3281 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3282 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3283 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3284
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3285 { /* FLAG_ALT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3286 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3287 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3288 my_asprintf (&result, "%#.Lg %d", 1.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3289 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3290 ASSERT (strcmp (result, "2. 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3291 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3292 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3293 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3294
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3295 { /* FLAG_ALT. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3296 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3297 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3298 my_asprintf (&result, "%#.Lg %d", 9.75L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3299 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	3300 ASSERT (strcmp (result, "1.e+01 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3301 \|\| strcmp (result, "1.e+001 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3302 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3303 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3304 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3305
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3306 { /* FLAG_ZERO with finite number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3307 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3308 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3309 my_asprintf (&result, "%010Lg %d", 1234.0L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3310 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3311 ASSERT (strcmp (result, "0000001234 33") == 0);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3312 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3313 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3314 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3315
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3316 { /* FLAG_ZERO with infinite number. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3317 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3318 int retval =
15595 328819af1c02 Support for MSVC compiler: Avoid division by a literal 0. Bruno Haible <bruno@clisp.org> parents: 14079 diff changeset	3319 my_asprintf (&result, "%015Lg %d", - Infinityl (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3320 ASSERT (result != NULL);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3321 ASSERT (strcmp (result, " -inf 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3322 \|\| strcmp (result, " -infinity 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3323 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3324 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3325 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3326
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3327 { /* FLAG_ZERO with NaN. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3328 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3329 int retval =
9854 baba3b346ab2 Use macros NaNf, NaNd, NaNl instead of NAN. Bruno Haible <bruno@clisp.org> parents: 9850 diff changeset	3330 my_asprintf (&result, "%050Lg %d", NaNl (), 33, 44, 55);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3331 ASSERT (result != NULL);
8870 4e1f2ea486b4 Allow for a longer printed representation of NaN. Bruno Haible <bruno@clisp.org> parents: 8865 diff changeset	3332 ASSERT (strlen (result) == 50 + 3
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3333 && strisnan (result, strspn (result, " "), strlen (result) - 3, 0)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3334 && strcmp (result + strlen (result) - 3, " 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3335 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3336 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3337 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3338
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3339 { /* Precision. */
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3340 char *result;
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3341 int retval =
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3342 my_asprintf (&result, "%.Lg %d", 1234.0L, 33, 44, 55);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3343 ASSERT (result != NULL);
10458 1cc9cffb9615 Allow 3-digit exponents in %e and %g results on 'long double'. Bruno Haible <bruno@clisp.org> parents: 10394 diff changeset	3344 ASSERT (strcmp (result, "1e+03 33") == 0
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3345 \|\| strcmp (result, "1e+003 33") == 0);
8836 07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3346 ASSERT (retval == strlen (result));
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3347 free (result);
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3348 }
07084ab003b8 Add tests for %e and %g directives. Bruno Haible <bruno@clisp.org> parents: 8834 diff changeset	3349
9938 9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3350 { /* Precision with no rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3351 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3352 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3353 my_asprintf (&result, "%.5Lg %d", 999.951L, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3354 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3355 ASSERT (strcmp (result, "999.95 33") == 0);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3356 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3357 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3358 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3359
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3360 { /* Precision with rounding. */
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3361 char *result;
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3362 int retval =
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3363 my_asprintf (&result, "%.5Lg %d", 999.996L, 33, 44, 55);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3364 ASSERT (result != NULL);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3365 ASSERT (strcmp (result, "1000 33") == 0);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3366 ASSERT (retval == strlen (result));
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3367 free (result);
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3368 }
9f8c455639fc Fix rounding when a precision is given. Bruno Haible <bruno@clisp.org> parents: 9889 diff changeset	3369
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3370 /* Test the support of the %n format directive. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3371
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3372 {
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3373 int count = -1;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3374 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3375 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3376 my_asprintf (&result, "%d %n", 123, &count, 33, 44, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3377 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3378 ASSERT (strcmp (result, "123 ") == 0);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3379 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3380 ASSERT (count == 4);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3381 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3382 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3383
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3384 /* Test the support of the POSIX/XSI format strings with positions. */
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3385
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3386 {
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3387 char *result;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3388 int retval =
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3389 my_asprintf (&result, "%2$d %1$d", 33, 55);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3390 ASSERT (result != NULL);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3391 ASSERT (strcmp (result, "55 33") == 0);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3392 ASSERT (retval == strlen (result));
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3393 free (result);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3394 }
8803 6c1d98929550 Work around lack of support of grouping flag. Bruno Haible <bruno@clisp.org> parents: 8754 diff changeset	3395
6c1d98929550 Work around lack of support of grouping flag. Bruno Haible <bruno@clisp.org> parents: 8754 diff changeset	3396 /* Test the support of the grouping flag. */
6c1d98929550 Work around lack of support of grouping flag. Bruno Haible <bruno@clisp.org> parents: 8754 diff changeset	3397
6c1d98929550 Work around lack of support of grouping flag. Bruno Haible <bruno@clisp.org> parents: 8754 diff changeset	3398 {
6c1d98929550 Work around lack of support of grouping flag. Bruno Haible <bruno@clisp.org> parents: 8754 diff changeset	3399 char *result;
6c1d98929550 Work around lack of support of grouping flag. Bruno Haible <bruno@clisp.org> parents: 8754 diff changeset	3400 int retval =
6c1d98929550 Work around lack of support of grouping flag. Bruno Haible <bruno@clisp.org> parents: 8754 diff changeset	3401 my_asprintf (&result, "%'d %d", 1234567, 99);
6c1d98929550 Work around lack of support of grouping flag. Bruno Haible <bruno@clisp.org> parents: 8754 diff changeset	3402 ASSERT (result != NULL);
6c1d98929550 Work around lack of support of grouping flag. Bruno Haible <bruno@clisp.org> parents: 8754 diff changeset	3403 ASSERT (result[strlen (result) - 1] == '9');
6c1d98929550 Work around lack of support of grouping flag. Bruno Haible <bruno@clisp.org> parents: 8754 diff changeset	3404 ASSERT (retval == strlen (result));
6c1d98929550 Work around lack of support of grouping flag. Bruno Haible <bruno@clisp.org> parents: 8754 diff changeset	3405 free (result);
6c1d98929550 Work around lack of support of grouping flag. Bruno Haible <bruno@clisp.org> parents: 8754 diff changeset	3406 }
9447 6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3407
9674 b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3408 /* Test the support of the left-adjust flag. */
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3409
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3410 {
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3411 char *result;
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3412 int retval =
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3413 my_asprintf (&result, "a%*sc", -3, "b");
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3414 ASSERT (result != NULL);
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3415 ASSERT (strcmp (result, "ab c") == 0);
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3416 ASSERT (retval == strlen (result));
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3417 free (result);
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3418 }
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3419
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3420 {
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3421 char *result;
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3422 int retval =
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3423 my_asprintf (&result, "a%-*sc", 3, "b");
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3424 ASSERT (result != NULL);
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3425 ASSERT (strcmp (result, "ab c") == 0);
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3426 ASSERT (retval == strlen (result));
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3427 free (result);
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3428 }
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3429
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3430 {
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3431 char *result;
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3432 int retval =
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3433 my_asprintf (&result, "a%-*sc", -3, "b");
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3434 ASSERT (result != NULL);
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3435 ASSERT (strcmp (result, "ab c") == 0);
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3436 ASSERT (retval == strlen (result));
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3437 free (result);
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3438 }
b69f1141e94f Fix printf behaviour regarding the left-adjust flag on HP-UX 10.20. Bruno Haible <bruno@clisp.org>* parents: 9447 diff changeset	3439
9447 6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3440 /* Test the support of large precision. */
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3441
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3442 {
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3443 char *result;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3444 int retval =
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3445 my_asprintf (&result, "%.4000d %d", 1234567, 99);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3446 size_t i;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3447 ASSERT (result != NULL);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3448 for (i = 0; i < 4000 - 7; i++)
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3449 ASSERT (result[i] == '0');
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3450 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3451 ASSERT (retval == strlen (result));
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3452 free (result);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3453 }
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3454
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3455 {
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3456 char *result;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3457 int retval =
10394 4b3ac67aa7bc vasnprintf-posix: handle large precision via %.d Eric Blake <ebb9@byu.net>* parents: 10296 diff changeset	3458 my_asprintf (&result, "%.*d %d", 4000, 1234567, 99);
4b3ac67aa7bc vasnprintf-posix: handle large precision via %.d Eric Blake <ebb9@byu.net>* parents: 10296 diff changeset	3459 size_t i;
4b3ac67aa7bc vasnprintf-posix: handle large precision via %.d Eric Blake <ebb9@byu.net>* parents: 10296 diff changeset	3460 ASSERT (result != NULL);
4b3ac67aa7bc vasnprintf-posix: handle large precision via %.d Eric Blake <ebb9@byu.net>* parents: 10296 diff changeset	3461 for (i = 0; i < 4000 - 7; i++)
4b3ac67aa7bc vasnprintf-posix: handle large precision via %.d Eric Blake <ebb9@byu.net>* parents: 10296 diff changeset	3462 ASSERT (result[i] == '0');
4b3ac67aa7bc vasnprintf-posix: handle large precision via %.d Eric Blake <ebb9@byu.net>* parents: 10296 diff changeset	3463 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
4b3ac67aa7bc vasnprintf-posix: handle large precision via %.d Eric Blake <ebb9@byu.net>* parents: 10296 diff changeset	3464 ASSERT (retval == strlen (result));
4b3ac67aa7bc vasnprintf-posix: handle large precision via %.d Eric Blake <ebb9@byu.net>* parents: 10296 diff changeset	3465 free (result);
4b3ac67aa7bc vasnprintf-posix: handle large precision via %.d Eric Blake <ebb9@byu.net>* parents: 10296 diff changeset	3466 }
4b3ac67aa7bc vasnprintf-posix: handle large precision via %.d Eric Blake <ebb9@byu.net>* parents: 10296 diff changeset	3467
4b3ac67aa7bc vasnprintf-posix: handle large precision via %.d Eric Blake <ebb9@byu.net>* parents: 10296 diff changeset	3468 {
4b3ac67aa7bc vasnprintf-posix: handle large precision via %.d Eric Blake <ebb9@byu.net>* parents: 10296 diff changeset	3469 char *result;
4b3ac67aa7bc vasnprintf-posix: handle large precision via %.d Eric Blake <ebb9@byu.net>* parents: 10296 diff changeset	3470 int retval =
9447 6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3471 my_asprintf (&result, "%.4000d %d", -1234567, 99);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3472 size_t i;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3473 ASSERT (result != NULL);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3474 ASSERT (result[0] == '-');
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3475 for (i = 0; i < 4000 - 7; i++)
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3476 ASSERT (result[1 + i] == '0');
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3477 ASSERT (strcmp (result + 1 + 4000 - 7, "1234567 99") == 0);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3478 ASSERT (retval == strlen (result));
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3479 free (result);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3480 }
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3481
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3482 {
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3483 char *result;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3484 int retval =
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3485 my_asprintf (&result, "%.4000u %d", 1234567, 99);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3486 size_t i;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3487 ASSERT (result != NULL);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3488 for (i = 0; i < 4000 - 7; i++)
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3489 ASSERT (result[i] == '0');
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3490 ASSERT (strcmp (result + 4000 - 7, "1234567 99") == 0);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3491 ASSERT (retval == strlen (result));
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3492 free (result);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3493 }
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3494
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3495 {
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3496 char *result;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3497 int retval =
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3498 my_asprintf (&result, "%.4000o %d", 1234567, 99);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3499 size_t i;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3500 ASSERT (result != NULL);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3501 for (i = 0; i < 4000 - 7; i++)
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3502 ASSERT (result[i] == '0');
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3503 ASSERT (strcmp (result + 4000 - 7, "4553207 99") == 0);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3504 ASSERT (retval == strlen (result));
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3505 free (result);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3506 }
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3507
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3508 {
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3509 char *result;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3510 int retval =
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3511 my_asprintf (&result, "%.4000x %d", 1234567, 99);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3512 size_t i;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3513 ASSERT (result != NULL);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3514 for (i = 0; i < 4000 - 6; i++)
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3515 ASSERT (result[i] == '0');
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3516 ASSERT (strcmp (result + 4000 - 6, "12d687 99") == 0);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3517 ASSERT (retval == strlen (result));
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3518 free (result);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3519 }
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3520
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3521 {
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3522 char *result;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3523 int retval =
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3524 my_asprintf (&result, "%#.4000x %d", 1234567, 99);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3525 size_t i;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3526 ASSERT (result != NULL);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3527 ASSERT (result[0] == '0');
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3528 ASSERT (result[1] == 'x');
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3529 for (i = 0; i < 4000 - 6; i++)
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3530 ASSERT (result[2 + i] == '0');
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3531 ASSERT (strcmp (result + 2 + 4000 - 6, "12d687 99") == 0);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3532 ASSERT (retval == strlen (result));
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3533 free (result);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3534 }
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3535
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3536 {
13908 4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3537 char *result;
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3538 int retval =
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3539 my_asprintf (&result, "%.4000f %d", 1.0, 99);
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3540 size_t i;
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3541 ASSERT (result != NULL);
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3542 ASSERT (result[0] == '1');
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3543 ASSERT (result[1] == '.');
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3544 for (i = 0; i < 4000; i++)
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3545 ASSERT (result[2 + i] == '0');
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3546 ASSERT (strcmp (result + 2 + 4000, " 99") == 0);
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3547 ASSERT (retval == strlen (result));
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3548 free (result);
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3549 }
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3550
4b4e2b0d175e printf-posix: Detect a bug on Solaris 10/x86. Bruno Haible <bruno@clisp.org>* parents: 13834 diff changeset	3551 {
14005 f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3552 char *result;
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3553 int retval =
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3554 my_asprintf (&result, "%.511f %d", 1.0, 99);
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3555 size_t i;
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3556 ASSERT (result != NULL);
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3557 ASSERT (result[0] == '1');
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3558 ASSERT (result[1] == '.');
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3559 for (i = 0; i < 511; i++)
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3560 ASSERT (result[2 + i] == '0');
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3561 ASSERT (strcmp (result + 2 + 511, " 99") == 0);
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3562 ASSERT (retval == strlen (result));
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3563 free (result);
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3564 }
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3565
f585ecc144aa printf: Detect large precisions bug on Solaris 10/SPARC. Bruno Haible <bruno@clisp.org>* parents: 13908 diff changeset	3566 {
9447 6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3567 char input[5000];
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3568 char *result;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3569 int retval;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3570 size_t i;
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3571
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3572 for (i = 0; i < sizeof (input) - 1; i++)
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3573 input[i] = 'a' + ((1000000 / (i + 1)) % 26);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3574 input[i] = '\0';
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3575 retval = my_asprintf (&result, "%.4000s %d", input, 99);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3576 ASSERT (result != NULL);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3577 ASSERT (memcmp (result, input, 4000) == 0);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3578 ASSERT (strcmp (result + 4000, " 99") == 0);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3579 ASSERT (retval == strlen (result));
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3580 free (result);
6d73d8d1aecb Add tests for large precisions. Bruno Haible <bruno@clisp.org> parents: 9309 diff changeset	3581 }
11207 4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3582
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3583 /* Test the support of the %s format directive. */
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3584
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3585 /* To verify that these tests succeed, it is necessary to run them under
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3586 a tool that checks against invalid memory accesses, such as ElectricFence
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3587 or "valgrind --tool=memcheck". */
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3588 {
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3589 size_t i;
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3590
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3591 for (i = 1; i <= 8; i++)
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3592 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3593 char *block;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3594 char *result;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3595 int retval;
11207 4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3596
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3597 block = (char *) malloc (i);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3598 memcpy (block, "abcdefgh", i);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3599 retval = my_asprintf (&result, "%.*s", (int) i, block);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3600 ASSERT (result != NULL);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3601 ASSERT (memcmp (result, block, i) == 0);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3602 ASSERT (result[i] == '\0');
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3603 ASSERT (retval == strlen (result));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3604 free (result);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3605 free (block);
11207 4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3606 }
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3607 }
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3608 #if HAVE_WCHAR_T
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3609 {
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3610 size_t i;
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3611
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3612 for (i = 1; i <= 8; i++)
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3613 {
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3614 wchar_t *block;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3615 size_t j;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3616 char *result;
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3617 int retval;
11207 4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3618
12421 e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3619 block = (wchar_t ) malloc (i sizeof (wchar_t));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3620 for (j = 0; j < i; j++)
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3621 block[j] = "abcdefgh"[j];
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3622 retval = my_asprintf (&result, "%.*ls", (int) i, block);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3623 ASSERT (result != NULL);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3624 ASSERT (memcmp (result, "abcdefgh", i) == 0);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3625 ASSERT (result[i] == '\0');
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3626 ASSERT (retval == strlen (result));
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3627 free (result);
e8d2c6fc33ad Use spaces for indentation, not tabs. Bruno Haible <bruno@clisp.org> parents: 11207 diff changeset	3628 free (block);
11207 4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3629 }
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3630 }
4daf474e9033 vasnprintf: Fix invalid read past end of memory block. Bruno Haible <bruno@clisp.org> parents: 11002 diff changeset	3631 #endif
8342 504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3632 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3633
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3634 static int
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3635 my_asprintf (char *result, const char format, ...)
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3636 {
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3637 va_list args;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3638 int ret;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3639
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3640 va_start (args, format);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3641 ret = vasprintf (result, format, args);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3642 va_end (args);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3643 return ret;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3644 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3645
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3646 static void
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3647 test_vasprintf ()
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3648 {
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3649 test_function (my_asprintf);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3650 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3651
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3652 static void
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3653 test_asprintf ()
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3654 {
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3655 test_function (asprintf);
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3656 }
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3657
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3658 int
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3659 main (int argc, char *argv[])
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3660 {
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3661 test_vasprintf ();
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3662 test_asprintf ();
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3663 return 0;
504f056f113a Tests for module 'vasprintf-posix'. Bruno Haible <bruno@clisp.org> parents: diff changeset	3664 }

Mercurial > hg > octave-lojdl > gnulib-hg

annotate tests/test-vasprintf-posix.c @ 16935:498a2211d839