[thirdparty/glibc.git] / stdio-common / tst-printf-round.c

/* Test for correct rounding of printf floating-point output.
   Copyright (C) 2012-2013 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

#include <fenv.h>
#include <stdio.h>
#include <string.h>

struct dec_test {
  double d;
  const char *fmt;
  const char *rd, *rn, *rz, *ru;
};

static const struct dec_test dec_tests[] = {
  { 1.5, "%.0f", "1", "2", "1", "2" },
  { -1.5, "%.0f", "-2", "-2", "-1", "-1" },
  { 2.5, "%.0f", "2", "2", "2", "3" },
  { -2.5, "%.0f", "-3", "-2", "-2", "-2" },
  { 1.4999, "%.0f", "1", "1", "1", "2" },
  { -1.4999, "%.0f", "-2", "-1", "-1", "-1" },
  { 1.5001, "%.0f", "1", "2", "1", "2" },
  { -1.5001, "%.0f", "-2", "-2", "-1", "-1" },
  { 2.4999, "%.0f", "2", "2", "2", "3" },
  { -2.4999, "%.0f", "-3", "-2", "-2", "-2" },
  { 2.5001, "%.0f", "2", "3", "2", "3" },
  { -2.5001, "%.0f", "-3", "-3", "-2", "-2" },
  { 1.0 / 3.0, "%f", "0.333333", "0.333333", "0.333333", "0.333334" },
  { -1.0 / 3.0, "%f", "-0.333334", "-0.333333", "-0.333333", "-0.333333" },
  { 0.2500001, "%.2e", "2.50e-01", "2.50e-01", "2.50e-01", "2.51e-01" },
  { -0.2500001, "%.2e", "-2.51e-01", "-2.50e-01", "-2.50e-01", "-2.50e-01" },
  { 1000001.0, "%.1e", "1.0e+06", "1.0e+06", "1.0e+06", "1.1e+06" },
  { -1000001.0, "%.1e", "-1.1e+06", "-1.0e+06", "-1.0e+06", "-1.0e+06" },
};

static int
test_dec_in_one_mode (double d, const char *fmt, const char *expected,
		      const char *mode_name)
{
  char buf[100];
  int ret = snprintf (buf, sizeof buf, fmt, d);
  if (ret <= 0 || ret >= (int) sizeof buf)
    {
      printf ("snprintf for %a returned %d\n", d, ret);
      return 1;
    }
  if (strcmp (buf, expected) == 0)
    return 0;
  else
    {
      printf ("snprintf (\"%s\", %a) returned \"%s\" not \"%s\" (%s)\n",
	      fmt, d, buf, expected, mode_name);
      return 1;
    }
}

struct hex_test
{
  double d;
  const char *fmt;
  const char *rd[4], *rn[4], *rz[4], *ru[4];
};

static const struct hex_test hex_tests[] =
  {
    {
      0x1.fffffp+4, "%.1a",
      { "0x1.fp+4", "0x3.fp+3", "0x7.fp+2", "0xf.fp+1" },
      { "0x2.0p+4", "0x4.0p+3", "0x8.0p+2", "0x1.0p+5" },
      { "0x1.fp+4", "0x3.fp+3", "0x7.fp+2", "0xf.fp+1" },
      { "0x2.0p+4", "0x4.0p+3", "0x8.0p+2", "0x1.0p+5" }
    },
    {
      -0x1.fffffp+4, "%.1a",
      { "-0x2.0p+4", "-0x4.0p+3", "-0x8.0p+2", "-0x1.0p+5" },
      { "-0x2.0p+4", "-0x4.0p+3", "-0x8.0p+2", "-0x1.0p+5" },
      { "-0x1.fp+4", "-0x3.fp+3", "-0x7.fp+2", "-0xf.fp+1" },
      { "-0x1.fp+4", "-0x3.fp+3", "-0x7.fp+2", "-0xf.fp+1" }
    },
    {
      0x1.88p+4, "%.1a",
      { "0x1.8p+4", "0x3.1p+3", "0x6.2p+2", "0xc.4p+1" },
      { "0x1.8p+4", "0x3.1p+3", "0x6.2p+2", "0xc.4p+1" },
      { "0x1.8p+4", "0x3.1p+3", "0x6.2p+2", "0xc.4p+1" },
      { "0x1.9p+4", "0x3.1p+3", "0x6.2p+2", "0xc.4p+1" }
    },
    {
      -0x1.88p+4, "%.1a",
      { "-0x1.9p+4", "-0x3.1p+3", "-0x6.2p+2", "-0xc.4p+1" },
      { "-0x1.8p+4", "-0x3.1p+3", "-0x6.2p+2", "-0xc.4p+1" },
      { "-0x1.8p+4", "-0x3.1p+3", "-0x6.2p+2", "-0xc.4p+1" },
      { "-0x1.8p+4", "-0x3.1p+3", "-0x6.2p+2", "-0xc.4p+1" }
    },
    {
      0x1.78p+4, "%.1a",
      { "0x1.7p+4", "0x2.fp+3", "0x5.ep+2", "0xb.cp+1" },
      { "0x1.8p+4", "0x2.fp+3", "0x5.ep+2", "0xb.cp+1" },
      { "0x1.7p+4", "0x2.fp+3", "0x5.ep+2", "0xb.cp+1" },
      { "0x1.8p+4", "0x2.fp+3", "0x5.ep+2", "0xb.cp+1" }
    },
    {
      -0x1.78p+4, "%.1a",
      { "-0x1.8p+4", "-0x2.fp+3", "-0x5.ep+2", "-0xb.cp+1" },
      { "-0x1.8p+4", "-0x2.fp+3", "-0x5.ep+2", "-0xb.cp+1" },
      { "-0x1.7p+4", "-0x2.fp+3", "-0x5.ep+2", "-0xb.cp+1" },
      { "-0x1.7p+4", "-0x2.fp+3", "-0x5.ep+2", "-0xb.cp+1" }
    },
    {
      64.0 / 3.0, "%.1a",
      { "0x1.5p+4", "0x2.ap+3", "0x5.5p+2", "0xa.ap+1" },
      { "0x1.5p+4", "0x2.bp+3", "0x5.5p+2", "0xa.bp+1" },
      { "0x1.5p+4", "0x2.ap+3", "0x5.5p+2", "0xa.ap+1" },
      { "0x1.6p+4", "0x2.bp+3", "0x5.6p+2", "0xa.bp+1" }
    },
    {
      -64.0 / 3.0, "%.1a",
      { "-0x1.6p+4", "-0x2.bp+3", "-0x5.6p+2", "-0xa.bp+1" },
      { "-0x1.5p+4", "-0x2.bp+3", "-0x5.5p+2", "-0xa.bp+1" },
      { "-0x1.5p+4", "-0x2.ap+3", "-0x5.5p+2", "-0xa.ap+1" },
      { "-0x1.5p+4", "-0x2.ap+3", "-0x5.5p+2", "-0xa.ap+1" }
    },
  };

static int
test_hex_in_one_mode (double d, const char *fmt, const char *expected[4],
		      const char *mode_name)
{
  char buf[100];
  int ret = snprintf (buf, sizeof buf, fmt, d);
  if (ret <= 0 || ret >= (int) sizeof buf)
    {
      printf ("snprintf for %a returned %d\n", d, ret);
      return 1;
    }
  if (strcmp (buf, expected[0]) == 0
      || strcmp (buf, expected[1]) == 0
      || strcmp (buf, expected[2]) == 0
      || strcmp (buf, expected[3]) == 0)
    return 0;
  else
    {
      printf ("snprintf (\"%s\", %a) returned \"%s\" not "
	      "\"%s\" or \"%s\" or \"%s\" or \"%s\" (%s)\n",
	      fmt, d, buf, expected[0], expected[1], expected[2], expected[3],
	      mode_name);
      return 1;
    }
}

static int
do_test (void)
{
  int save_round_mode = fegetround ();
  int result = 0;

  for (size_t i = 0; i < sizeof (dec_tests) / sizeof (dec_tests[0]); i++)
    {
      result |= test_dec_in_one_mode (dec_tests[i].d, dec_tests[i].fmt,
				      dec_tests[i].rn, "default rounding mode");
#ifdef FE_DOWNWARD
      if (!fesetround (FE_DOWNWARD))
	{
	  result |= test_dec_in_one_mode (dec_tests[i].d, dec_tests[i].fmt,
					  dec_tests[i].rd, "FE_DOWNWARD");
	  fesetround (save_round_mode);
	}
#endif
#ifdef FE_TOWARDZERO
      if (!fesetround (FE_TOWARDZERO))
	{
	  result |= test_dec_in_one_mode (dec_tests[i].d, dec_tests[i].fmt,
					  dec_tests[i].rz, "FE_TOWARDZERO");
	  fesetround (save_round_mode);
	}
#endif
#ifdef FE_UPWARD
      if (!fesetround (FE_UPWARD))
	{
	  result |= test_dec_in_one_mode (dec_tests[i].d, dec_tests[i].fmt,
					  dec_tests[i].ru, "FE_UPWARD");
	  fesetround (save_round_mode);
	}
#endif
    }

  for (size_t i = 0; i < sizeof (hex_tests) / sizeof (hex_tests[0]); i++)
    {
      result |= test_hex_in_one_mode (hex_tests[i].d, hex_tests[i].fmt,
				      hex_tests[i].rn, "default rounding mode");
#ifdef FE_DOWNWARD
      if (!fesetround (FE_DOWNWARD))
	{
	  result |= test_hex_in_one_mode (hex_tests[i].d, hex_tests[i].fmt,
					  hex_tests[i].rd, "FE_DOWNWARD");
	  fesetround (save_round_mode);
	}
#endif
#ifdef FE_TOWARDZERO
      if (!fesetround (FE_TOWARDZERO))
	{
	  result |= test_hex_in_one_mode (hex_tests[i].d, hex_tests[i].fmt,
					  hex_tests[i].rz, "FE_TOWARDZERO");
	  fesetround (save_round_mode);
	}
#endif
#ifdef FE_UPWARD
      if (!fesetround (FE_UPWARD))
	{
	  result |= test_hex_in_one_mode (hex_tests[i].d, hex_tests[i].fmt,
					  hex_tests[i].ru, "FE_UPWARD");
	  fesetround (save_round_mode);
	}
#endif
    }

  return result;
}

#define TEST_FUNCTION do_test ()
#include "../test-skeleton.c"
Commit	Line	Data
784761be	1	/* Test for correct rounding of printf floating-point output.
568035b7	2	Copyright (C) 2012-2013 Free Software Foundation, Inc.
784761be JM	3	This file is part of the GNU C Library.
	4
	5	The GNU C Library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
	9
	10	The GNU C Library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with the GNU C Library; if not, see
	17	<http://www.gnu.org/licenses/>. */
	18
	19	#include <fenv.h>
	20	#include <stdio.h>
	21	#include <string.h>
	22
	23	struct dec_test {
	24	double d;
	25	const char *fmt;
	26	const char rd, rn, rz, ru;
	27	};
	28
	29	static const struct dec_test dec_tests[] = {
	30	{ 1.5, "%.0f", "1", "2", "1", "2" },
	31	{ -1.5, "%.0f", "-2", "-2", "-1", "-1" },
	32	{ 2.5, "%.0f", "2", "2", "2", "3" },
	33	{ -2.5, "%.0f", "-3", "-2", "-2", "-2" },
	34	{ 1.4999, "%.0f", "1", "1", "1", "2" },
	35	{ -1.4999, "%.0f", "-2", "-1", "-1", "-1" },
	36	{ 1.5001, "%.0f", "1", "2", "1", "2" },
	37	{ -1.5001, "%.0f", "-2", "-2", "-1", "-1" },
	38	{ 2.4999, "%.0f", "2", "2", "2", "3" },
	39	{ -2.4999, "%.0f", "-3", "-2", "-2", "-2" },
	40	{ 2.5001, "%.0f", "2", "3", "2", "3" },
	41	{ -2.5001, "%.0f", "-3", "-3", "-2", "-2" },
	42	{ 1.0 / 3.0, "%f", "0.333333", "0.333333", "0.333333", "0.333334" },
	43	{ -1.0 / 3.0, "%f", "-0.333334", "-0.333333", "-0.333333", "-0.333333" },
	44	{ 0.2500001, "%.2e", "2.50e-01", "2.50e-01", "2.50e-01", "2.51e-01" },
	45	{ -0.2500001, "%.2e", "-2.51e-01", "-2.50e-01", "-2.50e-01", "-2.50e-01" },
	46	{ 1000001.0, "%.1e", "1.0e+06", "1.0e+06", "1.0e+06", "1.1e+06" },
	47	{ -1000001.0, "%.1e", "-1.1e+06", "-1.0e+06", "-1.0e+06", "-1.0e+06" },
	48	};
	49
	50	static int
	51	test_dec_in_one_mode (double d, const char fmt, const char expected,
	52	const char *mode_name)
	53	{
	54	char buf[100];
	55	int ret = snprintf (buf, sizeof buf, fmt, d);
	56	if (ret <= 0 \|\| ret >= (int) sizeof buf)
	57	{
	58	printf ("snprintf for %a returned %d\n", d, ret);
	59	return 1;
	60	}
	61	if (strcmp (buf, expected) == 0)
	62	return 0;
	63	else
	64	{
	65	printf ("snprintf (\"%s\", %a) returned \"%s\" not \"%s\" (%s)\n",
	66	fmt, d, buf, expected, mode_name);
67	return 1;
68	}
69	}
70
a9f8e53a JM	71	struct hex_test
	72	{
	73	double d;
	74	const char *fmt;
	75	const char rd[4], rn[4], rz[4], ru[4];
	76	};
	77
	78	static const struct hex_test hex_tests[] =
	79	{
	80	{
	81	0x1.fffffp+4, "%.1a",
	82	{ "0x1.fp+4", "0x3.fp+3", "0x7.fp+2", "0xf.fp+1" },
	83	{ "0x2.0p+4", "0x4.0p+3", "0x8.0p+2", "0x1.0p+5" },
	84	{ "0x1.fp+4", "0x3.fp+3", "0x7.fp+2", "0xf.fp+1" },
	85	{ "0x2.0p+4", "0x4.0p+3", "0x8.0p+2", "0x1.0p+5" }
	86	},
	87	{
	88	-0x1.fffffp+4, "%.1a",
	89	{ "-0x2.0p+4", "-0x4.0p+3", "-0x8.0p+2", "-0x1.0p+5" },
	90	{ "-0x2.0p+4", "-0x4.0p+3", "-0x8.0p+2", "-0x1.0p+5" },
	91	{ "-0x1.fp+4", "-0x3.fp+3", "-0x7.fp+2", "-0xf.fp+1" },
	92	{ "-0x1.fp+4", "-0x3.fp+3", "-0x7.fp+2", "-0xf.fp+1" }
	93	},
	94	{
	95	0x1.88p+4, "%.1a",
	96	{ "0x1.8p+4", "0x3.1p+3", "0x6.2p+2", "0xc.4p+1" },
	97	{ "0x1.8p+4", "0x3.1p+3", "0x6.2p+2", "0xc.4p+1" },
	98	{ "0x1.8p+4", "0x3.1p+3", "0x6.2p+2", "0xc.4p+1" },
	99	{ "0x1.9p+4", "0x3.1p+3", "0x6.2p+2", "0xc.4p+1" }
	100	},
	101	{
	102	-0x1.88p+4, "%.1a",
	103	{ "-0x1.9p+4", "-0x3.1p+3", "-0x6.2p+2", "-0xc.4p+1" },
	104	{ "-0x1.8p+4", "-0x3.1p+3", "-0x6.2p+2", "-0xc.4p+1" },
	105	{ "-0x1.8p+4", "-0x3.1p+3", "-0x6.2p+2", "-0xc.4p+1" },
	106	{ "-0x1.8p+4", "-0x3.1p+3", "-0x6.2p+2", "-0xc.4p+1" }
	107	},
	108	{
	109	0x1.78p+4, "%.1a",
	110	{ "0x1.7p+4", "0x2.fp+3", "0x5.ep+2", "0xb.cp+1" },
	111	{ "0x1.8p+4", "0x2.fp+3", "0x5.ep+2", "0xb.cp+1" },
	112	{ "0x1.7p+4", "0x2.fp+3", "0x5.ep+2", "0xb.cp+1" },
	113	{ "0x1.8p+4", "0x2.fp+3", "0x5.ep+2", "0xb.cp+1" }
	114	},
	115	{
	116	-0x1.78p+4, "%.1a",
	117	{ "-0x1.8p+4", "-0x2.fp+3", "-0x5.ep+2", "-0xb.cp+1" },
	118	{ "-0x1.8p+4", "-0x2.fp+3", "-0x5.ep+2", "-0xb.cp+1" },
	119	{ "-0x1.7p+4", "-0x2.fp+3", "-0x5.ep+2", "-0xb.cp+1" },
	120	{ "-0x1.7p+4", "-0x2.fp+3", "-0x5.ep+2", "-0xb.cp+1" }
	121	},
	122	{
	123	64.0 / 3.0, "%.1a",
	124	{ "0x1.5p+4", "0x2.ap+3", "0x5.5p+2", "0xa.ap+1" },
	125	{ "0x1.5p+4", "0x2.bp+3", "0x5.5p+2", "0xa.bp+1" },
	126	{ "0x1.5p+4", "0x2.ap+3", "0x5.5p+2", "0xa.ap+1" },
	127	{ "0x1.6p+4", "0x2.bp+3", "0x5.6p+2", "0xa.bp+1" }
	128	},
	129	{
	130	-64.0 / 3.0, "%.1a",
	131	{ "-0x1.6p+4", "-0x2.bp+3", "-0x5.6p+2", "-0xa.bp+1" },
	132	{ "-0x1.5p+4", "-0x2.bp+3", "-0x5.5p+2", "-0xa.bp+1" },
	133	{ "-0x1.5p+4", "-0x2.ap+3", "-0x5.5p+2", "-0xa.ap+1" },
	134	{ "-0x1.5p+4", "-0x2.ap+3", "-0x5.5p+2", "-0xa.ap+1" }
135	},
136	};
137
138	static int
139	test_hex_in_one_mode (double d, const char fmt, const char expected[4],
140	const char *mode_name)
141	{
142	char buf[100];
143	int ret = snprintf (buf, sizeof buf, fmt, d);
144	if (ret <= 0 \|\| ret >= (int) sizeof buf)
145	{
146	printf ("snprintf for %a returned %d\n", d, ret);
147	return 1;
148	}
149	if (strcmp (buf, expected[0]) == 0
150	\|\| strcmp (buf, expected[1]) == 0
151	\|\| strcmp (buf, expected[2]) == 0
152	\|\| strcmp (buf, expected[3]) == 0)
153	return 0;
154	else
155	{
156	printf ("snprintf (\"%s\", %a) returned \"%s\" not "
157	"\"%s\" or \"%s\" or \"%s\" or \"%s\" (%s)\n",
158	fmt, d, buf, expected[0], expected[1], expected[2], expected[3],
159	mode_name);
160	return 1;
161	}
162	}
163
784761be JM	164	static int
	165	do_test (void)
	166	{
	167	int save_round_mode = fegetround ();
	168	int result = 0;
	169
	170	for (size_t i = 0; i < sizeof (dec_tests) / sizeof (dec_tests[0]); i++)
	171	{
	172	result \|= test_dec_in_one_mode (dec_tests[i].d, dec_tests[i].fmt,
	173	dec_tests[i].rn, "default rounding mode");
	174	#ifdef FE_DOWNWARD
	175	if (!fesetround (FE_DOWNWARD))
	176	{
	177	result \|= test_dec_in_one_mode (dec_tests[i].d, dec_tests[i].fmt,
	178	dec_tests[i].rd, "FE_DOWNWARD");
	179	fesetround (save_round_mode);
	180	}
	181	#endif
	182	#ifdef FE_TOWARDZERO
	183	if (!fesetround (FE_TOWARDZERO))
	184	{
	185	result \|= test_dec_in_one_mode (dec_tests[i].d, dec_tests[i].fmt,
	186	dec_tests[i].rz, "FE_TOWARDZERO");
	187	fesetround (save_round_mode);
	188	}
	189	#endif
	190	#ifdef FE_UPWARD
	191	if (!fesetround (FE_UPWARD))
	192	{
	193	result \|= test_dec_in_one_mode (dec_tests[i].d, dec_tests[i].fmt,
	194	dec_tests[i].ru, "FE_UPWARD");
	195	fesetround (save_round_mode);
	196	}
	197	#endif
	198	}
a9f8e53a JM	199
	200	for (size_t i = 0; i < sizeof (hex_tests) / sizeof (hex_tests[0]); i++)
	201	{
	202	result \|= test_hex_in_one_mode (hex_tests[i].d, hex_tests[i].fmt,
	203	hex_tests[i].rn, "default rounding mode");
	204	#ifdef FE_DOWNWARD
	205	if (!fesetround (FE_DOWNWARD))
	206	{
	207	result \|= test_hex_in_one_mode (hex_tests[i].d, hex_tests[i].fmt,
	208	hex_tests[i].rd, "FE_DOWNWARD");
	209	fesetround (save_round_mode);
	210	}
	211	#endif
	212	#ifdef FE_TOWARDZERO
	213	if (!fesetround (FE_TOWARDZERO))
	214	{
	215	result \|= test_hex_in_one_mode (hex_tests[i].d, hex_tests[i].fmt,
	216	hex_tests[i].rz, "FE_TOWARDZERO");
	217	fesetround (save_round_mode);
	218	}
	219	#endif
	220	#ifdef FE_UPWARD
	221	if (!fesetround (FE_UPWARD))
	222	{
	223	result \|= test_hex_in_one_mode (hex_tests[i].d, hex_tests[i].fmt,
	224	hex_tests[i].ru, "FE_UPWARD");
	225	fesetround (save_round_mode);
	226	}
	227	#endif
	228	}
	229
784761be JM	230	return result;
	231	}
	232
	233	#define TEST_FUNCTION do_test ()
	234	#include "../test-skeleton.c"