math/test-fenv.c

   1 /* Copyright (C) 1997-2024 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.  */
  17
  18 /* Tests for ISO C99 7.6: Floating-point environment  */
  19
  20 #ifndef _GNU_SOURCE
  21 # define _GNU_SOURCE
  22 #endif
  23
  24 #include <complex.h>
  25 #include <math.h>
  26 #include <float.h>
  27 #include <fenv.h>
  28
  29 #include <errno.h>
  30 #include <signal.h>
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <unistd.h>
  35 #include <sys/wait.h>
  36 #include <sys/resource.h>
  37 #include <math-tests.h>
  38
  39 /*
  40   Since not all architectures might define all exceptions, we define
  41   a private set and map accordingly.
  42 */
  43 #define NO_EXC 0
  44 #define INEXACT_EXC 0x1
  45 #define DIVBYZERO_EXC 0x2
  46 #define UNDERFLOW_EXC 0x04
  47 #define OVERFLOW_EXC 0x08
  48 #define INVALID_EXC 0x10
  49 #define ALL_EXC \
  50         (INEXACT_EXC | DIVBYZERO_EXC | UNDERFLOW_EXC | OVERFLOW_EXC \
  51          | INVALID_EXC)
  52
  53 static int count_errors;
  54
  55 #if FE_ALL_EXCEPT
  56 /* Test whether a given exception was raised.  */
  57 static void
  58 test_single_exception (short int exception,
  59                        short int exc_flag,
  60                        fexcept_t fe_flag,
  61                        const char *flag_name)
  62 {
  63   if (exception & exc_flag)
  64     {
  65       if (fetestexcept (fe_flag))
  66         printf ("  Pass: Exception \"%s\" is set\n", flag_name);
  67       else
  68         {
  69           printf ("  Fail: Exception \"%s\" is not set\n", flag_name);
  70           ++count_errors;
  71         }
  72     }
  73   else
  74     {
  75       if (fetestexcept (fe_flag))
  76         {
  77           printf ("  Fail: Exception \"%s\" is set\n", flag_name);
  78           ++count_errors;
  79         }
  80       else
  81         {
  82           printf ("  Pass: Exception \"%s\" is not set\n", flag_name);
  83         }
  84     }
  85 }
  86 #endif
  87
  88 static void
  89 test_exceptions (const char *test_name, short int exception,
  90                  int ignore_inexact)
  91 {
  92   printf ("Test: %s\n", test_name);
  93 #ifdef FE_DIVBYZERO
  94   test_single_exception (exception, DIVBYZERO_EXC, FE_DIVBYZERO,
  95                          "DIVBYZERO");
  96 #endif
  97 #ifdef FE_INVALID
  98   test_single_exception (exception, INVALID_EXC, FE_INVALID,
  99                          "INVALID");
 100 #endif
 101 #ifdef FE_INEXACT
 102   if (!ignore_inexact)
 103     test_single_exception (exception, INEXACT_EXC, FE_INEXACT,
 104                            "INEXACT");
 105 #endif
 106 #ifdef FE_UNDERFLOW
 107   test_single_exception (exception, UNDERFLOW_EXC, FE_UNDERFLOW,
 108                          "UNDERFLOW");
 109 #endif
 110 #ifdef FE_OVERFLOW
 111   test_single_exception (exception, OVERFLOW_EXC, FE_OVERFLOW,
 112                          "OVERFLOW");
 113 #endif
 114 }
 115
 116 static void
 117 print_rounding (int rounding)
 118 {
 119
 120   switch (rounding)
 121     {
 122 #ifdef FE_TONEAREST
 123     case FE_TONEAREST:
 124       printf ("TONEAREST");
 125       break;
 126 #endif
 127 #ifdef FE_UPWARD
 128     case FE_UPWARD:
 129       printf ("UPWARD");
 130       break;
 131 #endif
 132 #ifdef FE_DOWNWARD
 133     case FE_DOWNWARD:
 134       printf ("DOWNWARD");
 135       break;
 136 #endif
 137 #ifdef FE_TOWARDZERO
 138     case FE_TOWARDZERO:
 139       printf ("TOWARDZERO");
 140       break;
 141 #endif
 142     }
 143   printf (".\n");
 144 }
 145
 146
 147 static void
 148 test_rounding (const char *test_name, int rounding_mode)
 149 {
 150   int curr_rounding = fegetround ();
 151
 152   printf ("Test: %s\n", test_name);
 153   if (curr_rounding == rounding_mode)
 154     {
 155       printf ("  Pass: Rounding mode is ");
 156       print_rounding (curr_rounding);
 157     }
 158   else
 159     {
 160       ++count_errors;
 161       printf ("  Fail: Rounding mode is ");
 162       print_rounding (curr_rounding);
 163     }
 164 }
 165
 166
 167 #if FE_ALL_EXCEPT
 168 static void
 169 set_single_exc (const char *test_name, int fe_exc, fexcept_t exception)
 170 {
 171   char str[200];
 172   /* The standard allows the inexact exception to be set together with the
 173      underflow and overflow exceptions.  So ignore the inexact flag if the
 174      others are raised.  */
 175   int ignore_inexact = (fe_exc & (UNDERFLOW_EXC | OVERFLOW_EXC)) != 0;
 176
 177   strcpy (str, test_name);
 178   strcat (str, ": set flag, with rest not set");
 179   feclearexcept (FE_ALL_EXCEPT);
 180   feraiseexcept (exception);
 181   test_exceptions (str, fe_exc, ignore_inexact);
 182
 183   strcpy (str, test_name);
 184   strcat (str, ": clear flag, rest also unset");
 185   feclearexcept (exception);
 186   test_exceptions (str, NO_EXC, ignore_inexact);
 187
 188   strcpy (str, test_name);
 189   strcat (str, ": set flag, with rest set");
 190   feraiseexcept (FE_ALL_EXCEPT ^ exception);
 191   feraiseexcept (exception);
 192   test_exceptions (str, ALL_EXC, 0);
 193
 194   strcpy (str, test_name);
 195   strcat (str, ": clear flag, leave rest set");
 196   feclearexcept (exception);
 197   test_exceptions (str, ALL_EXC ^ fe_exc, 0);
 198 }
 199
 200 static void
 201 update_single_exc (const char *test_name, const fenv_t *envp, int fe_exc,
 202                    int fe_exc_clear, int exception)
 203 {
 204   char str[200];
 205   /* The standard allows the inexact exception to be set together with the
 206      underflow and overflow exceptions.  So ignore the inexact flag if the
 207      others are raised.  */
 208   int ignore_inexact = (fe_exc & (UNDERFLOW_EXC | OVERFLOW_EXC)) != 0;
 209
 210   strcpy (str, test_name);
 211   strcat (str, ": set flag, with rest not set");
 212   feclearexcept (FE_ALL_EXCEPT);
 213   feraiseexcept (exception);
 214   feupdateenv (envp);
 215   test_exceptions (str, fe_exc, ignore_inexact);
 216
 217   strcpy (str, test_name);
 218   strcat (str, ": clear flag, rest also unset");
 219   feclearexcept (exception);
 220   feupdateenv (envp);
 221   test_exceptions (str, fe_exc_clear, ignore_inexact);
 222 }
 223 #endif
 224
 225 static void
 226 fe_tests (void)
 227 {
 228   /* clear all exceptions and test if all are cleared */
 229   feclearexcept (FE_ALL_EXCEPT);
 230   test_exceptions ("feclearexcept (FE_ALL_EXCEPT) clears all exceptions",
 231                    NO_EXC, 0);
 232
 233   /* Skip further tests here if exceptions not supported.  */
 234   if (!EXCEPTION_TESTS (float) && FE_ALL_EXCEPT != 0)
 235     return;
 236   /* raise all exceptions and test if all are raised */
 237   feraiseexcept (FE_ALL_EXCEPT);
 238   test_exceptions ("feraiseexcept (FE_ALL_EXCEPT) raises all exceptions",
 239                    ALL_EXC, 0);
 240   feclearexcept (FE_ALL_EXCEPT);
 241
 242 #ifdef FE_DIVBYZERO
 243   set_single_exc ("Set/Clear FE_DIVBYZERO", DIVBYZERO_EXC, FE_DIVBYZERO);
 244 #endif
 245 #ifdef FE_INVALID
 246   set_single_exc ("Set/Clear FE_INVALID", INVALID_EXC, FE_INVALID);
 247 #endif
 248 #ifdef FE_INEXACT
 249   set_single_exc ("Set/Clear FE_INEXACT", INEXACT_EXC, FE_INEXACT);
 250 #endif
 251 #ifdef FE_UNDERFLOW
 252   set_single_exc ("Set/Clear FE_UNDERFLOW", UNDERFLOW_EXC, FE_UNDERFLOW);
 253 #endif
 254 #ifdef FE_OVERFLOW
 255   set_single_exc ("Set/Clear FE_OVERFLOW", OVERFLOW_EXC, FE_OVERFLOW);
 256 #endif
 257 }
 258
 259 #if FE_ALL_EXCEPT
 260 static const char *
 261 funcname (int (*func)(const fenv_t *))
 262 {
 263   if (func == fesetenv)
 264     return "fesetenv";
 265   else if (func == feupdateenv)
 266     return "feupdateenv";
 267   __builtin_unreachable ();
 268 }
 269
 270 /* Test that program aborts with no masked interrupts */
 271 static void
 272 feenv_nomask_test (const char *flag_name, int fe_exc, int (*func)(const fenv_t *))
 273 {
 274 # if defined FE_NOMASK_ENV
 275   int status;
 276   pid_t pid;
 277
 278   if (!EXCEPTION_ENABLE_SUPPORTED (FE_ALL_EXCEPT)
 279       && func (FE_NOMASK_ENV) != 0)
 280     {
 281       printf ("Test: not testing FE_NOMASK_ENV, it isn't implemented.\n");
 282       return;
 283     }
 284
 285   printf ("Test: after %s (FE_NOMASK_ENV) processes will abort\n", funcname (func));
 286   printf ("      when feraiseexcept (%s) is called.\n", flag_name);
 287   pid = fork ();
 288   if (pid == 0)
 289     {
 290 #  ifdef RLIMIT_CORE
 291       /* Try to avoid dumping core.  */
 292       struct rlimit core_limit;
 293       core_limit.rlim_cur = 0;
 294       core_limit.rlim_max = 0;
 295       setrlimit (RLIMIT_CORE, &core_limit);
 296 #  endif
 297
 298       fesetenv (FE_NOMASK_ENV);
 299       feraiseexcept (fe_exc);
 300       exit (2);
 301     }
 302   else if (pid < 0)
 303     {
 304       if (errno != ENOSYS)
 305         {
 306           printf ("  Fail: Could not fork.\n");
 307           ++count_errors;
 308         }
 309       else
 310         printf ("  `fork' not implemented, test ignored.\n");
 311     }
 312   else {
 313     if (waitpid (pid, &status, 0) != pid)
 314       {
 315         printf ("  Fail: waitpid call failed.\n");
 316         ++count_errors;
 317       }
 318     else if (WIFSIGNALED (status) && WTERMSIG (status) == SIGFPE)
 319       printf ("  Pass: Process received SIGFPE.\n");
 320     else
 321       {
 322         printf ("  Fail: Process didn't receive signal and exited with status %d.\n",
 323                 status);
 324         ++count_errors;
 325       }
 326   }
 327 # endif
 328 }
 329
 330 /* Test that program doesn't abort with default environment */
 331 static void
 332 feenv_mask_test (const char *flag_name, int fe_exc, int (*func)(const fenv_t *))
 333 {
 334   int status;
 335   pid_t pid;
 336
 337   printf ("Test: after %s (FE_DFL_ENV) processes will not abort\n", funcname (func));
 338   printf ("      when feraiseexcept (%s) is called.\n", flag_name);
 339   pid = fork ();
 340   if (pid == 0)
 341     {
 342 #ifdef RLIMIT_CORE
 343       /* Try to avoid dumping core.  */
 344       struct rlimit core_limit;
 345       core_limit.rlim_cur = 0;
 346       core_limit.rlim_max = 0;
 347       setrlimit (RLIMIT_CORE, &core_limit);
 348 #endif
 349
 350       func (FE_DFL_ENV);
 351       feraiseexcept (fe_exc);
 352       exit (2);
 353     }
 354   else if (pid < 0)
 355     {
 356       if (errno != ENOSYS)
 357         {
 358           printf ("  Fail: Could not fork.\n");
 359           ++count_errors;
 360         }
 361       else
 362         printf ("  `fork' not implemented, test ignored.\n");
 363     }
 364   else {
 365     if (waitpid (pid, &status, 0) != pid)
 366       {
 367         printf ("  Fail: waitpid call failed.\n");
 368         ++count_errors;
 369       }
 370     else if (WIFEXITED (status) && WEXITSTATUS (status) == 2)
 371       printf ("  Pass: Process exited normally.\n");
 372     else
 373       {
 374         printf ("  Fail: Process exited abnormally with status %d.\n",
 375                 status);
 376         ++count_errors;
 377       }
 378   }
 379 }
 380
 381 /* Test that program aborts with no masked interrupts */
 382 static void
 383 feexcp_nomask_test (const char *flag_name, int fe_exc)
 384 {
 385   int status;
 386   pid_t pid;
 387
 388   if (!EXCEPTION_ENABLE_SUPPORTED (fe_exc) && feenableexcept (fe_exc) == -1)
 389     {
 390       printf ("Test: not testing feenableexcept, it isn't implemented.\n");
 391       return;
 392     }
 393
 394   printf ("Test: after feenableexcept (%s) processes will abort\n",
 395           flag_name);
 396   printf ("      when feraiseexcept (%s) is called.\n", flag_name);
 397   pid = fork ();
 398   if (pid == 0)
 399     {
 400 #ifdef RLIMIT_CORE
 401       /* Try to avoid dumping core.  */
 402       struct rlimit core_limit;
 403       core_limit.rlim_cur = 0;
 404       core_limit.rlim_max = 0;
 405       setrlimit (RLIMIT_CORE, &core_limit);
 406 #endif
 407
 408       fedisableexcept (FE_ALL_EXCEPT);
 409       feenableexcept (fe_exc);
 410       feraiseexcept (fe_exc);
 411       exit (2);
 412     }
 413   else if (pid < 0)
 414     {
 415       if (errno != ENOSYS)
 416         {
 417           printf ("  Fail: Could not fork.\n");
 418           ++count_errors;
 419         }
 420       else
 421         printf ("  `fork' not implemented, test ignored.\n");
 422     }
 423   else {
 424     if (waitpid (pid, &status, 0) != pid)
 425       {
 426         printf ("  Fail: waitpid call failed.\n");
 427         ++count_errors;
 428       }
 429     else if (WIFSIGNALED (status) && WTERMSIG (status) == SIGFPE)
 430       printf ("  Pass: Process received SIGFPE.\n");
 431     else
 432       {
 433         printf ("  Fail: Process didn't receive signal and exited with status %d.\n",
 434                 status);
 435         ++count_errors;
 436       }
 437   }
 438 }
 439
 440 /* Test that program doesn't abort with exception.  */
 441 static void
 442 feexcp_mask_test (const char *flag_name, int fe_exc)
 443 {
 444   int status;
 445   int exception;
 446   pid_t pid;
 447
 448   printf ("Test: after fedisableexcept (%s) processes will not abort\n",
 449           flag_name);
 450   printf ("      when feraiseexcept (%s) is called.\n", flag_name);
 451   pid = fork ();
 452   if (pid == 0)
 453     {
 454 #ifdef RLIMIT_CORE
 455       /* Try to avoid dumping core.  */
 456       struct rlimit core_limit;
 457       core_limit.rlim_cur = 0;
 458       core_limit.rlim_max = 0;
 459       setrlimit (RLIMIT_CORE, &core_limit);
 460 #endif
 461       feenableexcept (FE_ALL_EXCEPT);
 462       exception = fe_exc;
 463 #ifdef FE_INEXACT
 464       /* The standard allows the inexact exception to be set together with the
 465          underflow and overflow exceptions.  So add FE_INEXACT to the set of
 466          exceptions to be disabled if we will be raising underflow or
 467          overflow.  */
 468 # ifdef FE_OVERFLOW
 469       if (fe_exc & FE_OVERFLOW)
 470         exception |= FE_INEXACT;
 471 # endif
 472 # ifdef FE_UNDERFLOW
 473       if (fe_exc & FE_UNDERFLOW)
 474         exception |= FE_INEXACT;
 475 # endif
 476 #endif
 477       fedisableexcept (exception);
 478       feraiseexcept (fe_exc);
 479       exit (2);
 480     }
 481   else if (pid < 0)
 482     {
 483       if (errno != ENOSYS)
 484         {
 485           printf ("  Fail: Could not fork.\n");
 486           ++count_errors;
 487         }
 488       else
 489         printf ("  `fork' not implemented, test ignored.\n");
 490     }
 491   else {
 492     if (waitpid (pid, &status, 0) != pid)
 493       {
 494         printf ("  Fail: waitpid call failed.\n");
 495         ++count_errors;
 496       }
 497     else if (WIFEXITED (status) && WEXITSTATUS (status) == 2)
 498       printf ("  Pass: Process exited normally.\n");
 499     else
 500       {
 501         printf ("  Fail: Process exited abnormally with status %d.\n",
 502                 status);
 503         ++count_errors;
 504       }
 505   }
 506 }
 507
 508
 509 /* Tests for feenableexcept/fedisableexcept/fegetexcept.  */
 510 static void
 511 feenable_test (const char *flag_name, int fe_exc)
 512 {
 513   int excepts;
 514
 515   printf ("Tests for feenableexcepts etc. with flag %s\n", flag_name);
 516
 517   /* First disable all exceptions.  */
 518   if (fedisableexcept (FE_ALL_EXCEPT) == -1)
 519     {
 520       printf ("Test: fedisableexcept (FE_ALL_EXCEPT) failed\n");
 521       ++count_errors;
 522       /* If this fails, the other tests don't make sense.  */
 523       return;
 524     }
 525   excepts = fegetexcept ();
 526   if (excepts != 0)
 527     {
 528       printf ("Test: fegetexcept (%s) failed, return should be 0, is %d\n",
 529               flag_name, excepts);
 530       ++count_errors;
 531     }
 532   excepts = feenableexcept (fe_exc);
 533   if (!EXCEPTION_ENABLE_SUPPORTED (fe_exc) && excepts == -1)
 534     {
 535       printf ("Test: not testing feenableexcept, it isn't implemented.\n");
 536       return;
 537     }
 538   if (excepts == -1)
 539     {
 540       printf ("Test: feenableexcept (%s) failed\n", flag_name);
 541       ++count_errors;
 542       return;
 543     }
 544   if (excepts != 0)
 545     {
 546       printf ("Test: feenableexcept (%s) failed, return should be 0, is %x\n",
 547               flag_name, excepts);
 548       ++count_errors;
 549     }
 550
 551   excepts = fegetexcept ();
 552   if (excepts != fe_exc)
 553     {
 554       printf ("Test: fegetexcept (%s) failed, return should be 0x%x, is 0x%x\n",
 555               flag_name, fe_exc, excepts);
 556       ++count_errors;
 557     }
 558
 559   /* And now disable the exception again.  */
 560   excepts = fedisableexcept (fe_exc);
 561   if (excepts == -1)
 562     {
 563       printf ("Test: fedisableexcept (%s) failed\n", flag_name);
 564       ++count_errors;
 565       return;
 566     }
 567   if (excepts != fe_exc)
 568     {
 569       printf ("Test: fedisableexcept (%s) failed, return should be 0x%x, is 0x%x\n",
 570               flag_name, fe_exc, excepts);
 571       ++count_errors;
 572     }
 573
 574   excepts = fegetexcept ();
 575   if (excepts != 0)
 576     {
 577       printf ("Test: fegetexcept (%s) failed, return should be 0, is 0x%x\n",
 578               flag_name, excepts);
 579       ++count_errors;
 580     }
 581
 582   /* Now the other way round: Enable all exceptions and disable just this one.  */
 583   if (feenableexcept (FE_ALL_EXCEPT) == -1)
 584     {
 585       printf ("Test: feenableexcept (FE_ALL_EXCEPT) failed\n");
 586       ++count_errors;
 587       /* If this fails, the other tests don't make sense.  */
 588       return;
 589     }
 590
 591   excepts = fegetexcept ();
 592   if (excepts != FE_ALL_EXCEPT)
 593     {
 594       printf ("Test: fegetexcept (%s) failed, return should be 0x%x, is 0x%x\n",
 595               flag_name, FE_ALL_EXCEPT, excepts);
 596       ++count_errors;
 597     }
 598
 599   excepts = fedisableexcept (fe_exc);
 600   if (excepts == -1)
 601     {
 602       printf ("Test: fedisableexcept (%s) failed\n", flag_name);
 603       ++count_errors;
 604       return;
 605     }
 606   if (excepts != FE_ALL_EXCEPT)
 607     {
 608       printf ("Test: fedisableexcept (%s) failed, return should be 0, is 0x%x\n",
 609               flag_name, excepts);
 610       ++count_errors;
 611     }
 612
 613   excepts = fegetexcept ();
 614   if (excepts != (FE_ALL_EXCEPT & ~fe_exc))
 615     {
 616       printf ("Test: fegetexcept (%s) failed, return should be 0x%x, is 0x%x\n",
 617               flag_name, (FE_ALL_EXCEPT & ~fe_exc), excepts);
 618       ++count_errors;
 619     }
 620
 621   /* And now enable the exception again.  */
 622   excepts = feenableexcept (fe_exc);
 623   if (excepts == -1)
 624     {
 625       printf ("Test: feenableexcept (%s) failed\n", flag_name);
 626       ++count_errors;
 627       return;
 628     }
 629   if (excepts != (FE_ALL_EXCEPT & ~fe_exc))
 630     {
 631       printf ("Test: feenableexcept (%s) failed, return should be 0, is 0x%x\n",
 632               flag_name, excepts);
 633       ++count_errors;
 634     }
 635
 636   excepts = fegetexcept ();
 637   if (excepts != FE_ALL_EXCEPT)
 638     {
 639       printf ("Test: fegetexcept (%s) failed, return should be 0x%x, is 0x%x\n",
 640               flag_name, FE_ALL_EXCEPT, excepts);
 641       ++count_errors;
 642     }
 643   feexcp_nomask_test (flag_name, fe_exc);
 644   feexcp_mask_test (flag_name, fe_exc);
 645
 646 }
 647
 648
 649 static void
 650 fe_single_test (const char *flag_name, int fe_exc)
 651 {
 652   feenv_nomask_test (flag_name, fe_exc, fesetenv);
 653   feenv_mask_test (flag_name, fe_exc, fesetenv);
 654   feenable_test (flag_name, fe_exc);
 655 }
 656
 657
 658 static void
 659 feupdate_single_test (const char *flag_name, int fe_exc)
 660 {
 661   feenv_nomask_test (flag_name, fe_exc, feupdateenv);
 662   feenv_mask_test (flag_name, fe_exc, feupdateenv);
 663 }
 664 #endif
 665
 666
 667 static void
 668 feenv_tests (void)
 669 {
 670   /* We might have some exceptions still set.  */
 671   feclearexcept (FE_ALL_EXCEPT);
 672
 673 #ifdef FE_DIVBYZERO
 674   fe_single_test ("FE_DIVBYZERO", FE_DIVBYZERO);
 675 #endif
 676 #ifdef FE_INVALID
 677   fe_single_test ("FE_INVALID", FE_INVALID);
 678 #endif
 679 #ifdef FE_INEXACT
 680   fe_single_test ("FE_INEXACT", FE_INEXACT);
 681 #endif
 682 #ifdef FE_UNDERFLOW
 683   fe_single_test ("FE_UNDERFLOW", FE_UNDERFLOW);
 684 #endif
 685 #ifdef FE_OVERFLOW
 686   fe_single_test ("FE_OVERFLOW", FE_OVERFLOW);
 687 #endif
 688   fesetenv (FE_DFL_ENV);
 689 }
 690
 691 #if FE_ALL_EXCEPT
 692 static void
 693 feupdateenv_single_test (const char *test_name, int fe_exc, int exception)
 694 {
 695   char str[100];
 696   fenv_t env;
 697   int res;
 698
 699   snprintf (str, sizeof str, "feupdateenv %s and FL_DFL_ENV", test_name);
 700   update_single_exc (str, FE_DFL_ENV, fe_exc, NO_EXC, exception);
 701
 702   feraiseexcept (FE_ALL_EXCEPT);
 703   res = fegetenv (&env);
 704   if (res != 0)
 705     {
 706       printf ("fegetenv failed: %d\n", res);
 707       ++count_errors;
 708       return;
 709     }
 710
 711   snprintf (str, sizeof str, "feupdateenv %s and FE_ALL_EXCEPT", test_name);
 712   update_single_exc (str, &env, ALL_EXC, ALL_EXC, exception);
 713 }
 714 #endif
 715
 716 static void
 717 feupdateenv_tests (void)
 718 {
 719   /* We might have some exceptions still set.  */
 720   feclearexcept (FE_ALL_EXCEPT);
 721
 722 #ifdef FE_DIVBYZERO
 723   feupdate_single_test ("FE_DIVBYZERO", FE_DIVBYZERO);
 724 #endif
 725 #ifdef FE_INVALID
 726   feupdate_single_test ("FE_INVALID", FE_INVALID);
 727 #endif
 728 #ifdef FE_INEXACT
 729   feupdate_single_test ("FE_INEXACT", FE_INEXACT);
 730 #endif
 731 #ifdef FE_UNDERFLOW
 732   feupdate_single_test ("FE_UNDERFLOW", FE_UNDERFLOW);
 733 #endif
 734 #ifdef FE_OVERFLOW
 735   feupdate_single_test ("FE_OVERFLOW", FE_OVERFLOW);
 736 #endif
 737
 738 #ifdef FE_DIVBYZERO
 739   feupdateenv_single_test ("DIVBYZERO", DIVBYZERO_EXC, FE_DIVBYZERO);
 740 #endif
 741 #ifdef FE_INVALID
 742   feupdateenv_single_test ("INVALID", INVALID_EXC, FE_INVALID);
 743 #endif
 744 #ifdef FE_INEXACT
 745   feupdateenv_single_test ("INEXACT", INEXACT_EXC, FE_INEXACT);
 746 #endif
 747 #ifdef FE_UNDERFLOW
 748   feupdateenv_single_test ("UNDERFLOW", UNDERFLOW_EXC, FE_UNDERFLOW);
 749 #endif
 750 #ifdef FE_OVERFLOW
 751   feupdateenv_single_test ("OVERFLOW", OVERFLOW_EXC, FE_OVERFLOW);
 752 #endif
 753
 754   feupdateenv (FE_DFL_ENV);
 755 }
 756
 757
 758 static void
 759 feholdexcept_tests (void)
 760 {
 761   fenv_t saved, saved2;
 762   int res;
 763
 764   feclearexcept (FE_ALL_EXCEPT);
 765   fedisableexcept (FE_ALL_EXCEPT);
 766 #ifdef FE_DIVBYZERO
 767   feraiseexcept (FE_DIVBYZERO);
 768 #endif
 769   if (EXCEPTION_TESTS (float))
 770     test_exceptions ("feholdexcept_tests FE_DIVBYZERO test",
 771                      DIVBYZERO_EXC, 0);
 772   res = feholdexcept (&saved);
 773   if (res != 0)
 774     {
 775       printf ("feholdexcept failed: %d\n", res);
 776       ++count_errors;
 777     }
 778 #if defined FE_TONEAREST && defined FE_TOWARDZERO
 779   res = fesetround (FE_TOWARDZERO);
 780   if (res != 0 && ROUNDING_TESTS (float, FE_TOWARDZERO))
 781     {
 782       printf ("fesetround failed: %d\n", res);
 783       ++count_errors;
 784     }
 785 #endif
 786   test_exceptions ("feholdexcept_tests 0 test", NO_EXC, 0);
 787 #ifdef FE_INVALID
 788   feraiseexcept (FE_INVALID);
 789   if (EXCEPTION_TESTS (float))
 790     test_exceptions ("feholdexcept_tests FE_INVALID test",
 791                      INVALID_EXC, 0);
 792 #endif
 793   res = feupdateenv (&saved);
 794   if (res != 0)
 795     {
 796       printf ("feupdateenv failed: %d\n", res);
 797       ++count_errors;
 798     }
 799 #if defined FE_TONEAREST && defined FE_TOWARDZERO
 800   res = fegetround ();
 801   if (res != FE_TONEAREST)
 802     {
 803       printf ("feupdateenv didn't restore rounding mode: %d\n", res);
 804       ++count_errors;
 805     }
 806 #endif
 807   if (EXCEPTION_TESTS (float))
 808     test_exceptions ("feholdexcept_tests FE_DIVBYZERO|FE_INVALID test",
 809                      DIVBYZERO_EXC | INVALID_EXC, 0);
 810   feclearexcept (FE_ALL_EXCEPT);
 811 #ifdef FE_INVALID
 812   feraiseexcept (FE_INVALID);
 813 #endif
 814 #if defined FE_TONEAREST && defined FE_UPWARD
 815   res = fesetround (FE_UPWARD);
 816   if (res != 0 && ROUNDING_TESTS (float, FE_UPWARD))
 817     {
 818       printf ("fesetround failed: %d\n", res);
 819       ++count_errors;
 820     }
 821 #endif
 822   res = feholdexcept (&saved2);
 823   if (res != 0)
 824     {
 825       printf ("feholdexcept failed: %d\n", res);
 826       ++count_errors;
 827     }
 828 #if defined FE_TONEAREST && defined FE_UPWARD
 829   res = fesetround (FE_TONEAREST);
 830   if (res != 0)
 831     {
 832       printf ("fesetround failed: %d\n", res);
 833       ++count_errors;
 834     }
 835 #endif
 836   test_exceptions ("feholdexcept_tests 0 2nd test", NO_EXC, 0);
 837 #ifdef FE_INEXACT
 838   feraiseexcept (FE_INEXACT);
 839   if (EXCEPTION_TESTS (float))
 840     test_exceptions ("feholdexcept_tests FE_INEXACT test",
 841                      INEXACT_EXC, 0);
 842 #endif
 843   res = feupdateenv (&saved2);
 844   if (res != 0)
 845     {
 846       printf ("feupdateenv failed: %d\n", res);
 847       ++count_errors;
 848     }
 849 #if defined FE_TONEAREST && defined FE_UPWARD
 850   res = fegetround ();
 851   if (res != FE_UPWARD && ROUNDING_TESTS (float, FE_UPWARD))
 852     {
 853       printf ("feupdateenv didn't restore rounding mode: %d\n", res);
 854       ++count_errors;
 855     }
 856   fesetround (FE_TONEAREST);
 857 #endif
 858   if (EXCEPTION_TESTS (float))
 859     test_exceptions ("feholdexcept_tests FE_INEXACT|FE_INVALID test",
 860                      INVALID_EXC | INEXACT_EXC, 0);
 861   feclearexcept (FE_ALL_EXCEPT);
 862 }
 863
 864
 865 /* IEC 559 and ISO C99 define a default startup environment */
 866 static void
 867 initial_tests (void)
 868 {
 869   test_exceptions ("Initially all exceptions should be cleared",
 870                    NO_EXC, 0);
 871 #ifdef FE_TONEAREST
 872   test_rounding ("Rounding direction should be initialized to nearest",
 873                  FE_TONEAREST);
 874 #endif
 875 }
 876
 877 static int
 878 do_test (void)
 879 {
 880   initial_tests ();
 881   fe_tests ();
 882   feenv_tests ();
 883   feholdexcept_tests ();
 884   feupdateenv_tests ();
 885
 886   if (count_errors)
 887     {
 888       printf ("\n%d errors occurred.\n", count_errors);
 889       exit (1);
 890     }
 891   printf ("\n All tests passed successfully.\n");
 892   return 0;
 893 }
 894
 895 #include <support/test-driver.c>