stdlib/tst-strtod-round-skeleton.c

   1 /* Test for correct rounding of results of strtod and related
   2    functions.
   3    Copyright (C) 2012-2017 Free Software Foundation, Inc.
   4    This file is part of the GNU C Library.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 /* Defining _LIBC_TEST ensures long double math functions are
  21    declared in the headers.  */
  22 #define _LIBC_TEST 1
  23 #include <fenv.h>
  24 #include <float.h>
  25 #include <math.h>
  26 #include <stdbool.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <math-tests.h>
  31
  32 #include "tst-strtod.h"
  33
  34 /* Non-standard macros expected to be externally defined:
  35
  36    L_(str): Pastes the appropriate modifier to a string literal str.
  37
  38    FNPFX: Expands to the correct prefix for the strtod equivalent
  39           of type CHAR. (e.g str or wcs).
  40
  41    CHAR: Expands to the string type being tested (e.g wchar_t or char).
  42
  43    STRM: Expands to a string literal suitable for printing CHAR* via
  44          printf (e.g "%s" or "%ls"). */
  45
  46 #define _CONCAT(a, b) a ## b
  47 #define CONCAT(a, b) _CONCAT (a, b)
  48
  49 #define STRTO(x) CONCAT (CONCAT (FNPFX, to), x)
  50
  51 #if LDBL_MANT_DIG == 106 && LDBL_MAX_EXP == 1024
  52 /* This is a stupid hack for IBM long double.  This test ignores
  53    inexact values for long double due to the limitations of the
  54    format.  This ensures rounding tests are ignored.  */
  55 # undef ROUNDING_TESTS_long_double
  56 # define ROUNDING_TESTS_long_double(x) 0
  57 #endif
  58
  59 /* Generator to create an FTYPE member variabled named FSUF
  60    used to populate struct member variables.  */
  61 #define FTYPE_MEMBER(FSUF, FTYPE, FTOSTR, LSUF, CSUF)  \
  62        FTYPE FSUF;
  63
  64 /* Likewise, but each member is of type bool.  */
  65 #define BOOL_MEMBER(FSUF, FTYPE, FTOSTR, LSUF, CSUF)  \
  66        bool FSUF;
  67
  68 #define STRUCT_FOREACH_FLOAT_FTYPE GEN_TEST_STRTOD_FOREACH (FTYPE_MEMBER)
  69 #define STRUCT_FOREACH_FLOAT_BOOL GEN_TEST_STRTOD_FOREACH (BOOL_MEMBER)
  70
  71 /* Define the long double choose (CHOOSE_ld) macro
  72    to select the appropriate generated long double
  73    value from the generated test data.  */
  74 #if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
  75 /* This is for the long double == double format.  */
  76 # define CHOOSE_ld(f,d,...) d
  77 #elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 && LDBL_MIN_EXP == -16381
  78 /* This is for the Intel extended float format.  */
  79 # define CHOOSE_ld(f,d,ld64i,...) ld64i
  80 #elif LDBL_MANT_DIG == 64 && LDBL_MAX_EXP == 16384 && LDBL_MIN_EXP == -16382
  81 /* This is for the Motorola extended float format.  */
  82 # define CHOOSE_ld(f,d,ld64i,ld64m,...) ld64m
  83 #elif LDBL_MANT_DIG == 106 && LDBL_MAX_EXP == 1024
  84 /* This is for the IBM extended double format.  */
  85 # define CHOOSE_ld(f,d,ld64i,ld64m,ld106,...) ld106
  86 #elif LDBL_MANT_DIG == 113 && LDBL_MAX_EXP == 16384
  87 /* This is for the IEEE binary128 format.  */
  88 # define CHOOSE_ld(f,d,ld64i,ld64m,ld106,ld113,...) ld113
  89 #else
  90 # error "unknown long double format"
  91 #endif
  92
  93 /* Add type specific choosing macros below.  */
  94 #define CHOOSE_f(f,...) f
  95 #define CHOOSE_f32(f,...) f
  96 #define CHOOSE_d(f,d,...) d
  97 #define CHOOSE_f64(f,d,...) d
  98 #define CHOOSE_f32x(f,d,...) d
  99 #define CHOOSE_f128(f,d,ld64i,ld64m,ld106,ld113,...) ld113
 100 /* long double is special, and handled above.  _Float16 would require
 101    updates to the generator to generate appropriate expectations, and
 102    updates to the test inputs to cover difficult rounding cases for
 103    _Float16.  */
 104
 105 #if __HAVE_FLOAT64X
 106 # if FLT64X_MANT_DIG == 113 && FLT64X_MAX_EXP == 16384
 107 #  define CHOOSE_f64x(f,d,ld64i,ld64m,ld106,ld113,...) ld113
 108 # elif (FLT64X_MANT_DIG == 64                   \
 109         && FLT64X_MAX_EXP == 16384              \
 110         && FLT64X_MIN_EXP == -16381)
 111 #  define CHOOSE_f64x(f,d,ld64i,...) ld64i
 112 # else
 113 #  error "unknown _Float64x format"
 114 # endif
 115 #endif
 116
 117 /* Selector for expected result field of a given type.  */
 118 #define _ENTRY(FSUF, FTYPE, FTOSTR, LSUF, CSUF, ...)  \
 119   CONCAT (CHOOSE_ ## FSUF (__VA_ARGS__), LSUF),
 120 #define ENTRY(...) \
 121   GEN_TEST_STRTOD_FOREACH (_ENTRY, __VA_ARGS__)
 122
 123 /* Selector for boolean exact tag of expected results.  */
 124 #define _XNTRY(FSUF, FTYPE, FTOSTR, LSUF, CSUF, ...)  \
 125   CHOOSE_ ## FSUF (__VA_ARGS__),
 126 #define XNTRY(...) \
 127   GEN_TEST_STRTOD_FOREACH (_XNTRY, __VA_ARGS__)
 128
 129 /* This is hacky way around the seemingly unavoidable macro
 130    expansion of the INFINITY or HUGE_VAL like macros in the
 131    above.  It is assumed the compiler will implicitly convert
 132    the infinity correctly.  */
 133 #define INF INFINITY + 0.0
 134
 135 /* This macro is used in conjunction with the output from the
 136    gen-tst-strtod-round utility to select the appropriately
 137    rounded long double value for a given format.  */
 138 #define TEST(s,                                         \
 139              fx, fd, fn, fz, fu,                        \
 140              dx, dd, dn, dz, du,                        \
 141              ld64ix, ld64id, ld64in, ld64iz, ld64iu,    \
 142              ld64mx, ld64md, ld64mn, ld64mz, ld64mu,    \
 143              ld106x, ld106d, ld106n, ld106z, ld106u,    \
 144              ld113x, ld113d, ld113n, ld113z, ld113u)    \
 145   {                                                     \
 146     L_ (s),                                             \
 147     { XNTRY (fx, dx, ld64ix, ld64mx, ld106x, ld113x) }, \
 148     {                                                   \
 149     { ENTRY (fn, dn, ld64in, ld64mn, ld106n, ld113n) }, \
 150     { ENTRY (fd, dd, ld64id, ld64md, ld106d, ld113d) }, \
 151     { ENTRY (fz, dz, ld64iz, ld64mz, ld106z, ld113z) }, \
 152     { ENTRY (fu, du, ld64iu, ld64mu, ld106u, ld113u) }  \
 153     }                                                   \
 154   }
 155
 156 struct test_exactness
 157   {
 158   STRUCT_FOREACH_FLOAT_BOOL
 159   };
 160
 161 struct test_results
 162   {
 163   STRUCT_FOREACH_FLOAT_FTYPE
 164   };
 165
 166 struct test {
 167   const CHAR *s;
 168   struct test_exactness exact;
 169   struct test_results r[4];
 170 };
 171
 172 /* Include the generated test data.  */
 173 #include "tst-strtod-round-data.h"
 174
 175 #define STRX(x) #x
 176 #define STR(x) STRX (x)
 177 #define FNPFXS STR (FNPFX)
 178
 179 #ifndef FE_INEXACT
 180 # define FE_INEXACT 0
 181 #endif
 182
 183 #define GEN_ONE_TEST(FSUF, FTYPE, FTOSTR, LSUF, CSUF)           \
 184 {                                                               \
 185   feclearexcept (FE_INEXACT);                                   \
 186   FTYPE f = STRTO (FSUF) (s, NULL);                             \
 187   if (f != expected->FSUF                                       \
 188       || (copysign ## CSUF) (1.0 ## LSUF, f)                    \
 189          != (copysign ## CSUF) (1.0 ## LSUF, expected->FSUF))   \
 190     {                                                           \
 191       char efstr[FSTRLENMAX];                                   \
 192       char fstr[FSTRLENMAX];                                    \
 193       FTOSTR (efstr, FSTRLENMAX, "%a", expected->FSUF);         \
 194       FTOSTR (fstr, FSTRLENMAX, "%a", f);                       \
 195       printf (FNPFXS "to" #FSUF  " (" STRM ") returned %s not " \
 196               "%s (%s)\n", s, fstr, efstr, mode_name);          \
 197       if (ROUNDING_TESTS (FTYPE, rnd_mode) || exact->FSUF)      \
 198         result = 1;                                             \
 199       else                                                      \
 200         printf ("ignoring this inexact result\n");              \
 201     }                                                           \
 202   else if (FE_INEXACT != 0)                                     \
 203     {                                                           \
 204       bool inexact_raised = fetestexcept (FE_INEXACT) != 0;     \
 205       if (inexact_raised != !exact->FSUF)                       \
 206         {                                                       \
 207           printf (FNPFXS "to" #FSUF  " (" STRM ") inexact %d "  \
 208                   "not %d\n", s, inexact_raised, !exact->FSUF); \
 209           if (EXCEPTION_TESTS (FTYPE))                          \
 210             result = 1;                                         \
 211           else                                                  \
 212             printf ("ignoring this exception error\n");         \
 213         }                                                       \
 214     }                                                           \
 215 }
 216
 217 static int
 218 test_in_one_mode (const CHAR *s, const struct test_results *expected,
 219                   const struct test_exactness *exact, const char *mode_name,
 220                   int rnd_mode)
 221 {
 222   int result = 0;
 223   GEN_TEST_STRTOD_FOREACH (GEN_ONE_TEST)
 224   return result;
 225 }
 226
 227 static const struct fetestmodes
 228   {
 229   const char *mode_name;
 230   int rnd_mode;
 231   int rnd_i; /* Corresponding index into r array of struct test.  */
 232   } modes[] = {
 233     { "default rounding mode", FE_TONEAREST, 0 },
 234 #ifdef FE_DOWNWARD
 235     { "FE_DOWNWARD", FE_DOWNWARD, 1 },
 236 #endif
 237 #ifdef FE_TOWARDZERO
 238     { "FE_TOWARDZERO", FE_TOWARDZERO, 2 },
 239 #endif
 240 #ifdef FE_UPWARD
 241     { "FE_UPWARD", FE_UPWARD, 3 },
 242 #endif
 243     {}
 244 };
 245
 246 static int
 247 do_test (void)
 248 {
 249   int save_round_mode __attribute__ ((unused)) = fegetround ();
 250   int result = 0;
 251   for (size_t i = 0; i < sizeof (tests) / sizeof (tests[0]); i++)
 252     {
 253       result |= test_in_one_mode (tests[i].s, &tests[i].r[modes[0].rnd_i],
 254                                   &tests[i].exact, modes[0].mode_name,
 255                                   modes[0].rnd_mode);
 256       for (const struct fetestmodes *m = &modes[1]; m->mode_name != NULL; m++)
 257         {
 258           if (!fesetround (m->rnd_mode))
 259             {
 260               result |= test_in_one_mode (tests[i].s, &tests[i].r[m->rnd_i],
 261                                           &tests[i].exact, m->mode_name,
 262                                           m->rnd_mode);
 263               fesetround (save_round_mode);
 264             }
 265         }
 266     }
 267   return result;
 268 }
 269
 270 #define TEST_FUNCTION do_test ()
 271 #include "../test-skeleton.c"