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
182 struct test_aa_f_data
185 ARG_FLOAT arg1
, arg2
;
193 struct test_fi_f_data
204 struct test_fl_f_data
215 struct test_if_f_data
226 struct test_fff_f_data
229 FLOAT arg1
, arg2
, arg3
;
236 struct test_fiu_M_data
248 struct test_fiu_U_data
270 /* Used for both RUN_TEST_LOOP_f_f1 and RUN_TEST_LOOP_fI_f1. */
271 struct test_f_f1_data
283 struct test_fF_f1_data
292 FLOAT extra_expected
;
295 struct test_ffI_f1_data
317 struct test_cc_c_data
320 FLOAT arg1r
, arg1c
, arg2r
, arg2c
;
327 /* Used for all of RUN_TEST_LOOP_f_i, RUN_TEST_LOOP_f_i_tg,
328 RUN_TEST_LOOP_f_b and RUN_TEST_LOOP_f_b_tg. */
339 /* Used for RUN_TEST_LOOP_f_i_tg_u and RUN_TEST_LOOP_f_b_tg_u. */
340 #if TEST_COND_intel96
341 struct test_j_i_data_u
344 ieee_long_double_shape_type arg
;
352 /* Used for RUN_TEST_LOOP_ff_b, RUN_TEST_LOOP_fpfp_b and
353 RUN_TEST_LOOP_ff_i_tg. */
354 struct test_ff_i_data
380 long long int expected
;
384 struct test_fFF_11_data
392 FLOAT extra1_expected
;
394 FLOAT extra2_expected
;
397 /* Used for both RUN_TEST_LOOP_Ff_b1 and RUN_TEST_LOOP_Ffp_b1. */
398 struct test_Ff_b1_data
407 FLOAT extra_expected
;
411 /* Set the rounding mode, or restore the saved value. */
412 #define IF_ROUND_INIT_ /* Empty. */
413 #define IF_ROUND_INIT_FE_DOWNWARD \
414 int save_round_mode = fegetround (); \
415 if (ROUNDING_TESTS (FLOAT, FE_DOWNWARD) \
417 && fesetround (FE_DOWNWARD) == 0)
418 #define IF_ROUND_INIT_FE_TONEAREST \
419 int save_round_mode = fegetround (); \
420 if (ROUNDING_TESTS (FLOAT, FE_TONEAREST) \
421 && fesetround (FE_TONEAREST) == 0)
422 #define IF_ROUND_INIT_FE_TOWARDZERO \
423 int save_round_mode = fegetround (); \
424 if (ROUNDING_TESTS (FLOAT, FE_TOWARDZERO) \
426 && fesetround (FE_TOWARDZERO) == 0)
427 #define IF_ROUND_INIT_FE_UPWARD \
428 int save_round_mode = fegetround (); \
429 if (ROUNDING_TESTS (FLOAT, FE_UPWARD) \
431 && fesetround (FE_UPWARD) == 0)
432 #define ROUND_RESTORE_ /* Empty. */
433 #define ROUND_RESTORE_FE_DOWNWARD \
434 fesetround (save_round_mode)
435 #define ROUND_RESTORE_FE_TONEAREST \
436 fesetround (save_round_mode)
437 #define ROUND_RESTORE_FE_TOWARDZERO \
438 fesetround (save_round_mode)
439 #define ROUND_RESTORE_FE_UPWARD \
440 fesetround (save_round_mode)
442 /* Field name to use for a given rounding mode. */
444 #define RM_FE_DOWNWARD rd
445 #define RM_FE_TONEAREST rn
446 #define RM_FE_TOWARDZERO rz
447 #define RM_FE_UPWARD ru
449 /* Common setup for an individual test. */
450 #define COMMON_TEST_SETUP(ARG_STR) \
452 if (asprintf (&test_name, "%s (%s)", this_func, (ARG_STR)) == -1) \
455 /* Setup for a test with an extra output. */
456 #define EXTRA_OUTPUT_TEST_SETUP(ARG_STR, N) \
457 char *extra##N##_name; \
458 if (asprintf (&extra##N##_name, "%s (%s) extra output " #N, \
459 this_func, (ARG_STR)) == -1) \
462 /* Common cleanup after an individual test. */
463 #define COMMON_TEST_CLEANUP \
466 /* Cleanup for a test with an extra output. */
467 #define EXTRA_OUTPUT_TEST_CLEANUP(N) \
468 free (extra##N##_name)
470 /* Run an individual test, including any required setup and checking
471 of results, or loop over all tests in an array. */
472 #define RUN_TEST_1_f(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
475 if (enable_test (EXCEPTIONS)) \
477 COMMON_TEST_SETUP (ARG_STR); \
478 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG), \
479 EXPECTED, EXCEPTIONS); \
480 COMMON_TEST_CLEANUP; \
483 #define RUN_TEST_LOOP_1_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
484 IF_ROUND_INIT_ ## ROUNDING_MODE \
485 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
486 RUN_TEST_1_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
487 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
488 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
489 ROUND_RESTORE_ ## ROUNDING_MODE
490 #define RUN_TEST_LOOP_f_f RUN_TEST_LOOP_1_f
491 #define RUN_TEST_LOOP_a_f RUN_TEST_LOOP_1_f
492 #define RUN_TEST_fp_f(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
495 if (enable_test (EXCEPTIONS)) \
497 COMMON_TEST_SETUP (ARG_STR); \
498 check_float (test_name, FUNC_TEST (FUNC_NAME) (&(ARG)), \
499 EXPECTED, EXCEPTIONS); \
500 COMMON_TEST_CLEANUP; \
503 #define RUN_TEST_LOOP_fp_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
504 IF_ROUND_INIT_ ## ROUNDING_MODE \
505 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
506 RUN_TEST_fp_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
507 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
508 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
509 ROUND_RESTORE_ ## ROUNDING_MODE
510 #define RUN_TEST_2_f(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
513 if (enable_test (EXCEPTIONS)) \
515 COMMON_TEST_SETUP (ARG_STR); \
516 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG1, ARG2), \
517 EXPECTED, EXCEPTIONS); \
518 COMMON_TEST_CLEANUP; \
521 #define RUN_TEST_LOOP_2_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
522 IF_ROUND_INIT_ ## ROUNDING_MODE \
523 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
524 RUN_TEST_2_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \
526 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
527 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
528 ROUND_RESTORE_ ## ROUNDING_MODE
529 #define RUN_TEST_ff_f RUN_TEST_2_f
530 #define RUN_TEST_LOOP_ff_f RUN_TEST_LOOP_2_f
531 #define RUN_TEST_LOOP_fj_f RUN_TEST_LOOP_2_f
532 #define RUN_TEST_LOOP_aa_f RUN_TEST_LOOP_2_f
533 #define RUN_TEST_fi_f RUN_TEST_2_f
534 #define RUN_TEST_LOOP_fi_f RUN_TEST_LOOP_2_f
535 #define RUN_TEST_fl_f RUN_TEST_2_f
536 #define RUN_TEST_LOOP_fl_f RUN_TEST_LOOP_2_f
537 #define RUN_TEST_if_f RUN_TEST_2_f
538 #define RUN_TEST_LOOP_if_f RUN_TEST_LOOP_2_f
539 #define RUN_TEST_fff_f(ARG_STR, FUNC_NAME, ARG1, ARG2, ARG3, \
540 EXPECTED, EXCEPTIONS) \
542 if (enable_test (EXCEPTIONS)) \
544 COMMON_TEST_SETUP (ARG_STR); \
545 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG1, ARG2, ARG3), \
546 EXPECTED, EXCEPTIONS); \
547 COMMON_TEST_CLEANUP; \
550 #define RUN_TEST_LOOP_fff_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
551 IF_ROUND_INIT_ ## ROUNDING_MODE \
552 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
553 RUN_TEST_fff_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \
554 (ARRAY)[i].arg2, (ARRAY)[i].arg3, \
555 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
556 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
557 ROUND_RESTORE_ ## ROUNDING_MODE
558 #define RUN_TEST_fiu_M(ARG_STR, FUNC_NAME, ARG1, ARG2, ARG3, \
559 EXPECTED, EXCEPTIONS) \
561 if (enable_test (EXCEPTIONS)) \
563 COMMON_TEST_SETUP (ARG_STR); \
564 check_intmax_t (test_name, \
565 FUNC_TEST (FUNC_NAME) (ARG1, ARG2, ARG3), \
566 EXPECTED, EXCEPTIONS); \
567 COMMON_TEST_CLEANUP; \
570 #define RUN_TEST_LOOP_fiu_M(FUNC_NAME, ARRAY, ROUNDING_MODE) \
571 IF_ROUND_INIT_ ## ROUNDING_MODE \
572 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
573 RUN_TEST_fiu_M ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \
574 (ARRAY)[i].arg2, (ARRAY)[i].arg3, \
575 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
576 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
577 ROUND_RESTORE_ ## ROUNDING_MODE
578 #define RUN_TEST_fiu_U(ARG_STR, FUNC_NAME, ARG1, ARG2, ARG3, \
579 EXPECTED, EXCEPTIONS) \
581 if (enable_test (EXCEPTIONS)) \
583 COMMON_TEST_SETUP (ARG_STR); \
584 check_uintmax_t (test_name, \
585 FUNC_TEST (FUNC_NAME) (ARG1, ARG2, ARG3), \
586 EXPECTED, EXCEPTIONS); \
587 COMMON_TEST_CLEANUP; \
590 #define RUN_TEST_LOOP_fiu_U(FUNC_NAME, ARRAY, ROUNDING_MODE) \
591 IF_ROUND_INIT_ ## ROUNDING_MODE \
592 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
593 RUN_TEST_fiu_U ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \
594 (ARRAY)[i].arg2, (ARRAY)[i].arg3, \
595 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
596 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
597 ROUND_RESTORE_ ## ROUNDING_MODE
598 #define RUN_TEST_c_f(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
601 if (enable_test (EXCEPTIONS)) \
603 COMMON_TEST_SETUP (ARG_STR); \
604 check_float (test_name, \
605 FUNC_TEST (FUNC_NAME) (BUILD_COMPLEX (ARG1, ARG2)),\
606 EXPECTED, EXCEPTIONS); \
607 COMMON_TEST_CLEANUP; \
610 #define RUN_TEST_LOOP_c_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
611 IF_ROUND_INIT_ ## ROUNDING_MODE \
612 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
613 RUN_TEST_c_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].argr, \
615 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
616 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
617 ROUND_RESTORE_ ## ROUNDING_MODE
618 #define RUN_TEST_f_f1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
619 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
622 if (enable_test (EXCEPTIONS)) \
624 COMMON_TEST_SETUP (ARG_STR); \
625 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
626 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG), EXPECTED, \
628 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
630 check_int (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, 0); \
631 EXTRA_OUTPUT_TEST_CLEANUP (1); \
632 COMMON_TEST_CLEANUP; \
635 #define RUN_TEST_LOOP_f_f1(FUNC_NAME, ARRAY, ROUNDING_MODE, EXTRA_VAR) \
636 IF_ROUND_INIT_ ## ROUNDING_MODE \
637 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
638 RUN_TEST_f_f1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
639 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
640 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
642 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
643 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
644 ROUND_RESTORE_ ## ROUNDING_MODE
645 #define RUN_TEST_fF_f1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
646 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
649 if (enable_test (EXCEPTIONS)) \
651 COMMON_TEST_SETUP (ARG_STR); \
652 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
653 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG, &(EXTRA_VAR)), \
654 EXPECTED, EXCEPTIONS); \
655 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
657 check_float (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, 0); \
658 EXTRA_OUTPUT_TEST_CLEANUP (1); \
659 COMMON_TEST_CLEANUP; \
662 #define RUN_TEST_LOOP_fF_f1(FUNC_NAME, ARRAY, ROUNDING_MODE, EXTRA_VAR) \
663 IF_ROUND_INIT_ ## ROUNDING_MODE \
664 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
665 RUN_TEST_fF_f1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
666 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
667 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
669 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
670 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
671 ROUND_RESTORE_ ## ROUNDING_MODE
672 #define RUN_TEST_fI_f1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
673 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
676 if (enable_test (EXCEPTIONS)) \
678 COMMON_TEST_SETUP (ARG_STR); \
679 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
680 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG, &(EXTRA_VAR)), \
681 EXPECTED, EXCEPTIONS); \
682 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
684 check_int (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, 0); \
685 EXTRA_OUTPUT_TEST_CLEANUP (1); \
686 COMMON_TEST_CLEANUP; \
689 #define RUN_TEST_LOOP_fI_f1(FUNC_NAME, ARRAY, ROUNDING_MODE, EXTRA_VAR) \
690 IF_ROUND_INIT_ ## ROUNDING_MODE \
691 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
692 RUN_TEST_fI_f1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
693 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
694 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
696 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
697 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
698 ROUND_RESTORE_ ## ROUNDING_MODE
699 #define RUN_TEST_ffI_f1_mod8(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
700 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
703 if (enable_test (EXCEPTIONS)) \
705 COMMON_TEST_SETUP (ARG_STR); \
706 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
707 check_float (test_name, \
708 FUNC_TEST (FUNC_NAME) (ARG1, ARG2, &(EXTRA_VAR)), \
709 EXPECTED, EXCEPTIONS); \
710 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
712 check_int (extra1_name, (EXTRA_VAR) % 8, EXTRA_EXPECTED, 0); \
713 EXTRA_OUTPUT_TEST_CLEANUP (1); \
714 COMMON_TEST_CLEANUP; \
717 #define RUN_TEST_LOOP_ffI_f1_mod8(FUNC_NAME, ARRAY, ROUNDING_MODE, \
719 IF_ROUND_INIT_ ## ROUNDING_MODE \
720 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
721 RUN_TEST_ffI_f1_mod8 ((ARRAY)[i].arg_str, FUNC_NAME, \
722 (ARRAY)[i].arg1, (ARRAY)[i].arg2, \
723 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
724 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
726 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
727 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
728 ROUND_RESTORE_ ## ROUNDING_MODE
729 #define RUN_TEST_Ff_b1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
730 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
733 if (enable_test (EXCEPTIONS)) \
735 COMMON_TEST_SETUP (ARG_STR); \
736 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
737 /* Clear any exceptions from comparison involving sNaN \
739 feclearexcept (FE_ALL_EXCEPT); \
740 check_bool (test_name, FUNC_TEST (FUNC_NAME) (&(EXTRA_VAR), \
742 EXPECTED, EXCEPTIONS); \
743 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
745 check_float (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, \
746 (EXCEPTIONS) & TEST_NAN_PAYLOAD); \
747 EXTRA_OUTPUT_TEST_CLEANUP (1); \
748 COMMON_TEST_CLEANUP; \
751 #define RUN_TEST_LOOP_Ff_b1(FUNC_NAME, ARRAY, ROUNDING_MODE, \
753 IF_ROUND_INIT_ ## ROUNDING_MODE \
754 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
755 RUN_TEST_Ff_b1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
756 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
757 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
759 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
760 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
761 ROUND_RESTORE_ ## ROUNDING_MODE
762 #define RUN_TEST_Ffp_b1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
763 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
766 if (enable_test (EXCEPTIONS)) \
768 COMMON_TEST_SETUP (ARG_STR); \
769 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
770 check_bool (test_name, FUNC_TEST (FUNC_NAME) (&(EXTRA_VAR), \
772 EXPECTED, EXCEPTIONS); \
773 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
775 check_float (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, \
776 (EXCEPTIONS) & TEST_NAN_PAYLOAD); \
777 EXTRA_OUTPUT_TEST_CLEANUP (1); \
778 COMMON_TEST_CLEANUP; \
781 #define RUN_TEST_LOOP_Ffp_b1(FUNC_NAME, ARRAY, ROUNDING_MODE, \
783 IF_ROUND_INIT_ ## ROUNDING_MODE \
784 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
785 RUN_TEST_Ffp_b1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
786 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
787 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
789 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
790 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
791 ROUND_RESTORE_ ## ROUNDING_MODE
792 #define RUN_TEST_c_c(ARG_STR, FUNC_NAME, ARGR, ARGC, EXPR, EXPC, \
795 if (enable_test (EXCEPTIONS)) \
797 COMMON_TEST_SETUP (ARG_STR); \
798 check_complex (test_name, \
799 FUNC_TEST (FUNC_NAME) (BUILD_COMPLEX (ARGR, ARGC)), \
800 BUILD_COMPLEX (EXPR, EXPC), EXCEPTIONS); \
801 COMMON_TEST_CLEANUP; \
804 #define RUN_TEST_LOOP_c_c(FUNC_NAME, ARRAY, ROUNDING_MODE) \
805 IF_ROUND_INIT_ ## ROUNDING_MODE \
806 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
807 RUN_TEST_c_c ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].argr, \
809 (ARRAY)[i].RM_##ROUNDING_MODE.expr, \
810 (ARRAY)[i].RM_##ROUNDING_MODE.expc, \
811 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
812 ROUND_RESTORE_ ## ROUNDING_MODE
813 #define RUN_TEST_cc_c(ARG_STR, FUNC_NAME, ARG1R, ARG1C, ARG2R, ARG2C, \
814 EXPR, EXPC, EXCEPTIONS) \
816 if (enable_test (EXCEPTIONS)) \
818 COMMON_TEST_SETUP (ARG_STR); \
819 check_complex (test_name, \
820 FUNC_TEST (FUNC_NAME) (BUILD_COMPLEX (ARG1R, ARG1C), \
821 BUILD_COMPLEX (ARG2R, ARG2C)), \
822 BUILD_COMPLEX (EXPR, EXPC), EXCEPTIONS); \
823 COMMON_TEST_CLEANUP; \
826 #define RUN_TEST_LOOP_cc_c(FUNC_NAME, ARRAY, ROUNDING_MODE) \
827 IF_ROUND_INIT_ ## ROUNDING_MODE \
828 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
829 RUN_TEST_cc_c ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1r, \
830 (ARRAY)[i].arg1c, (ARRAY)[i].arg2r, \
832 (ARRAY)[i].RM_##ROUNDING_MODE.expr, \
833 (ARRAY)[i].RM_##ROUNDING_MODE.expc, \
834 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
835 ROUND_RESTORE_ ## ROUNDING_MODE
836 #define RUN_TEST_f_i(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \
838 if (enable_test (EXCEPTIONS)) \
840 COMMON_TEST_SETUP (ARG_STR); \
841 check_int (test_name, FUNC_TEST (FUNC_NAME) (ARG), EXPECTED, \
843 COMMON_TEST_CLEANUP; \
846 #define RUN_TEST_LOOP_f_i(FUNC_NAME, ARRAY, ROUNDING_MODE) \
847 IF_ROUND_INIT_ ## ROUNDING_MODE \
848 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
849 RUN_TEST_f_i ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
850 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
851 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
852 ROUND_RESTORE_ ## ROUNDING_MODE
853 #define RUN_TEST_f_i_tg(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
856 if (enable_test (EXCEPTIONS)) \
858 COMMON_TEST_SETUP (ARG_STR); \
859 check_int (test_name, FUNC_NAME (ARG), EXPECTED, EXCEPTIONS); \
860 COMMON_TEST_CLEANUP; \
863 #define RUN_TEST_LOOP_f_i_tg(FUNC_NAME, ARRAY, ROUNDING_MODE) \
864 IF_ROUND_INIT_ ## ROUNDING_MODE \
865 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
866 RUN_TEST_f_i_tg ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
867 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
868 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
869 ROUND_RESTORE_ ## ROUNDING_MODE
870 #define RUN_TEST_LOOP_j_b_tg_u(FUNC_NAME, ARRAY, ROUNDING_MODE) \
871 IF_ROUND_INIT_ ## ROUNDING_MODE \
872 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
873 RUN_TEST_f_b_tg ((ARRAY)[i].arg_str, FUNC_NAME, \
874 (FLOAT)(ARRAY)[i].arg.value, \
875 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
876 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
877 ROUND_RESTORE_ ## ROUNDING_MODE
878 #define RUN_TEST_LOOP_j_i_tg_u(FUNC_NAME, ARRAY, ROUNDING_MODE) \
879 IF_ROUND_INIT_ ## ROUNDING_MODE \
880 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
881 RUN_TEST_f_i_tg ((ARRAY)[i].arg_str, FUNC_NAME, \
882 (FLOAT)(ARRAY)[i].arg.value, \
883 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
884 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
885 ROUND_RESTORE_ ## ROUNDING_MODE
886 #define RUN_TEST_ff_b(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
889 if (enable_test (EXCEPTIONS)) \
891 COMMON_TEST_SETUP (ARG_STR); \
892 check_bool (test_name, FUNC_TEST (FUNC_NAME) (ARG1, ARG2), \
893 EXPECTED, EXCEPTIONS); \
894 COMMON_TEST_CLEANUP; \
897 #define RUN_TEST_LOOP_ff_b(FUNC_NAME, ARRAY, ROUNDING_MODE) \
898 IF_ROUND_INIT_ ## ROUNDING_MODE \
899 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
900 RUN_TEST_ff_b ((ARRAY)[i].arg_str, FUNC_NAME, \
901 (ARRAY)[i].arg1, (ARRAY)[i].arg2, \
902 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
903 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
904 ROUND_RESTORE_ ## ROUNDING_MODE
905 #define RUN_TEST_fpfp_b(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
908 if (enable_test (EXCEPTIONS)) \
910 COMMON_TEST_SETUP (ARG_STR); \
911 check_bool (test_name, \
912 FUNC_TEST (FUNC_NAME) (&(ARG1), &(ARG2)), \
913 EXPECTED, EXCEPTIONS); \
914 COMMON_TEST_CLEANUP; \
917 #define RUN_TEST_LOOP_fpfp_b(FUNC_NAME, ARRAY, ROUNDING_MODE) \
918 IF_ROUND_INIT_ ## ROUNDING_MODE \
919 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
920 RUN_TEST_fpfp_b ((ARRAY)[i].arg_str, FUNC_NAME, \
921 (ARRAY)[i].arg1, (ARRAY)[i].arg2, \
922 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
923 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
924 ROUND_RESTORE_ ## ROUNDING_MODE
925 #define RUN_TEST_ff_i_tg(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
928 if (enable_test (EXCEPTIONS)) \
930 COMMON_TEST_SETUP (ARG_STR); \
931 check_int (test_name, FUNC_NAME (ARG1, ARG2), EXPECTED, \
933 COMMON_TEST_CLEANUP; \
936 #define RUN_TEST_LOOP_ff_i_tg(FUNC_NAME, ARRAY, ROUNDING_MODE) \
937 IF_ROUND_INIT_ ## ROUNDING_MODE \
938 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
939 RUN_TEST_ff_i_tg ((ARRAY)[i].arg_str, FUNC_NAME, \
940 (ARRAY)[i].arg1, (ARRAY)[i].arg2, \
941 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
942 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
943 ROUND_RESTORE_ ## ROUNDING_MODE
944 #define RUN_TEST_f_b(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \
946 if (enable_test (EXCEPTIONS)) \
948 COMMON_TEST_SETUP (ARG_STR); \
949 check_bool (test_name, FUNC_TEST (FUNC_NAME) (ARG), EXPECTED, \
951 COMMON_TEST_CLEANUP; \
954 #define RUN_TEST_LOOP_f_b(FUNC_NAME, ARRAY, ROUNDING_MODE) \
955 IF_ROUND_INIT_ ## ROUNDING_MODE \
956 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
957 RUN_TEST_f_b ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
958 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
959 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
960 ROUND_RESTORE_ ## ROUNDING_MODE
961 #define RUN_TEST_f_b_tg(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
964 if (enable_test (EXCEPTIONS)) \
966 COMMON_TEST_SETUP (ARG_STR); \
967 check_bool (test_name, FUNC_NAME (ARG), EXPECTED, EXCEPTIONS); \
968 COMMON_TEST_CLEANUP; \
971 #define RUN_TEST_LOOP_f_b_tg(FUNC_NAME, ARRAY, ROUNDING_MODE) \
972 IF_ROUND_INIT_ ## ROUNDING_MODE \
973 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
974 RUN_TEST_f_b_tg ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
975 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
976 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
977 ROUND_RESTORE_ ## ROUNDING_MODE
978 #define RUN_TEST_f_l(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \
980 if (enable_test (EXCEPTIONS)) \
982 COMMON_TEST_SETUP (ARG_STR); \
983 check_long (test_name, FUNC_TEST (FUNC_NAME) (ARG), EXPECTED, \
985 COMMON_TEST_CLEANUP; \
988 #define RUN_TEST_LOOP_f_l(FUNC_NAME, ARRAY, ROUNDING_MODE) \
989 IF_ROUND_INIT_ ## ROUNDING_MODE \
990 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
991 RUN_TEST_f_l ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
992 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
993 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
994 ROUND_RESTORE_ ## ROUNDING_MODE
995 #define RUN_TEST_f_L(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \
997 if (enable_test (EXCEPTIONS)) \
999 COMMON_TEST_SETUP (ARG_STR); \
1000 check_longlong (test_name, FUNC_TEST (FUNC_NAME) (ARG), \
1001 EXPECTED, EXCEPTIONS); \
1002 COMMON_TEST_CLEANUP; \
1005 #define RUN_TEST_LOOP_f_L(FUNC_NAME, ARRAY, ROUNDING_MODE) \
1006 IF_ROUND_INIT_ ## ROUNDING_MODE \
1007 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
1008 RUN_TEST_f_L ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
1009 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
1010 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
1011 ROUND_RESTORE_ ## ROUNDING_MODE
1012 #define RUN_TEST_fFF_11(ARG_STR, FUNC_NAME, ARG, EXCEPTIONS, \
1013 EXTRA1_VAR, EXTRA1_TEST, \
1014 EXTRA1_EXPECTED, EXTRA2_VAR, \
1015 EXTRA2_TEST, EXTRA2_EXPECTED) \
1017 if (enable_test (EXCEPTIONS)) \
1019 COMMON_TEST_SETUP (ARG_STR); \
1020 FUNC_TEST (FUNC_NAME) (ARG, &(EXTRA1_VAR), &(EXTRA2_VAR)); \
1021 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
1023 check_float (extra1_name, EXTRA1_VAR, EXTRA1_EXPECTED, \
1025 EXTRA_OUTPUT_TEST_CLEANUP (1); \
1026 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 2); \
1028 check_float (extra2_name, EXTRA2_VAR, EXTRA2_EXPECTED, 0); \
1029 EXTRA_OUTPUT_TEST_CLEANUP (2); \
1030 COMMON_TEST_CLEANUP; \
1033 #define RUN_TEST_LOOP_fFF_11(FUNC_NAME, ARRAY, ROUNDING_MODE, \
1034 EXTRA1_VAR, EXTRA2_VAR) \
1035 IF_ROUND_INIT_ ## ROUNDING_MODE \
1036 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
1037 RUN_TEST_fFF_11 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
1038 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
1040 (ARRAY)[i].RM_##ROUNDING_MODE.extra1_test, \
1041 (ARRAY)[i].RM_##ROUNDING_MODE.extra1_expected, \
1043 (ARRAY)[i].RM_##ROUNDING_MODE.extra2_test, \
1044 (ARRAY)[i].RM_##ROUNDING_MODE.extra2_expected); \
1045 ROUND_RESTORE_ ## ROUNDING_MODE
1048 # define TEST_SUFF VEC_SUFF
1049 # define TEST_SUFF_STR
1052 # define TEST_SUFF_STR "_" ARG_TYPE_STR
1055 # define TEST_SUFF_STR
1058 #define STR_CONCAT(a, b, c) __STRING (a##b##c)
1059 #define STR_CON3(a, b, c) STR_CONCAT (a, b, c)
1062 # define TEST_COND_any_ibm128 (TEST_COND_ibm128 || TEST_COND_arg_ibm128)
1064 # define TEST_COND_any_ibm128 TEST_COND_ibm128
1067 /* Start and end the tests for a given function. */
1068 #define START(FUN, SUFF, EXACT) \
1070 const char *this_func \
1071 = STR_CON3 (FUN, SUFF, TEST_SUFF) TEST_SUFF_STR; \
1072 init_max_error (this_func, EXACT, TEST_COND_any_ibm128)
1074 print_max_error (this_func)
1075 #define END_COMPLEX \
1076 print_complex_max_error (this_func)
1078 /* Run tests for a given function in all rounding modes. */
1079 #define ALL_RM_TEST(FUNC, EXACT, ARRAY, LOOP_MACRO, END_MACRO, ...) \
1084 START (FUNC,, EXACT); \
1085 LOOP_MACRO (FUNC, ARRAY, , ## __VA_ARGS__); \
1091 START (FUNC, _downward, EXACT); \
1092 LOOP_MACRO (FUNC, ARRAY, FE_DOWNWARD, ## __VA_ARGS__); \
1098 START (FUNC, _towardzero, EXACT); \
1099 LOOP_MACRO (FUNC, ARRAY, FE_TOWARDZERO, ## __VA_ARGS__); \
1105 START (FUNC, _upward, EXACT); \
1106 LOOP_MACRO (FUNC, ARRAY, FE_UPWARD, ## __VA_ARGS__); \
1113 /* Short description of program. */
1114 const char doc
[] = "Math test suite: " TEST_MSG
;
1116 static void do_test (void);
1119 main (int argc
, char **argv
)
1121 libm_test_init (argc
, argv
);
1124 return libm_test_finish ();