1 /* Support code for testing libm functions (driver).
2 Copyright (C) 1997-2021 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
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.
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.
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 <https://www.gnu.org/licenses/>. */
19 #include "libm-test-support.h"
21 #include <math-tests-arch.h>
23 /* Flags set by the including file. */
24 const int flag_test_errno
= TEST_ERRNO
;
25 const int flag_test_exceptions
= TEST_EXCEPTIONS
;
26 const int flag_test_mathvec
= TEST_MATHVEC
;
29 const int snan_tests_arg
= SNAN_TESTS (ARG_FLOAT
);
31 const int snan_tests_arg
= SNAN_TESTS (FLOAT
);
35 #define STR(x) STRX (x)
36 #define STR_FLOAT STR (FLOAT)
37 #define STR_ARG_FLOAT STR (ARG_FLOAT)
38 #define STR_VEC_LEN STR (VEC_LEN)
40 /* Informal description of the functions being tested. */
42 # define TEST_MSG "testing " STR_FLOAT " (vector length " STR_VEC_LEN ")\n"
44 # define TEST_MSG "testing " STR_FLOAT " (argument " STR_ARG_FLOAT ")\n"
46 # define TEST_MSG "testing " STR_FLOAT " (without inline functions)\n"
48 const char test_msg
[] = TEST_MSG
;
50 /* Allow platforms without all rounding modes to test properly,
51 assuming they provide an __FE_UNDEFINED in <bits/fenv.h> which
52 causes fesetround() to return failure. */
54 # define FE_TONEAREST __FE_UNDEFINED
57 # define FE_TOWARDZERO __FE_UNDEFINED
60 # define FE_UPWARD __FE_UNDEFINED
63 # define FE_DOWNWARD __FE_UNDEFINED
66 #define TEST_NAN_PAYLOAD_CANONICALIZE (SNAN_TESTS_PRESERVE_PAYLOAD \
70 const char qtype_str
[] = TYPE_STR
;
72 /* Various constants derived from pi. We must supply them precalculated for
73 accuracy. They are written as a series of postfix operations to keep
74 them concise yet somewhat readable. */
77 #define lit_pi_3_m_4_d LIT (2.356194490192344928846982537459627163)
78 /* pi * 3 / (4 * ln(10)) */
79 #define lit_pi_3_m_4_ln10_m_d LIT (1.023282265381381010614337719073516828)
80 /* pi / (2 * ln(10)) */
81 #define lit_pi_2_ln10_m_d LIT (0.682188176920920673742891812715677885)
82 /* pi / (4 * ln(10)) */
83 #define lit_pi_4_ln10_m_d LIT (0.341094088460460336871445906357838943)
85 #define lit_pi_ln10_d LIT (1.364376353841841347485783625431355770)
87 #define lit_pi_2_d LITM (M_PI_2)
89 #define lit_pi_4_d LITM (M_PI_4)
91 #define lit_pi LITM (M_PI)
93 /* Other useful constants. */
96 #define lit_e LITM (M_E)
98 #define plus_zero LIT (0.0)
99 #define minus_zero LIT (-0.0)
100 #define plus_infty FUNC (__builtin_inf) ()
101 #define minus_infty -(FUNC (__builtin_inf) ())
102 #define qnan_value_pl(S) FUNC (__builtin_nan) (S)
103 #define qnan_value qnan_value_pl ("")
104 #define snan_value_pl(S) FUNC (__builtin_nans) (S)
105 #define snan_value snan_value_pl ("")
106 #define max_value TYPE_MAX
107 #define min_value TYPE_MIN
108 #define min_subnorm_value TYPE_TRUE_MIN
110 #define arg_plus_zero ARG_LIT (0.0)
111 #define arg_minus_zero ARG_LIT (-0.0)
112 #define arg_plus_infty ARG_FUNC (__builtin_inf) ()
113 #define arg_minus_infty -(ARG_FUNC (__builtin_inf) ())
114 #define arg_qnan_value_pl(S) ARG_FUNC (__builtin_nan) (S)
115 #define arg_qnan_value arg_qnan_value_pl ("")
116 #define arg_snan_value_pl(S) ARG_FUNC (__builtin_nans) (S)
117 #define arg_snan_value arg_snan_value_pl ("")
118 #define arg_max_value ARG_TYPE_MAX
119 #define arg_min_value ARG_TYPE_MIN
120 #define arg_min_subnorm_value ARG_TYPE_TRUE_MIN
122 /* For nexttoward tests. */
123 #define snan_value_ld __builtin_nansl ("")
125 /* For pseudo-normal number tests. */
126 #if TEST_COND_intel96
127 # include <math_ldbl.h>
128 #define pseudo_inf { .parts = { 0x00000000, 0x00000000, 0x7fff }}
129 #define pseudo_zero { .parts = { 0x00000000, 0x00000000, 0x0100 }}
130 #define pseudo_qnan { .parts = { 0x00000001, 0x00000000, 0x7fff }}
131 #define pseudo_snan { .parts = { 0x00000001, 0x40000000, 0x7fff }}
132 #define pseudo_unnormal { .parts = { 0x00000001, 0x40000000, 0x0100 }}
135 /* Structures for each kind of test. */
136 /* Used for both RUN_TEST_LOOP_f_f and RUN_TEST_LOOP_fp_f. */
147 struct test_ff_f_data
157 /* Strictly speaking, a j type argument is one gen-libm-test.py will not
158 attempt to muck with. For now, it is only used to prevent it from
159 mucking up an explicitly long double argument. */
160 struct test_fj_f_data
172 struct test_aa_f_data
175 ARG_FLOAT arg1
, arg2
;
183 struct test_fi_f_data
194 struct test_fl_f_data
205 struct test_if_f_data
216 struct test_fff_f_data
219 FLOAT arg1
, arg2
, arg3
;
226 struct test_fiu_M_data
238 struct test_fiu_U_data
260 /* Used for both RUN_TEST_LOOP_f_f1 and RUN_TEST_LOOP_fI_f1. */
261 struct test_f_f1_data
273 struct test_fF_f1_data
282 FLOAT extra_expected
;
285 struct test_ffI_f1_data
307 struct test_cc_c_data
310 FLOAT arg1r
, arg1c
, arg2r
, arg2c
;
317 /* Used for all of RUN_TEST_LOOP_f_i, RUN_TEST_LOOP_f_i_tg,
318 RUN_TEST_LOOP_f_b and RUN_TEST_LOOP_f_b_tg. */
329 /* Used for RUN_TEST_LOOP_f_i_tg_u and RUN_TEST_LOOP_f_b_tg_u. */
330 #if TEST_COND_intel96
331 struct test_j_i_data_u
334 ieee_long_double_shape_type arg
;
342 /* Used for RUN_TEST_LOOP_ff_b, RUN_TEST_LOOP_fpfp_b and
343 RUN_TEST_LOOP_ff_i_tg. */
344 struct test_ff_i_data
370 long long int expected
;
374 struct test_fFF_11_data
382 FLOAT extra1_expected
;
384 FLOAT extra2_expected
;
387 /* Used for both RUN_TEST_LOOP_Ff_b1 and RUN_TEST_LOOP_Ffp_b1. */
388 struct test_Ff_b1_data
397 FLOAT extra_expected
;
401 /* Set the rounding mode, or restore the saved value. */
402 #define IF_ROUND_INIT_ /* Empty. */
403 #define IF_ROUND_INIT_FE_DOWNWARD \
404 int save_round_mode = fegetround (); \
405 if (ROUNDING_TESTS (FLOAT, FE_DOWNWARD) \
407 && fesetround (FE_DOWNWARD) == 0)
408 #define IF_ROUND_INIT_FE_TONEAREST \
409 int save_round_mode = fegetround (); \
410 if (ROUNDING_TESTS (FLOAT, FE_TONEAREST) \
411 && fesetround (FE_TONEAREST) == 0)
412 #define IF_ROUND_INIT_FE_TOWARDZERO \
413 int save_round_mode = fegetround (); \
414 if (ROUNDING_TESTS (FLOAT, FE_TOWARDZERO) \
416 && fesetround (FE_TOWARDZERO) == 0)
417 #define IF_ROUND_INIT_FE_UPWARD \
418 int save_round_mode = fegetround (); \
419 if (ROUNDING_TESTS (FLOAT, FE_UPWARD) \
421 && fesetround (FE_UPWARD) == 0)
422 #define ROUND_RESTORE_ /* Empty. */
423 #define ROUND_RESTORE_FE_DOWNWARD \
424 fesetround (save_round_mode)
425 #define ROUND_RESTORE_FE_TONEAREST \
426 fesetround (save_round_mode)
427 #define ROUND_RESTORE_FE_TOWARDZERO \
428 fesetround (save_round_mode)
429 #define ROUND_RESTORE_FE_UPWARD \
430 fesetround (save_round_mode)
432 /* Field name to use for a given rounding mode. */
434 #define RM_FE_DOWNWARD rd
435 #define RM_FE_TONEAREST rn
436 #define RM_FE_TOWARDZERO rz
437 #define RM_FE_UPWARD ru
439 /* Common setup for an individual test. */
440 #define COMMON_TEST_SETUP(ARG_STR) \
442 if (asprintf (&test_name, "%s (%s)", this_func, (ARG_STR)) == -1) \
445 /* Setup for a test with an extra output. */
446 #define EXTRA_OUTPUT_TEST_SETUP(ARG_STR, N) \
447 char *extra##N##_name; \
448 if (asprintf (&extra##N##_name, "%s (%s) extra output " #N, \
449 this_func, (ARG_STR)) == -1) \
452 /* Common cleanup after an individual test. */
453 #define COMMON_TEST_CLEANUP \
456 /* Cleanup for a test with an extra output. */
457 #define EXTRA_OUTPUT_TEST_CLEANUP(N) \
458 free (extra##N##_name)
460 /* Run an individual test, including any required setup and checking
461 of results, or loop over all tests in an array. */
462 #define RUN_TEST_f_f(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
465 if (enable_test (EXCEPTIONS)) \
467 COMMON_TEST_SETUP (ARG_STR); \
468 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG), \
469 EXPECTED, EXCEPTIONS); \
470 COMMON_TEST_CLEANUP; \
473 #define RUN_TEST_LOOP_f_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
474 IF_ROUND_INIT_ ## ROUNDING_MODE \
475 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
476 RUN_TEST_f_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
477 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
478 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
479 ROUND_RESTORE_ ## ROUNDING_MODE
480 #define RUN_TEST_fp_f(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
483 if (enable_test (EXCEPTIONS)) \
485 COMMON_TEST_SETUP (ARG_STR); \
486 check_float (test_name, FUNC_TEST (FUNC_NAME) (&(ARG)), \
487 EXPECTED, EXCEPTIONS); \
488 COMMON_TEST_CLEANUP; \
491 #define RUN_TEST_LOOP_fp_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
492 IF_ROUND_INIT_ ## ROUNDING_MODE \
493 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
494 RUN_TEST_fp_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
495 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
496 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
497 ROUND_RESTORE_ ## ROUNDING_MODE
498 #define RUN_TEST_2_f(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
501 if (enable_test (EXCEPTIONS)) \
503 COMMON_TEST_SETUP (ARG_STR); \
504 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG1, ARG2), \
505 EXPECTED, EXCEPTIONS); \
506 COMMON_TEST_CLEANUP; \
509 #define RUN_TEST_LOOP_2_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
510 IF_ROUND_INIT_ ## ROUNDING_MODE \
511 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
512 RUN_TEST_2_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \
514 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
515 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
516 ROUND_RESTORE_ ## ROUNDING_MODE
517 #define RUN_TEST_ff_f RUN_TEST_2_f
518 #define RUN_TEST_LOOP_ff_f RUN_TEST_LOOP_2_f
519 #define RUN_TEST_LOOP_fj_f RUN_TEST_LOOP_2_f
520 #define RUN_TEST_LOOP_aa_f RUN_TEST_LOOP_2_f
521 #define RUN_TEST_fi_f RUN_TEST_2_f
522 #define RUN_TEST_LOOP_fi_f RUN_TEST_LOOP_2_f
523 #define RUN_TEST_fl_f RUN_TEST_2_f
524 #define RUN_TEST_LOOP_fl_f RUN_TEST_LOOP_2_f
525 #define RUN_TEST_if_f RUN_TEST_2_f
526 #define RUN_TEST_LOOP_if_f RUN_TEST_LOOP_2_f
527 #define RUN_TEST_fff_f(ARG_STR, FUNC_NAME, ARG1, ARG2, ARG3, \
528 EXPECTED, EXCEPTIONS) \
530 if (enable_test (EXCEPTIONS)) \
532 COMMON_TEST_SETUP (ARG_STR); \
533 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG1, ARG2, ARG3), \
534 EXPECTED, EXCEPTIONS); \
535 COMMON_TEST_CLEANUP; \
538 #define RUN_TEST_LOOP_fff_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
539 IF_ROUND_INIT_ ## ROUNDING_MODE \
540 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
541 RUN_TEST_fff_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \
542 (ARRAY)[i].arg2, (ARRAY)[i].arg3, \
543 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
544 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
545 ROUND_RESTORE_ ## ROUNDING_MODE
546 #define RUN_TEST_fiu_M(ARG_STR, FUNC_NAME, ARG1, ARG2, ARG3, \
547 EXPECTED, EXCEPTIONS) \
549 if (enable_test (EXCEPTIONS)) \
551 COMMON_TEST_SETUP (ARG_STR); \
552 check_intmax_t (test_name, \
553 FUNC_TEST (FUNC_NAME) (ARG1, ARG2, ARG3), \
554 EXPECTED, EXCEPTIONS); \
555 COMMON_TEST_CLEANUP; \
558 #define RUN_TEST_LOOP_fiu_M(FUNC_NAME, ARRAY, ROUNDING_MODE) \
559 IF_ROUND_INIT_ ## ROUNDING_MODE \
560 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
561 RUN_TEST_fiu_M ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \
562 (ARRAY)[i].arg2, (ARRAY)[i].arg3, \
563 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
564 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
565 ROUND_RESTORE_ ## ROUNDING_MODE
566 #define RUN_TEST_fiu_U(ARG_STR, FUNC_NAME, ARG1, ARG2, ARG3, \
567 EXPECTED, EXCEPTIONS) \
569 if (enable_test (EXCEPTIONS)) \
571 COMMON_TEST_SETUP (ARG_STR); \
572 check_uintmax_t (test_name, \
573 FUNC_TEST (FUNC_NAME) (ARG1, ARG2, ARG3), \
574 EXPECTED, EXCEPTIONS); \
575 COMMON_TEST_CLEANUP; \
578 #define RUN_TEST_LOOP_fiu_U(FUNC_NAME, ARRAY, ROUNDING_MODE) \
579 IF_ROUND_INIT_ ## ROUNDING_MODE \
580 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
581 RUN_TEST_fiu_U ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \
582 (ARRAY)[i].arg2, (ARRAY)[i].arg3, \
583 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
584 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
585 ROUND_RESTORE_ ## ROUNDING_MODE
586 #define RUN_TEST_c_f(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
589 if (enable_test (EXCEPTIONS)) \
591 COMMON_TEST_SETUP (ARG_STR); \
592 check_float (test_name, \
593 FUNC_TEST (FUNC_NAME) (BUILD_COMPLEX (ARG1, ARG2)),\
594 EXPECTED, EXCEPTIONS); \
595 COMMON_TEST_CLEANUP; \
598 #define RUN_TEST_LOOP_c_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
599 IF_ROUND_INIT_ ## ROUNDING_MODE \
600 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
601 RUN_TEST_c_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].argr, \
603 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
604 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
605 ROUND_RESTORE_ ## ROUNDING_MODE
606 #define RUN_TEST_f_f1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
607 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
610 if (enable_test (EXCEPTIONS)) \
612 COMMON_TEST_SETUP (ARG_STR); \
613 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
614 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG), EXPECTED, \
616 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
618 check_int (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, 0); \
619 EXTRA_OUTPUT_TEST_CLEANUP (1); \
620 COMMON_TEST_CLEANUP; \
623 #define RUN_TEST_LOOP_f_f1(FUNC_NAME, ARRAY, ROUNDING_MODE, EXTRA_VAR) \
624 IF_ROUND_INIT_ ## ROUNDING_MODE \
625 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
626 RUN_TEST_f_f1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
627 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
628 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
630 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
631 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
632 ROUND_RESTORE_ ## ROUNDING_MODE
633 #define RUN_TEST_fF_f1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
634 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
637 if (enable_test (EXCEPTIONS)) \
639 COMMON_TEST_SETUP (ARG_STR); \
640 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
641 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG, &(EXTRA_VAR)), \
642 EXPECTED, EXCEPTIONS); \
643 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
645 check_float (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, 0); \
646 EXTRA_OUTPUT_TEST_CLEANUP (1); \
647 COMMON_TEST_CLEANUP; \
650 #define RUN_TEST_LOOP_fF_f1(FUNC_NAME, ARRAY, ROUNDING_MODE, EXTRA_VAR) \
651 IF_ROUND_INIT_ ## ROUNDING_MODE \
652 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
653 RUN_TEST_fF_f1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
654 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
655 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
657 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
658 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
659 ROUND_RESTORE_ ## ROUNDING_MODE
660 #define RUN_TEST_fI_f1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
661 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
664 if (enable_test (EXCEPTIONS)) \
666 COMMON_TEST_SETUP (ARG_STR); \
667 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
668 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG, &(EXTRA_VAR)), \
669 EXPECTED, EXCEPTIONS); \
670 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
672 check_int (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, 0); \
673 EXTRA_OUTPUT_TEST_CLEANUP (1); \
674 COMMON_TEST_CLEANUP; \
677 #define RUN_TEST_LOOP_fI_f1(FUNC_NAME, ARRAY, ROUNDING_MODE, EXTRA_VAR) \
678 IF_ROUND_INIT_ ## ROUNDING_MODE \
679 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
680 RUN_TEST_fI_f1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
681 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
682 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
684 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
685 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
686 ROUND_RESTORE_ ## ROUNDING_MODE
687 #define RUN_TEST_ffI_f1_mod8(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
688 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
691 if (enable_test (EXCEPTIONS)) \
693 COMMON_TEST_SETUP (ARG_STR); \
694 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
695 check_float (test_name, \
696 FUNC_TEST (FUNC_NAME) (ARG1, ARG2, &(EXTRA_VAR)), \
697 EXPECTED, EXCEPTIONS); \
698 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
700 check_int (extra1_name, (EXTRA_VAR) % 8, EXTRA_EXPECTED, 0); \
701 EXTRA_OUTPUT_TEST_CLEANUP (1); \
702 COMMON_TEST_CLEANUP; \
705 #define RUN_TEST_LOOP_ffI_f1_mod8(FUNC_NAME, ARRAY, ROUNDING_MODE, \
707 IF_ROUND_INIT_ ## ROUNDING_MODE \
708 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
709 RUN_TEST_ffI_f1_mod8 ((ARRAY)[i].arg_str, FUNC_NAME, \
710 (ARRAY)[i].arg1, (ARRAY)[i].arg2, \
711 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
712 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
714 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
715 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
716 ROUND_RESTORE_ ## ROUNDING_MODE
717 #define RUN_TEST_Ff_b1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
718 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
721 if (enable_test (EXCEPTIONS)) \
723 COMMON_TEST_SETUP (ARG_STR); \
724 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
725 /* Clear any exceptions from comparison involving sNaN \
727 feclearexcept (FE_ALL_EXCEPT); \
728 check_bool (test_name, FUNC_TEST (FUNC_NAME) (&(EXTRA_VAR), \
730 EXPECTED, EXCEPTIONS); \
731 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
733 check_float (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, \
734 (EXCEPTIONS) & TEST_NAN_PAYLOAD); \
735 EXTRA_OUTPUT_TEST_CLEANUP (1); \
736 COMMON_TEST_CLEANUP; \
739 #define RUN_TEST_LOOP_Ff_b1(FUNC_NAME, ARRAY, ROUNDING_MODE, \
741 IF_ROUND_INIT_ ## ROUNDING_MODE \
742 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
743 RUN_TEST_Ff_b1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
744 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
745 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
747 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
748 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
749 ROUND_RESTORE_ ## ROUNDING_MODE
750 #define RUN_TEST_Ffp_b1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
751 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
754 if (enable_test (EXCEPTIONS)) \
756 COMMON_TEST_SETUP (ARG_STR); \
757 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
758 check_bool (test_name, FUNC_TEST (FUNC_NAME) (&(EXTRA_VAR), \
760 EXPECTED, EXCEPTIONS); \
761 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
763 check_float (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, \
764 (EXCEPTIONS) & TEST_NAN_PAYLOAD); \
765 EXTRA_OUTPUT_TEST_CLEANUP (1); \
766 COMMON_TEST_CLEANUP; \
769 #define RUN_TEST_LOOP_Ffp_b1(FUNC_NAME, ARRAY, ROUNDING_MODE, \
771 IF_ROUND_INIT_ ## ROUNDING_MODE \
772 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
773 RUN_TEST_Ffp_b1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
774 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
775 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
777 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
778 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
779 ROUND_RESTORE_ ## ROUNDING_MODE
780 #define RUN_TEST_c_c(ARG_STR, FUNC_NAME, ARGR, ARGC, EXPR, EXPC, \
783 if (enable_test (EXCEPTIONS)) \
785 COMMON_TEST_SETUP (ARG_STR); \
786 check_complex (test_name, \
787 FUNC_TEST (FUNC_NAME) (BUILD_COMPLEX (ARGR, ARGC)), \
788 BUILD_COMPLEX (EXPR, EXPC), EXCEPTIONS); \
789 COMMON_TEST_CLEANUP; \
792 #define RUN_TEST_LOOP_c_c(FUNC_NAME, ARRAY, ROUNDING_MODE) \
793 IF_ROUND_INIT_ ## ROUNDING_MODE \
794 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
795 RUN_TEST_c_c ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].argr, \
797 (ARRAY)[i].RM_##ROUNDING_MODE.expr, \
798 (ARRAY)[i].RM_##ROUNDING_MODE.expc, \
799 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
800 ROUND_RESTORE_ ## ROUNDING_MODE
801 #define RUN_TEST_cc_c(ARG_STR, FUNC_NAME, ARG1R, ARG1C, ARG2R, ARG2C, \
802 EXPR, EXPC, EXCEPTIONS) \
804 if (enable_test (EXCEPTIONS)) \
806 COMMON_TEST_SETUP (ARG_STR); \
807 check_complex (test_name, \
808 FUNC_TEST (FUNC_NAME) (BUILD_COMPLEX (ARG1R, ARG1C), \
809 BUILD_COMPLEX (ARG2R, ARG2C)), \
810 BUILD_COMPLEX (EXPR, EXPC), EXCEPTIONS); \
811 COMMON_TEST_CLEANUP; \
814 #define RUN_TEST_LOOP_cc_c(FUNC_NAME, ARRAY, ROUNDING_MODE) \
815 IF_ROUND_INIT_ ## ROUNDING_MODE \
816 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
817 RUN_TEST_cc_c ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1r, \
818 (ARRAY)[i].arg1c, (ARRAY)[i].arg2r, \
820 (ARRAY)[i].RM_##ROUNDING_MODE.expr, \
821 (ARRAY)[i].RM_##ROUNDING_MODE.expc, \
822 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
823 ROUND_RESTORE_ ## ROUNDING_MODE
824 #define RUN_TEST_f_i(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \
826 if (enable_test (EXCEPTIONS)) \
828 COMMON_TEST_SETUP (ARG_STR); \
829 check_int (test_name, FUNC_TEST (FUNC_NAME) (ARG), EXPECTED, \
831 COMMON_TEST_CLEANUP; \
834 #define RUN_TEST_LOOP_f_i(FUNC_NAME, ARRAY, ROUNDING_MODE) \
835 IF_ROUND_INIT_ ## ROUNDING_MODE \
836 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
837 RUN_TEST_f_i ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
838 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
839 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
840 ROUND_RESTORE_ ## ROUNDING_MODE
841 #define RUN_TEST_f_i_tg(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
844 if (enable_test (EXCEPTIONS)) \
846 COMMON_TEST_SETUP (ARG_STR); \
847 check_int (test_name, FUNC_NAME (ARG), EXPECTED, EXCEPTIONS); \
848 COMMON_TEST_CLEANUP; \
851 #define RUN_TEST_LOOP_f_i_tg(FUNC_NAME, ARRAY, ROUNDING_MODE) \
852 IF_ROUND_INIT_ ## ROUNDING_MODE \
853 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
854 RUN_TEST_f_i_tg ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
855 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
856 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
857 ROUND_RESTORE_ ## ROUNDING_MODE
858 #define RUN_TEST_LOOP_j_b_tg_u(FUNC_NAME, ARRAY, ROUNDING_MODE) \
859 IF_ROUND_INIT_ ## ROUNDING_MODE \
860 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
861 RUN_TEST_f_b_tg ((ARRAY)[i].arg_str, FUNC_NAME, \
862 (FLOAT)(ARRAY)[i].arg.value, \
863 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
864 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
865 ROUND_RESTORE_ ## ROUNDING_MODE
866 #define RUN_TEST_LOOP_j_i_tg_u(FUNC_NAME, ARRAY, ROUNDING_MODE) \
867 IF_ROUND_INIT_ ## ROUNDING_MODE \
868 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
869 RUN_TEST_f_i_tg ((ARRAY)[i].arg_str, FUNC_NAME, \
870 (FLOAT)(ARRAY)[i].arg.value, \
871 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
872 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
873 ROUND_RESTORE_ ## ROUNDING_MODE
874 #define RUN_TEST_ff_b(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
877 if (enable_test (EXCEPTIONS)) \
879 COMMON_TEST_SETUP (ARG_STR); \
880 check_bool (test_name, FUNC_TEST (FUNC_NAME) (ARG1, ARG2), \
881 EXPECTED, EXCEPTIONS); \
882 COMMON_TEST_CLEANUP; \
885 #define RUN_TEST_LOOP_ff_b(FUNC_NAME, ARRAY, ROUNDING_MODE) \
886 IF_ROUND_INIT_ ## ROUNDING_MODE \
887 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
888 RUN_TEST_ff_b ((ARRAY)[i].arg_str, FUNC_NAME, \
889 (ARRAY)[i].arg1, (ARRAY)[i].arg2, \
890 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
891 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
892 ROUND_RESTORE_ ## ROUNDING_MODE
893 #define RUN_TEST_fpfp_b(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
896 if (enable_test (EXCEPTIONS)) \
898 COMMON_TEST_SETUP (ARG_STR); \
899 check_bool (test_name, \
900 FUNC_TEST (FUNC_NAME) (&(ARG1), &(ARG2)), \
901 EXPECTED, EXCEPTIONS); \
902 COMMON_TEST_CLEANUP; \
905 #define RUN_TEST_LOOP_fpfp_b(FUNC_NAME, ARRAY, ROUNDING_MODE) \
906 IF_ROUND_INIT_ ## ROUNDING_MODE \
907 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
908 RUN_TEST_fpfp_b ((ARRAY)[i].arg_str, FUNC_NAME, \
909 (ARRAY)[i].arg1, (ARRAY)[i].arg2, \
910 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
911 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
912 ROUND_RESTORE_ ## ROUNDING_MODE
913 #define RUN_TEST_ff_i_tg(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
916 if (enable_test (EXCEPTIONS)) \
918 COMMON_TEST_SETUP (ARG_STR); \
919 check_int (test_name, FUNC_NAME (ARG1, ARG2), EXPECTED, \
921 COMMON_TEST_CLEANUP; \
924 #define RUN_TEST_LOOP_ff_i_tg(FUNC_NAME, ARRAY, ROUNDING_MODE) \
925 IF_ROUND_INIT_ ## ROUNDING_MODE \
926 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
927 RUN_TEST_ff_i_tg ((ARRAY)[i].arg_str, FUNC_NAME, \
928 (ARRAY)[i].arg1, (ARRAY)[i].arg2, \
929 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
930 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
931 ROUND_RESTORE_ ## ROUNDING_MODE
932 #define RUN_TEST_f_b(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \
934 if (enable_test (EXCEPTIONS)) \
936 COMMON_TEST_SETUP (ARG_STR); \
937 check_bool (test_name, FUNC_TEST (FUNC_NAME) (ARG), EXPECTED, \
939 COMMON_TEST_CLEANUP; \
942 #define RUN_TEST_LOOP_f_b(FUNC_NAME, ARRAY, ROUNDING_MODE) \
943 IF_ROUND_INIT_ ## ROUNDING_MODE \
944 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
945 RUN_TEST_f_b ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
946 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
947 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
948 ROUND_RESTORE_ ## ROUNDING_MODE
949 #define RUN_TEST_f_b_tg(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
952 if (enable_test (EXCEPTIONS)) \
954 COMMON_TEST_SETUP (ARG_STR); \
955 check_bool (test_name, FUNC_NAME (ARG), EXPECTED, EXCEPTIONS); \
956 COMMON_TEST_CLEANUP; \
959 #define RUN_TEST_LOOP_f_b_tg(FUNC_NAME, ARRAY, ROUNDING_MODE) \
960 IF_ROUND_INIT_ ## ROUNDING_MODE \
961 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
962 RUN_TEST_f_b_tg ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
963 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
964 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
965 ROUND_RESTORE_ ## ROUNDING_MODE
966 #define RUN_TEST_f_l(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \
968 if (enable_test (EXCEPTIONS)) \
970 COMMON_TEST_SETUP (ARG_STR); \
971 check_long (test_name, FUNC_TEST (FUNC_NAME) (ARG), EXPECTED, \
973 COMMON_TEST_CLEANUP; \
976 #define RUN_TEST_LOOP_f_l(FUNC_NAME, ARRAY, ROUNDING_MODE) \
977 IF_ROUND_INIT_ ## ROUNDING_MODE \
978 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
979 RUN_TEST_f_l ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
980 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
981 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
982 ROUND_RESTORE_ ## ROUNDING_MODE
983 #define RUN_TEST_f_L(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \
985 if (enable_test (EXCEPTIONS)) \
987 COMMON_TEST_SETUP (ARG_STR); \
988 check_longlong (test_name, FUNC_TEST (FUNC_NAME) (ARG), \
989 EXPECTED, EXCEPTIONS); \
990 COMMON_TEST_CLEANUP; \
993 #define RUN_TEST_LOOP_f_L(FUNC_NAME, ARRAY, ROUNDING_MODE) \
994 IF_ROUND_INIT_ ## ROUNDING_MODE \
995 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
996 RUN_TEST_f_L ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
997 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
998 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
999 ROUND_RESTORE_ ## ROUNDING_MODE
1000 #define RUN_TEST_fFF_11(ARG_STR, FUNC_NAME, ARG, EXCEPTIONS, \
1001 EXTRA1_VAR, EXTRA1_TEST, \
1002 EXTRA1_EXPECTED, EXTRA2_VAR, \
1003 EXTRA2_TEST, EXTRA2_EXPECTED) \
1005 if (enable_test (EXCEPTIONS)) \
1007 COMMON_TEST_SETUP (ARG_STR); \
1008 FUNC_TEST (FUNC_NAME) (ARG, &(EXTRA1_VAR), &(EXTRA2_VAR)); \
1009 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
1011 check_float (extra1_name, EXTRA1_VAR, EXTRA1_EXPECTED, \
1013 EXTRA_OUTPUT_TEST_CLEANUP (1); \
1014 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 2); \
1016 check_float (extra2_name, EXTRA2_VAR, EXTRA2_EXPECTED, 0); \
1017 EXTRA_OUTPUT_TEST_CLEANUP (2); \
1018 COMMON_TEST_CLEANUP; \
1021 #define RUN_TEST_LOOP_fFF_11(FUNC_NAME, ARRAY, ROUNDING_MODE, \
1022 EXTRA1_VAR, EXTRA2_VAR) \
1023 IF_ROUND_INIT_ ## ROUNDING_MODE \
1024 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
1025 RUN_TEST_fFF_11 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
1026 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
1028 (ARRAY)[i].RM_##ROUNDING_MODE.extra1_test, \
1029 (ARRAY)[i].RM_##ROUNDING_MODE.extra1_expected, \
1031 (ARRAY)[i].RM_##ROUNDING_MODE.extra2_test, \
1032 (ARRAY)[i].RM_##ROUNDING_MODE.extra2_expected); \
1033 ROUND_RESTORE_ ## ROUNDING_MODE
1036 # define TEST_SUFF VEC_SUFF
1037 # define TEST_SUFF_STR
1040 # define TEST_SUFF_STR "_" ARG_TYPE_STR
1043 # define TEST_SUFF_STR
1046 #define STR_CONCAT(a, b, c) __STRING (a##b##c)
1047 #define STR_CON3(a, b, c) STR_CONCAT (a, b, c)
1050 # define TEST_COND_any_ibm128 (TEST_COND_ibm128 || TEST_COND_arg_ibm128)
1052 # define TEST_COND_any_ibm128 TEST_COND_ibm128
1055 /* Start and end the tests for a given function. */
1056 #define START(FUN, SUFF, EXACT) \
1058 const char *this_func \
1059 = STR_CON3 (FUN, SUFF, TEST_SUFF) TEST_SUFF_STR; \
1060 init_max_error (this_func, EXACT, TEST_COND_any_ibm128)
1062 print_max_error (this_func)
1063 #define END_COMPLEX \
1064 print_complex_max_error (this_func)
1066 /* Run tests for a given function in all rounding modes. */
1067 #define ALL_RM_TEST(FUNC, EXACT, ARRAY, LOOP_MACRO, END_MACRO, ...) \
1072 START (FUNC,, EXACT); \
1073 LOOP_MACRO (FUNC, ARRAY, , ## __VA_ARGS__); \
1079 START (FUNC, _downward, EXACT); \
1080 LOOP_MACRO (FUNC, ARRAY, FE_DOWNWARD, ## __VA_ARGS__); \
1086 START (FUNC, _towardzero, EXACT); \
1087 LOOP_MACRO (FUNC, ARRAY, FE_TOWARDZERO, ## __VA_ARGS__); \
1093 START (FUNC, _upward, EXACT); \
1094 LOOP_MACRO (FUNC, ARRAY, FE_UPWARD, ## __VA_ARGS__); \
1101 /* Short description of program. */
1102 const char doc
[] = "Math test suite: " TEST_MSG
;
1104 static void do_test (void);
1107 main (int argc
, char **argv
)
1109 libm_test_init (argc
, argv
);
1112 return libm_test_finish ();