diff options
Diffstat (limited to 'math')
| -rw-r--r-- | math/libm-test-driver.c | 2286 | ||||
| -rw-r--r-- | math/libm-test.inc | 2267 |
2 files changed, 2290 insertions, 2263 deletions
diff --git a/math/libm-test-driver.c b/math/libm-test-driver.c new file mode 100644 index 0000000000..1227d52d06 --- /dev/null +++ b/math/libm-test-driver.c @@ -0,0 +1,2286 @@ +/* Support code for testing libm functions. + Copyright (C) 1997-2017 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/>. */ + +/* Part of testsuite for libm. + + libm-test.inc is processed by a perl script. The resulting file has to + be included by a master file that defines: + + Macros: + FUNC(function): converts general function name (like cos) to + name with correct suffix (e.g. cosl or cosf) + FLOAT: floating point type to test + - TEST_MSG: informal message to be displayed + chooses one of the parameters as delta for testing + equality + PREFIX A macro which defines the prefix for common macros for the + type (i.e LDBL, DBL, or FLT). + LIT A function which appends the correct suffix to a literal. + TYPE_STR A macro which defines a stringitized name of the type. + FTOSTR This macro defines a function similar in type to strfromf + which converts a FLOAT to a string. */ + +/* Parameter handling is primitive in the moment: + --verbose=[0..3] for different levels of output: + 0: only error count + 1: basic report on failed tests (default) + 2: full report on all tests + -v for full output (equals --verbose=3) + -u for generation of an ULPs file + */ + +/* "Philosophy": + + This suite tests some aspects of the correct implementation of + mathematical functions in libm. Some simple, specific parameters + are tested for correctness but there's no exhaustive + testing. Handling of specific inputs (e.g. infinity, not-a-number) + is also tested. Correct handling of exceptions is checked + against. These implemented tests should check all cases that are + specified in ISO C99. + + NaN values: The payload of NaNs is set in inputs for functions + where it is significant, and is examined in the outputs of some + functions. + + Inline functions: Inlining functions should give an improvement in + speed - but not in precission. The inlined functions return + reasonable values for a reasonable range of input values. The + result is not necessarily correct for all values and exceptions are + not correctly raised in all cases. Problematic input and return + values are infinity, not-a-number and minus zero. This suite + therefore does not check these specific inputs and the exception + handling for inlined mathematical functions - just the "reasonable" + values are checked. + + Beware: The tests might fail for any of the following reasons: + - Tests are wrong + - Functions are wrong + - Floating Point Unit not working properly + - Compiler has errors + + With e.g. gcc 2.7.2.2 the test for cexp fails because of a compiler error. + + + To Do: All parameter should be numbers that can be represented as + exact floating point values. Currently some values cannot be + represented exactly and therefore the result is not the expected + result. For this we will use 36 digits so that numbers can be + represented exactly. */ + +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif + +#include <complex.h> +#include <math.h> +#include <float.h> +#include <fenv.h> +#include <limits.h> + +#include <errno.h> +#include <stdlib.h> +#include <stdint.h> +#include <stdio.h> +#include <string.h> +#include <argp.h> +#include <tininess.h> +#include <math-tests.h> +#include <math-tests-arch.h> +#include <nan-high-order-bit.h> + +/* This header defines func_ulps, func_real_ulps and func_imag_ulps + arrays. */ +#include "libm-test-ulps.h" + +/* Allow platforms without all rounding modes to test properly, + assuming they provide an __FE_UNDEFINED in <bits/fenv.h> which + causes fesetround() to return failure. */ +#ifndef FE_TONEAREST +# define FE_TONEAREST __FE_UNDEFINED +#endif +#ifndef FE_TOWARDZERO +# define FE_TOWARDZERO __FE_UNDEFINED +#endif +#ifndef FE_UPWARD +# define FE_UPWARD __FE_UNDEFINED +#endif +#ifndef FE_DOWNWARD +# define FE_DOWNWARD __FE_UNDEFINED +#endif + +/* Possible exceptions */ +#define NO_EXCEPTION 0x0 +#define INVALID_EXCEPTION 0x1 +#define DIVIDE_BY_ZERO_EXCEPTION 0x2 +#define OVERFLOW_EXCEPTION 0x4 +#define UNDERFLOW_EXCEPTION 0x8 +#define INEXACT_EXCEPTION 0x10 +/* The next flags signals that those exceptions are allowed but not required. */ +#define INVALID_EXCEPTION_OK 0x20 +#define DIVIDE_BY_ZERO_EXCEPTION_OK 0x40 +#define OVERFLOW_EXCEPTION_OK 0x80 +#define UNDERFLOW_EXCEPTION_OK 0x100 +/* For "inexact" exceptions, the default is allowed but not required + unless INEXACT_EXCEPTION or NO_INEXACT_EXCEPTION is specified. */ +#define NO_INEXACT_EXCEPTION 0x200 +#define EXCEPTIONS_OK INVALID_EXCEPTION_OK+DIVIDE_BY_ZERO_EXCEPTION_OK +/* Some special test flags, passed together with exceptions. */ +#define IGNORE_ZERO_INF_SIGN 0x400 +#define TEST_NAN_SIGN 0x800 +#define TEST_NAN_PAYLOAD 0x1000 +#define NO_TEST_INLINE 0x2000 +#define XFAIL_TEST 0x4000 +/* Indicate errno settings required or disallowed. */ +#define ERRNO_UNCHANGED 0x8000 +#define ERRNO_EDOM 0x10000 +#define ERRNO_ERANGE 0x20000 +/* Flags generated by gen-libm-test.pl, not entered here manually. */ +#define IGNORE_RESULT 0x40000 +#define NON_FINITE 0x80000 +#define TEST_SNAN 0x100000 +#define NO_TEST_MATHVEC 0x200000 + +#define TEST_NAN_PAYLOAD_CANONICALIZE (SNAN_TESTS_PRESERVE_PAYLOAD \ + ? TEST_NAN_PAYLOAD \ + : 0) + +#define __CONCATX(a,b) __CONCAT(a,b) + +#define TYPE_MIN __CONCATX (PREFIX, _MIN) +#define TYPE_TRUE_MIN __CONCATX (PREFIX, _TRUE_MIN) +#define TYPE_MAX __CONCATX (PREFIX, _MAX) +#define MIN_EXP __CONCATX (PREFIX, _MIN_EXP) +#define MAX_EXP __CONCATX (PREFIX, _MAX_EXP) +#define MANT_DIG __CONCATX (PREFIX, _MANT_DIG) + +/* Maximum character buffer to store a stringitized FLOAT value. */ +#define FSTR_MAX (128) + +#if TEST_INLINE +# define ULP_IDX __CONCATX (ULP_I_, PREFIX) +# define QTYPE_STR "i" TYPE_STR +#else +# define ULP_IDX __CONCATX (ULP_, PREFIX) +# define QTYPE_STR TYPE_STR +#endif + +/* Format specific test macros. */ +#define TEST_COND_binary32 (MANT_DIG == 24 \ + && MIN_EXP == -125 \ + && MAX_EXP == 128) + +#define TEST_COND_binary64 (MANT_DIG == 53 \ + && MIN_EXP == -1021 \ + && MAX_EXP == 1024) + +#define TEST_COND_binary128 (MANT_DIG == 113 \ + && MIN_EXP == -16381 \ + && MAX_EXP == 16384) + +#define TEST_COND_ibm128 (MANT_DIG == 106) + +#define TEST_COND_intel96 (MANT_DIG == 64 \ + && MIN_EXP == -16381 \ + && MAX_EXP == 16384) + +#define TEST_COND_m68k96 (MANT_DIG == 64 \ + && MIN_EXP == -16382 \ + && MAX_EXP == 16384) + +/* The condition ibm128-libgcc is used instead of ibm128 to mark tests + where in principle the glibc code is OK but the tests fail because + of limitations of the libgcc support for that format (e.g. GCC bug + 59666, in non-default rounding modes). */ +#define TEST_COND_ibm128_libgcc TEST_COND_ibm128 + +/* Mark a test as expected to fail for ibm128-libgcc. This is used + via XFAIL_ROUNDING_IBM128_LIBGCC, which gen-libm-test.pl transforms + appropriately for each rounding mode. */ +#define XFAIL_IBM128_LIBGCC (TEST_COND_ibm128_libgcc ? XFAIL_TEST : 0) + +/* Number of bits in NaN payload. */ +#if TEST_COND_ibm128 +# define PAYLOAD_DIG (DBL_MANT_DIG - 2) +#else +# define PAYLOAD_DIG (MANT_DIG - 2) +#endif + +/* Values underflowing only for float. */ +#if TEST_COND_binary32 +# define UNDERFLOW_EXCEPTION_FLOAT UNDERFLOW_EXCEPTION +# define UNDERFLOW_EXCEPTION_OK_FLOAT UNDERFLOW_EXCEPTION_OK +#else +# define UNDERFLOW_EXCEPTION_FLOAT 0 +# define UNDERFLOW_EXCEPTION_OK_FLOAT 0 +#endif + +/* Values underflowing only for double or types with a larger least + positive normal value. */ +#if TEST_COND_binary32 || TEST_COND_binary64 || TEST_COND_ibm128 +# define UNDERFLOW_EXCEPTION_DOUBLE UNDERFLOW_EXCEPTION +# define UNDERFLOW_EXCEPTION_OK_DOUBLE UNDERFLOW_EXCEPTION_OK +#else +# define UNDERFLOW_EXCEPTION_DOUBLE 0 +# define UNDERFLOW_EXCEPTION_OK_DOUBLE 0 +#endif + +/* Values underflowing only for IBM long double or types with a larger least + positive normal value. */ +#if TEST_COND_binary32 || TEST_COND_ibm128 +# define UNDERFLOW_EXCEPTION_LDOUBLE_IBM UNDERFLOW_EXCEPTION +#else +# define UNDERFLOW_EXCEPTION_LDOUBLE_IBM 0 +#endif + +/* Values underflowing on architectures detecting tininess before + rounding, but not on those detecting tininess after rounding. */ +#define UNDERFLOW_EXCEPTION_BEFORE_ROUNDING (TININESS_AFTER_ROUNDING \ + ? 0 \ + : UNDERFLOW_EXCEPTION) + +#if LONG_MAX == 0x7fffffff +# define TEST_COND_long32 1 +# define TEST_COND_long64 0 +#else +# define TEST_COND_long32 0 +# define TEST_COND_long64 1 +#endif +#define TEST_COND_before_rounding (!TININESS_AFTER_ROUNDING) +#define TEST_COND_after_rounding TININESS_AFTER_ROUNDING + +/* Various constants derived from pi. We must supply them precalculated for + accuracy. They are written as a series of postfix operations to keep + them concise yet somewhat readable. */ + +/* (pi * 3) / 4 */ +#define lit_pi_3_m_4_d LIT (2.356194490192344928846982537459627163) +/* pi * 3 / (4 * ln(10)) */ +#define lit_pi_3_m_4_ln10_m_d LIT (1.023282265381381010614337719073516828) +/* pi / (2 * ln(10)) */ +#define lit_pi_2_ln10_m_d LIT (0.682188176920920673742891812715677885) +/* pi / (4 * ln(10)) */ +#define lit_pi_4_ln10_m_d LIT (0.341094088460460336871445906357838943) +/* pi / ln(10) */ +#define lit_pi_ln10_d LIT (1.364376353841841347485783625431355770) +/* pi / 2 */ +#define lit_pi_2_d LITM (M_PI_2) +/* pi / 4 */ +#define lit_pi_4_d LITM (M_PI_4) +/* pi */ +#define lit_pi LITM (M_PI) + +/* Other useful constants. */ + +/* e */ +#define lit_e LITM (M_E) + +#define ulps_file_name "ULPs" /* Name of the ULPs file. */ +static FILE *ulps_file; /* File to document difference. */ +static int output_ulps; /* Should ulps printed? */ +static char *output_dir; /* Directory where generated files will be written. */ + +static int noErrors; /* number of errors */ +static int noTests; /* number of tests (without testing exceptions) */ +static int noExcTests; /* number of tests for exception flags */ +static int noErrnoTests;/* number of tests for errno values */ + +static int verbose; +static int output_max_error; /* Should the maximal errors printed? */ +static int output_points; /* Should the single function results printed? */ +static int ignore_max_ulp; /* Should we ignore max_ulp? */ + +#define plus_zero LIT (0.0) +#define minus_zero LIT (-0.0) +#define plus_infty FUNC (__builtin_inf) () +#define minus_infty -(FUNC (__builtin_inf) ()) +#define qnan_value_pl(S) FUNC (__builtin_nan) (S) +#define qnan_value qnan_value_pl ("") +#define snan_value_pl(S) FUNC (__builtin_nans) (S) +#define snan_value snan_value_pl ("") +#define max_value TYPE_MAX +#define min_value TYPE_MIN +#define min_subnorm_value TYPE_TRUE_MIN + +/* For nexttoward tests. */ +#define snan_value_ld __builtin_nansl ("") + +static FLOAT max_error, real_max_error, imag_max_error; + +static FLOAT prev_max_error, prev_real_max_error, prev_imag_max_error; + +static FLOAT max_valid_error; + +/* Sufficient numbers of digits to represent any floating-point value + unambiguously (for any choice of the number of bits in the first + hex digit, in the case of TYPE_HEX_DIG). When used with printf + formats where the precision counts only digits after the point, 1 + is subtracted from these values. */ +#define TYPE_DECIMAL_DIG __CONCATX (PREFIX, _DECIMAL_DIG) +#define TYPE_HEX_DIG ((MANT_DIG + 6) / 4) + +/* Converts VALUE (a floating-point number) to string and writes it to DEST. + PRECISION specifies the number of fractional digits that should be printed. + CONVERSION is the conversion specifier, such as in printf, e.g. 'f' or 'a'. + The output is prepended with an empty space if VALUE is non-negative. */ +static void +fmt_ftostr (char *dest, size_t size, int precision, const char *conversion, + FLOAT value) +{ + char format[64]; + char *ptr_format; + int ret; + + /* Generate the format string. */ + ptr_format = stpcpy (format, "%."); + ret = sprintf (ptr_format, "%d", precision); + ptr_format += ret; + ptr_format = stpcpy (ptr_format, conversion); + + /* Add a space to the beginning of the output string, if the floating-point + number is non-negative. This mimics the behavior of the space (' ') flag + in snprintf, which is not available on strfrom. */ + if (! signbit (value)) + { + *dest = ' '; + dest++; + size--; + } + + /* Call the float to string conversion function, e.g.: strfromd. */ + FTOSTR (dest, size, format, value); +} + +/* Compare KEY (a string, with the name of a function) with ULP (a + pointer to a struct ulp_data structure), returning a value less + than, equal to or greater than zero for use in bsearch. */ + +static int +compare_ulp_data (const void *key, const void *ulp) +{ + const char *keystr = key; + const struct ulp_data *ulpdat = ulp; + return strcmp (keystr, ulpdat->name); +} + +/* Return the ulps for NAME in array DATA with NMEMB elements, or 0 if + no ulps listed. */ + +static FLOAT +find_ulps (const char *name, const struct ulp_data *data, size_t nmemb) +{ + const struct ulp_data *entry = bsearch (name, data, nmemb, sizeof (*data), + compare_ulp_data); + if (entry == NULL) + return 0; + else + return entry->max_ulp[ULP_IDX]; +} + +static void +init_max_error (const char *name, int exact) +{ + max_error = 0; + real_max_error = 0; + imag_max_error = 0; + prev_max_error = find_ulps (name, func_ulps, + sizeof (func_ulps) / sizeof (func_ulps[0])); + prev_real_max_error = find_ulps (name, func_real_ulps, + (sizeof (func_real_ulps) + / sizeof (func_real_ulps[0]))); + prev_imag_max_error = find_ulps (name, func_imag_ulps, + (sizeof (func_imag_ulps) + / sizeof (func_imag_ulps[0]))); +#if TEST_COND_ibm128 + /* The documented accuracy of IBM long double division is 3ulp (see + libgcc/config/rs6000/ibm-ldouble-format), so do not require + better accuracy for libm functions that are exactly defined for + other formats. */ + max_valid_error = exact ? 3 : 16; +#else + max_valid_error = exact ? 0 : 9; +#endif + prev_max_error = (prev_max_error <= max_valid_error + ? prev_max_error + : max_valid_error); + prev_real_max_error = (prev_real_max_error <= max_valid_error + ? prev_real_max_error + : max_valid_error); + prev_imag_max_error = (prev_imag_max_error <= max_valid_error + ? prev_imag_max_error + : max_valid_error); + feclearexcept (FE_ALL_EXCEPT); + errno = 0; +} + +static void +set_max_error (FLOAT current, FLOAT *curr_max_error) +{ + if (current > *curr_max_error && current <= max_valid_error) + *curr_max_error = current; +} + + +/* Print a FLOAT. */ +static void +print_float (FLOAT f) +{ + /* As printf doesn't differ between a sNaN and a qNaN, do this manually. */ + if (issignaling (f)) + printf ("sNaN\n"); + else if (isnan (f)) + printf ("qNaN\n"); + else + { + char fstrn[FSTR_MAX], fstrx[FSTR_MAX]; + fmt_ftostr (fstrn, FSTR_MAX, TYPE_DECIMAL_DIG - 1, "e", f); + fmt_ftostr (fstrx, FSTR_MAX, TYPE_HEX_DIG - 1, "a", f); + printf ("%s %s\n", fstrn, fstrx); + } +} + +/* Should the message print to screen? This depends on the verbose flag, + and the test status. */ +static int +print_screen (int ok) +{ + if (output_points + && (verbose > 1 + || (verbose == 1 && ok == 0))) + return 1; + return 0; +} + + +/* Should the message print to screen? This depends on the verbose flag, + and the test status. */ +static int +print_screen_max_error (int ok) +{ + if (output_max_error + && (verbose > 1 + || ((verbose == 1) && (ok == 0)))) + return 1; + return 0; +} + +/* Update statistic counters. */ +static void +update_stats (int ok) +{ + ++noTests; + if (!ok) + ++noErrors; +} + +static void +print_function_ulps (const char *function_name, FLOAT ulp) +{ + if (output_ulps) + { + char ustrn[FSTR_MAX]; + FTOSTR (ustrn, FSTR_MAX, "%.0f", FUNC (ceil) (ulp)); + fprintf (ulps_file, "Function: \"%s\":\n", function_name); + fprintf (ulps_file, QTYPE_STR ": %s\n", ustrn); + } +} + + +static void +print_complex_function_ulps (const char *function_name, FLOAT real_ulp, + FLOAT imag_ulp) +{ + if (output_ulps) + { + char fstrn[FSTR_MAX]; + if (real_ulp != 0.0) + { + FTOSTR (fstrn, FSTR_MAX, "%.0f", FUNC (ceil) (real_ulp)); + fprintf (ulps_file, "Function: Real part of \"%s\":\n", function_name); + fprintf (ulps_file, QTYPE_STR ": %s\n", fstrn); + } + if (imag_ulp != 0.0) + { + FTOSTR (fstrn, FSTR_MAX, "%.0f", FUNC (ceil) (imag_ulp)); + fprintf (ulps_file, "Function: Imaginary part of \"%s\":\n", function_name); + fprintf (ulps_file, QTYPE_STR ": %s\n", fstrn); + } + + + } +} + + + +/* Test if Floating-Point stack hasn't changed */ +static void +fpstack_test (const char *test_name) +{ +#if defined (__i386__) || defined (__x86_64__) + static int old_stack; + int sw; + + asm ("fnstsw" : "=a" (sw)); + sw >>= 11; + sw &= 7; + + if (sw != old_stack) + { + printf ("FP-Stack wrong after test %s (%d, should be %d)\n", + test_name, sw, old_stack); + ++noErrors; + old_stack = sw; + } +#endif +} + + +static void +print_max_error (const char *func_name) +{ + int ok = 0; + + if (max_error == 0.0 || (max_error <= prev_max_error && !ignore_max_ulp)) + { + ok = 1; + } + + if (!ok) + print_function_ulps (func_name, max_error); + + + if (print_screen_max_error (ok)) + { + char mestr[FSTR_MAX], pmestr[FSTR_MAX]; + FTOSTR (mestr, FSTR_MAX, "%.0f", FUNC (ceil) (max_error)); + FTOSTR (pmestr, FSTR_MAX, "%.0f", FUNC (ceil) (prev_max_error)); + printf ("Maximal error of `%s'\n", func_name); + printf (" is : %s ulp\n", mestr); + printf (" accepted: %s ulp\n", pmestr); + } + + update_stats (ok); +} + + +static void +print_complex_max_error (const char *func_name) +{ + int real_ok = 0, imag_ok = 0, ok; + + if (real_max_error == 0 + || (real_max_error <= prev_real_max_error && !ignore_max_ulp)) + { + real_ok = 1; + } + + if (imag_max_error == 0 + || (imag_max_error <= prev_imag_max_error && !ignore_max_ulp)) + { + imag_ok = 1; + } + + ok = real_ok && imag_ok; + + if (!ok) + print_complex_function_ulps (func_name, + real_ok ? 0 : real_max_error, + imag_ok ? 0 : imag_max_error); + + if (print_screen_max_error (ok)) + { + char rmestr[FSTR_MAX], prmestr[FSTR_MAX]; + char imestr[FSTR_MAX], pimestr[FSTR_MAX]; + FTOSTR (rmestr, FSTR_MAX, "%.0f", FUNC (ceil) (real_max_error)); + FTOSTR (prmestr, FSTR_MAX, "%.0f", FUNC (ceil) (prev_real_max_error)); + FTOSTR (imestr, FSTR_MAX, "%.0f", FUNC (ceil) (imag_max_error)); + FTOSTR (pimestr, FSTR_MAX, "%.0f", FUNC (ceil) (prev_imag_max_error)); + printf ("Maximal error of real part of: %s\n", func_name); + printf (" is : %s ulp\n", rmestr); + printf (" accepted: %s ulp\n", prmestr); + printf ("Maximal error of imaginary part of: %s\n", func_name); + printf (" is : %s ulp\n", imestr); + printf (" accepted: %s ulp\n", pimestr); + } + + update_stats (ok); +} + + +#if FE_ALL_EXCEPT +/* Test whether a given exception was raised. */ +static void +test_single_exception (const char *test_name, + int exception, + int exc_flag, + int fe_flag, + const char *flag_name) +{ + int ok = 1; + if (exception & exc_flag) + { + if (fetestexcept (fe_flag)) + { + if (print_screen (1)) + printf ("Pass: %s: Exception \"%s\" set\n", test_name, flag_name); + } + else + { + ok = 0; + if (print_screen (0)) + printf ("Failure: %s: Exception \"%s\" not set\n", + test_name, flag_name); + } + } + else + { + if (fetestexcept (fe_flag)) + { + ok = 0; + if (print_screen (0)) + printf ("Failure: %s: Exception \"%s\" set\n", + test_name, flag_name); + } + else + { + if (print_screen (1)) + printf ("%s: Exception \"%s\" not set\n", test_name, + flag_name); + } + } + if (!ok) + ++noErrors; +} +#endif + +/* Test whether exceptions given by EXCEPTION are raised. Ignore thereby + allowed but not required exceptions. +*/ +static void +test_exceptions (const char *test_name, int exception) +{ + if (TEST_EXCEPTIONS && EXCEPTION_TESTS (FLOAT)) + { + ++noExcTests; +#ifdef FE_DIVBYZERO + if ((exception & DIVIDE_BY_ZERO_EXCEPTION_OK) == 0) + test_single_exception (test_name, exception, + DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO, + "Divide by zero"); +#endif +#ifdef FE_INVALID + if ((exception & INVALID_EXCEPTION_OK) == 0) + test_single_exception (test_name, exception, + INVALID_EXCEPTION, FE_INVALID, + "Invalid operation"); +#endif +#ifdef FE_OVERFLOW + if ((exception & OVERFLOW_EXCEPTION_OK) == 0) + test_single_exception (test_name, exception, OVERFLOW_EXCEPTION, + FE_OVERFLOW, "Overflow"); +#endif + /* Spurious "underflow" and "inexact" exceptions are always + allowed for IBM long double, in line with the underlying + arithmetic. */ +#ifdef FE_UNDERFLOW + if ((exception & UNDERFLOW_EXCEPTION_OK) == 0 + && !(TEST_COND_ibm128 + && (exception & UNDERFLOW_EXCEPTION) == 0)) + test_single_exception (test_name, exception, UNDERFLOW_EXCEPTION, + FE_UNDERFLOW, "Underflow"); +#endif +#ifdef FE_INEXACT + if ((exception & (INEXACT_EXCEPTION | NO_INEXACT_EXCEPTION)) != 0 + && !(TEST_COND_ibm128 + && (exception & NO_INEXACT_EXCEPTION) != 0)) + test_single_exception (test_name, exception, INEXACT_EXCEPTION, + FE_INEXACT, "Inexact"); +#endif + } + feclearexcept (FE_ALL_EXCEPT); +} + +/* Test whether errno for TEST_NAME, set to ERRNO_VALUE, has value + EXPECTED_VALUE (description EXPECTED_NAME). */ +static void +test_single_errno (const char *test_name, int errno_value, + int expected_value, const char *expected_name) +{ + if (errno_value == expected_value) + { + if (print_screen (1)) + printf ("Pass: %s: errno set to %d (%s)\n", test_name, errno_value, + expected_name); + } + else + { + ++noErrors; + if (print_screen (0)) + printf ("Failure: %s: errno set to %d, expected %d (%s)\n", + test_name, errno_value, expected_value, expected_name); + } +} + +/* Test whether errno (value ERRNO_VALUE) has been for TEST_NAME set + as required by EXCEPTIONS. */ +static void +test_errno (const char *test_name, int errno_value, int exceptions) +{ |