math/test-fenv.c

   1 /* Copyright (C) 1997-2023 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 #endif
 200
 201 static void
 202 fe_tests (void)
 203 {
 204   /* clear all exceptions and test if all are cleared */
 205   feclearexcept (FE_ALL_EXCEPT);
 206   test_exceptions ("feclearexcept (FE_ALL_EXCEPT) clears all exceptions",
 207                    NO_EXC, 0);
 208
 209   /* Skip further tests here if exceptions not supported.  */
 210   if (!EXCEPTION_TESTS (float) && FE_ALL_EXCEPT != 0)
 211     return;
 212   /* raise all exceptions and test if all are raised */
 213   feraiseexcept (FE_ALL_EXCEPT);
 214   test_exceptions ("feraiseexcept (FE_ALL_EXCEPT) raises all exceptions",
 215                    ALL_EXC, 0);
 216   feclearexcept (FE_ALL_EXCEPT);
 217
 218 #ifdef FE_DIVBYZERO
 219   set_single_exc ("Set/Clear FE_DIVBYZERO", DIVBYZERO_EXC, FE_DIVBYZERO);
 220 #endif
 221 #ifdef FE_INVALID
 222   set_single_exc ("Set/Clear FE_INVALID", INVALID_EXC, FE_INVALID);
 223 #endif
 224 #ifdef FE_INEXACT
 225   set_single_exc ("Set/Clear FE_INEXACT", INEXACT_EXC, FE_INEXACT);
 226 #endif
 227 #ifdef FE_UNDERFLOW
 228   set_single_exc ("Set/Clear FE_UNDERFLOW", UNDERFLOW_EXC, FE_UNDERFLOW);
 229 #endif
 230 #ifdef FE_OVERFLOW
 231   set_single_exc ("Set/Clear FE_OVERFLOW", OVERFLOW_EXC, FE_OVERFLOW);
 232 #endif
 233 }
 234
 235 #if FE_ALL_EXCEPT
 236 /* Test that program aborts with no masked interrupts */
 237 static void
 238 feenv_nomask_test (const char *flag_name, int fe_exc)
 239 {
 240 # if defined FE_NOMASK_ENV
 241   int status;
 242   pid_t pid;
 243
 244   if (!EXCEPTION_ENABLE_SUPPORTED (FE_ALL_EXCEPT)
 245       && fesetenv (FE_NOMASK_ENV) != 0)
 246     {
 247       printf ("Test: not testing FE_NOMASK_ENV, it isn't implemented.\n");
 248       return;
 249     }
 250
 251   printf ("Test: after fesetenv (FE_NOMASK_ENV) processes will abort\n");
 252   printf ("      when feraiseexcept (%s) is called.\n", flag_name);
 253   pid = fork ();
 254   if (pid == 0)
 255     {
 256 #  ifdef RLIMIT_CORE
 257       /* Try to avoid dumping core.  */
 258       struct rlimit core_limit;
 259       core_limit.rlim_cur = 0;
 260       core_limit.rlim_max = 0;
 261       setrlimit (RLIMIT_CORE, &core_limit);
 262 #  endif
 263
 264       fesetenv (FE_NOMASK_ENV);
 265       feraiseexcept (fe_exc);
 266       exit (2);
 267     }
 268   else if (pid < 0)
 269     {
 270       if (errno != ENOSYS)
 271         {
 272           printf ("  Fail: Could not fork.\n");
 273           ++count_errors;
 274         }
 275       else
 276         printf ("  `fork' not implemented, test ignored.\n");
 277     }
 278   else {
 279     if (waitpid (pid, &status, 0) != pid)
 280       {
 281         printf ("  Fail: waitpid call failed.\n");
 282         ++count_errors;
 283       }
 284     else if (WIFSIGNALED (status) && WTERMSIG (status) == SIGFPE)
 285       printf ("  Pass: Process received SIGFPE.\n");
 286     else
 287       {
 288         printf ("  Fail: Process didn't receive signal and exited with status %d.\n",
 289                 status);
 290         ++count_errors;
 291       }
 292   }
 293 # endif
 294 }
 295
 296 /* Test that program doesn't abort with default environment */
 297 static void
 298 feenv_mask_test (const char *flag_name, int fe_exc)
 299 {
 300   int status;
 301   pid_t pid;
 302
 303   printf ("Test: after fesetenv (FE_DFL_ENV) processes will not abort\n");
 304   printf ("      when feraiseexcept (%s) is called.\n", flag_name);
 305   pid = fork ();
 306   if (pid == 0)
 307     {
 308 #ifdef RLIMIT_CORE
 309       /* Try to avoid dumping core.  */
 310       struct rlimit core_limit;
 311       core_limit.rlim_cur = 0;
 312       core_limit.rlim_max = 0;
 313       setrlimit (RLIMIT_CORE, &core_limit);
 314 #endif
 315
 316       fesetenv (FE_DFL_ENV);
 317       feraiseexcept (fe_exc);
 318       exit (2);
 319     }
 320   else if (pid < 0)
 321     {
 322       if (errno != ENOSYS)
 323         {
 324           printf ("  Fail: Could not fork.\n");
 325           ++count_errors;
 326         }
 327       else
 328         printf ("  `fork' not implemented, test ignored.\n");
 329     }
 330   else {
 331     if (waitpid (pid, &status, 0) != pid)
 332       {
 333         printf ("  Fail: waitpid call failed.\n");
 334         ++count_errors;
 335       }
 336     else if (WIFEXITED (status) && WEXITSTATUS (status) == 2)
 337       printf ("  Pass: Process exited normally.\n");
 338     else
 339       {
 340         printf ("  Fail: Process exited abnormally with status %d.\n",
 341                 status);
 342         ++count_errors;
 343       }
 344   }
 345 }
 346
 347 /* Test that program aborts with no masked interrupts */
 348 static void
 349 feexcp_nomask_test (const char *flag_name, int fe_exc)
 350 {
 351   int status;
 352   pid_t pid;
 353
 354   if (!EXCEPTION_ENABLE_SUPPORTED (fe_exc) && feenableexcept (fe_exc) == -1)
 355     {
 356       printf ("Test: not testing feenableexcept, it isn't implemented.\n");
 357       return;
 358     }
 359
 360   printf ("Test: after feenableexcept (%s) processes will abort\n",
 361           flag_name);
 362   printf ("      when feraiseexcept (%s) is called.\n", flag_name);
 363   pid = fork ();
 364   if (pid == 0)
 365     {
 366 #ifdef RLIMIT_CORE
 367       /* Try to avoid dumping core.  */
 368       struct rlimit core_limit;
 369       core_limit.rlim_cur = 0;
 370       core_limit.rlim_max = 0;
 371       setrlimit (RLIMIT_CORE, &core_limit);
 372 #endif
 373
 374       fedisableexcept (FE_ALL_EXCEPT);
 375       feenableexcept (fe_exc);
 376       feraiseexcept (fe_exc);
 377       exit (2);
 378     }
 379   else if (pid < 0)
 380     {
 381       if (errno != ENOSYS)
 382         {
 383           printf ("  Fail: Could not fork.\n");
 384           ++count_errors;
 385         }
 386       else
 387         printf ("  `fork' not implemented, test ignored.\n");
 388     }
 389   else {
 390     if (waitpid (pid, &status, 0) != pid)
 391       {
 392         printf ("  Fail: waitpid call failed.\n");
 393         ++count_errors;
 394       }
 395     else if (WIFSIGNALED (status) && WTERMSIG (status) == SIGFPE)
 396       printf ("  Pass: Process received SIGFPE.\n");
 397     else
 398       {
 399         printf ("  Fail: Process didn't receive signal and exited with status %d.\n",
 400                 status);
 401         ++count_errors;
 402       }
 403   }
 404 }
 405
 406 /* Test that program doesn't abort with exception.  */
 407 static void
 408 feexcp_mask_test (const char *flag_name, int fe_exc)
 409 {
 410   int status;
 411   int exception;
 412   pid_t pid;
 413
 414   printf ("Test: after fedisableexcept (%s) processes will not abort\n",
 415           flag_name);
 416   printf ("      when feraiseexcept (%s) is called.\n", flag_name);
 417   pid = fork ();
 418   if (pid == 0)
 419     {
 420 #ifdef RLIMIT_CORE
 421       /* Try to avoid dumping core.  */
 422       struct rlimit core_limit;
 423       core_limit.rlim_cur = 0;
 424       core_limit.rlim_max = 0;
 425       setrlimit (RLIMIT_CORE, &core_limit);
 426 #endif
 427       feenableexcept (FE_ALL_EXCEPT);
 428       exception = fe_exc;
 429 #ifdef FE_INEXACT
 430       /* The standard allows the inexact exception to be set together with the
 431          underflow and overflow exceptions.  So add FE_INEXACT to the set of
 432          exceptions to be disabled if we will be raising underflow or
 433          overflow.  */
 434 # ifdef FE_OVERFLOW
 435       if (fe_exc & FE_OVERFLOW)
 436         exception |= FE_INEXACT;
 437 # endif
 438 # ifdef FE_UNDERFLOW
 439       if (fe_exc & FE_UNDERFLOW)
 440         exception |= FE_INEXACT;
 441 # endif
 442 #endif
 443       fedisableexcept (exception);
 444       feraiseexcept (fe_exc);
 445       exit (2);
 446     }
 447   else if (pid < 0)
 448     {
 449       if (errno != ENOSYS)
 450         {
 451           printf ("  Fail: Could not fork.\n");
 452           ++count_errors;
 453         }
 454       else
 455         printf ("  `fork' not implemented, test ignored.\n");
 456     }
 457   else {
 458     if (waitpid (pid, &status, 0) != pid)
 459       {
 460         printf ("  Fail: waitpid call failed.\n");
 461         ++count_errors;
 462       }
 463     else if (WIFEXITED (status) && WEXITSTATUS (status) == 2)
 464       printf ("  Pass: Process exited normally.\n");
 465     else
 466       {
 467         printf ("  Fail: Process exited abnormally with status %d.\n",
 468                 status);
 469         ++count_errors;
 470       }
 471   }
 472 }
 473
 474
 475 /* Tests for feenableexcept/fedisableexcept/fegetexcept.  */
 476 static void
 477 feenable_test (const char *flag_name, int fe_exc)
 478 {
 479   int excepts;
 480
 481   printf ("Tests for feenableexcepts etc. with flag %s\n", flag_name);
 482
 483   /* First disable all exceptions.  */
 484   if (fedisableexcept (FE_ALL_EXCEPT) == -1)
 485     {
 486       printf ("Test: fedisableexcept (FE_ALL_EXCEPT) failed\n");
 487       ++count_errors;
 488       /* If this fails, the other tests don't make sense.  */
 489       return;
 490     }
 491   excepts = fegetexcept ();
 492   if (excepts != 0)
 493     {
 494       printf ("Test: fegetexcept (%s) failed, return should be 0, is %d\n",
 495               flag_name, excepts);
 496       ++count_errors;
 497     }
 498   excepts = feenableexcept (fe_exc);
 499   if (!EXCEPTION_ENABLE_SUPPORTED (fe_exc) && excepts == -1)
 500     {
 501       printf ("Test: not testing feenableexcept, it isn't implemented.\n");
 502       return;
 503     }
 504   if (excepts == -1)
 505     {
 506       printf ("Test: feenableexcept (%s) failed\n", flag_name);
 507       ++count_errors;
 508       return;
 509     }
 510   if (excepts != 0)
 511     {
 512       printf ("Test: feenableexcept (%s) failed, return should be 0, is %x\n",
 513               flag_name, excepts);
 514       ++count_errors;
 515     }
 516
 517   excepts = fegetexcept ();
 518   if (excepts != fe_exc)
 519     {
 520       printf ("Test: fegetexcept (%s) failed, return should be 0x%x, is 0x%x\n",
 521               flag_name, fe_exc, excepts);
 522       ++count_errors;
 523     }
 524
 525   /* And now disable the exception again.  */
 526   excepts = fedisableexcept (fe_exc);
 527   if (excepts == -1)
 528     {
 529       printf ("Test: fedisableexcept (%s) failed\n", flag_name);
 530       ++count_errors;
 531       return;
 532     }
 533   if (excepts != fe_exc)
 534     {
 535       printf ("Test: fedisableexcept (%s) failed, return should be 0x%x, is 0x%x\n",
 536               flag_name, fe_exc, excepts);
 537       ++count_errors;
 538     }
 539
 540   excepts = fegetexcept ();
 541   if (excepts != 0)
 542     {
 543       printf ("Test: fegetexcept (%s) failed, return should be 0, is 0x%x\n",
 544               flag_name, excepts);
 545       ++count_errors;
 546     }
 547
 548   /* Now the other way round: Enable all exceptions and disable just this one.  */
 549   if (feenableexcept (FE_ALL_EXCEPT) == -1)
 550     {
 551       printf ("Test: feenableexcept (FE_ALL_EXCEPT) failed\n");
 552       ++count_errors;
 553       /* If this fails, the other tests don't make sense.  */
 554       return;
 555     }
 556
 557   excepts = fegetexcept ();
 558   if (excepts != FE_ALL_EXCEPT)
 559     {
 560       printf ("Test: fegetexcept (%s) failed, return should be 0x%x, is 0x%x\n",
 561               flag_name, FE_ALL_EXCEPT, excepts);
 562       ++count_errors;
 563     }
 564
 565   excepts = fedisableexcept (fe_exc);
 566   if (excepts == -1)
 567     {
 568       printf ("Test: fedisableexcept (%s) failed\n", flag_name);
 569       ++count_errors;
 570       return;
 571     }
 572   if (excepts != FE_ALL_EXCEPT)
 573     {
 574       printf ("Test: fedisableexcept (%s) failed, return should be 0, is 0x%x\n",
 575               flag_name, excepts);
 576       ++count_errors;
 577     }
 578
 579   excepts = fegetexcept ();
 580   if (excepts != (FE_ALL_EXCEPT & ~fe_exc))
 581     {
 582       printf ("Test: fegetexcept (%s) failed, return should be 0x%x, is 0x%x\n",
 583               flag_name, (FE_ALL_EXCEPT & ~fe_exc), excepts);
 584       ++count_errors;
 585     }
 586
 587   /* And now enable the exception again.  */
 588   excepts = feenableexcept (fe_exc);
 589   if (excepts == -1)
 590     {
 591       printf ("Test: feenableexcept (%s) failed\n", flag_name);
 592       ++count_errors;
 593       return;
 594     }
 595   if (excepts != (FE_ALL_EXCEPT & ~fe_exc))
 596     {
 597       printf ("Test: feenableexcept (%s) failed, return should be 0, is 0x%x\n",
 598               flag_name, excepts);
 599       ++count_errors;
 600     }
 601
 602   excepts = fegetexcept ();
 603   if (excepts != FE_ALL_EXCEPT)
 604     {
 605       printf ("Test: fegetexcept (%s) failed, return should be 0x%x, is 0x%x\n",
 606               flag_name, FE_ALL_EXCEPT, excepts);
 607       ++count_errors;
 608     }
 609   feexcp_nomask_test (flag_name, fe_exc);
 610   feexcp_mask_test (flag_name, fe_exc);
 611
 612 }
 613
 614
 615 static void
 616 fe_single_test (const char *flag_name, int fe_exc)
 617 {
 618   feenv_nomask_test (flag_name, fe_exc);
 619   feenv_mask_test (flag_name, fe_exc);
 620   feenable_test (flag_name, fe_exc);
 621 }
 622 #endif
 623
 624
 625 static void
 626 feenv_tests (void)
 627 {
 628   /* We might have some exceptions still set.  */
 629   feclearexcept (FE_ALL_EXCEPT);
 630
 631 #ifdef FE_DIVBYZERO
 632   fe_single_test ("FE_DIVBYZERO", FE_DIVBYZERO);
 633 #endif
 634 #ifdef FE_INVALID
 635   fe_single_test ("FE_INVALID", FE_INVALID);
 636 #endif
 637 #ifdef FE_INEXACT
 638   fe_single_test ("FE_INEXACT", FE_INEXACT);
 639 #endif
 640 #ifdef FE_UNDERFLOW
 641   fe_single_test ("FE_UNDERFLOW", FE_UNDERFLOW);
 642 #endif
 643 #ifdef FE_OVERFLOW
 644   fe_single_test ("FE_OVERFLOW", FE_OVERFLOW);
 645 #endif
 646   fesetenv (FE_DFL_ENV);
 647 }
 648
 649
 650 static void
 651 feholdexcept_tests (void)
 652 {
 653   fenv_t saved, saved2;
 654   int res;
 655
 656   feclearexcept (FE_ALL_EXCEPT);
 657   fedisableexcept (FE_ALL_EXCEPT);
 658 #ifdef FE_DIVBYZERO
 659   feraiseexcept (FE_DIVBYZERO);
 660 #endif
 661   if (EXCEPTION_TESTS (float))
 662     test_exceptions ("feholdexcept_tests FE_DIVBYZERO test",
 663                      DIVBYZERO_EXC, 0);
 664   res = feholdexcept (&saved);
 665   if (res != 0)
 666     {
 667       printf ("feholdexcept failed: %d\n", res);
 668       ++count_errors;
 669     }
 670 #if defined FE_TONEAREST && defined FE_TOWARDZERO
 671   res = fesetround (FE_TOWARDZERO);
 672   if (res != 0 && ROUNDING_TESTS (float, FE_TOWARDZERO))
 673     {
 674       printf ("fesetround failed: %d\n", res);
 675       ++count_errors;
 676     }
 677 #endif
 678   test_exceptions ("feholdexcept_tests 0 test", NO_EXC, 0);
 679 #ifdef FE_INVALID
 680   feraiseexcept (FE_INVALID);
 681   if (EXCEPTION_TESTS (float))
 682     test_exceptions ("feholdexcept_tests FE_INVALID test",
 683                      INVALID_EXC, 0);
 684 #endif
 685   res = feupdateenv (&saved);
 686   if (res != 0)
 687     {
 688       printf ("feupdateenv failed: %d\n", res);
 689       ++count_errors;
 690     }
 691 #if defined FE_TONEAREST && defined FE_TOWARDZERO
 692   res = fegetround ();
 693   if (res != FE_TONEAREST)
 694     {
 695       printf ("feupdateenv didn't restore rounding mode: %d\n", res);
 696       ++count_errors;
 697     }
 698 #endif
 699   if (EXCEPTION_TESTS (float))
 700     test_exceptions ("feholdexcept_tests FE_DIVBYZERO|FE_INVALID test",
 701                      DIVBYZERO_EXC | INVALID_EXC, 0);
 702   feclearexcept (FE_ALL_EXCEPT);
 703 #ifdef FE_INVALID
 704   feraiseexcept (FE_INVALID);
 705 #endif
 706 #if defined FE_TONEAREST && defined FE_UPWARD
 707   res = fesetround (FE_UPWARD);
 708   if (res != 0 && ROUNDING_TESTS (float, FE_UPWARD))
 709     {
 710       printf ("fesetround failed: %d\n", res);
 711       ++count_errors;
 712     }
 713 #endif
 714   res = feholdexcept (&saved2);
 715   if (res != 0)
 716     {
 717       printf ("feholdexcept failed: %d\n", res);
 718       ++count_errors;
 719     }
 720 #if defined FE_TONEAREST && defined FE_UPWARD
 721   res = fesetround (FE_TONEAREST);
 722   if (res != 0)
 723     {
 724       printf ("fesetround failed: %d\n", res);
 725       ++count_errors;
 726     }
 727 #endif
 728   test_exceptions ("feholdexcept_tests 0 2nd test", NO_EXC, 0);
 729 #ifdef FE_INEXACT
 730   feraiseexcept (FE_INEXACT);
 731   if (EXCEPTION_TESTS (float))
 732     test_exceptions ("feholdexcept_tests FE_INEXACT test",
 733                      INEXACT_EXC, 0);
 734 #endif
 735   res = feupdateenv (&saved2);
 736   if (res != 0)
 737     {
 738       printf ("feupdateenv failed: %d\n", res);
 739       ++count_errors;
 740     }
 741 #if defined FE_TONEAREST && defined FE_UPWARD
 742   res = fegetround ();
 743   if (res != FE_UPWARD && ROUNDING_TESTS (float, FE_UPWARD))
 744     {
 745       printf ("feupdateenv didn't restore rounding mode: %d\n", res);
 746       ++count_errors;
 747     }
 748   fesetround (FE_TONEAREST);
 749 #endif
 750   if (EXCEPTION_TESTS (float))
 751     test_exceptions ("feholdexcept_tests FE_INEXACT|FE_INVALID test",
 752                      INVALID_EXC | INEXACT_EXC, 0);
 753   feclearexcept (FE_ALL_EXCEPT);
 754 }
 755
 756
 757 /* IEC 559 and ISO C99 define a default startup environment */
 758 static void
 759 initial_tests (void)
 760 {
 761   test_exceptions ("Initially all exceptions should be cleared",
 762                    NO_EXC, 0);
 763 #ifdef FE_TONEAREST
 764   test_rounding ("Rounding direction should be initalized to nearest",
 765                  FE_TONEAREST);
 766 #endif
 767 }
 768
 769 int
 770 main (void)
 771 {
 772   initial_tests ();
 773   fe_tests ();
 774   feenv_tests ();
 775   feholdexcept_tests ();
 776
 777   if (count_errors)
 778     {
 779       printf ("\n%d errors occurred.\n", count_errors);
 780       exit (1);
 781     }
 782   printf ("\n All tests passed successfully.\n");
 783   return 0;
 784 }