]> git.ipfire.org Git - thirdparty/glibc.git/blob - math/libm-test-driver.c
projects / thirdparty / glibc.git / blob
? search:


4610280829038ec583ed4ea16485ad1cdcafe3f3
[thirdparty/glibc.git] / math / libm-test-driver.c
1 /* Support code for testing libm functions (driver).
2 Copyright (C) 1997-2025 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
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.
9
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.
14
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/>. */
18
19 #include "libm-test-support.h"
20
21 #include <math-tests-arch.h>
22
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;
27
28 #if TEST_NARROW
29 const int snan_tests_arg = SNAN_TESTS (ARG_FLOAT);
30 #else
31 const int snan_tests_arg = SNAN_TESTS (FLOAT);
32 #endif
33
34 #define STRX(x) #x
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)
39
40 /* Informal description of the functions being tested. */
41 #if TEST_MATHVEC
42 # define TEST_MSG "testing " STR_FLOAT " (vector length " STR_VEC_LEN ")\n"
43 #elif TEST_NARROW
44 # define TEST_MSG "testing " STR_FLOAT " (argument " STR_ARG_FLOAT ")\n"
45 #else
46 # define TEST_MSG "testing " STR_FLOAT " (without inline functions)\n"
47 #endif
48 const char test_msg[] = TEST_MSG;
49
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. */
53 #ifndef FE_TONEAREST
54 # define FE_TONEAREST __FE_UNDEFINED
55 #endif
56 #ifndef FE_TOWARDZERO
57 # define FE_TOWARDZERO __FE_UNDEFINED
58 #endif
59 #ifndef FE_UPWARD
60 # define FE_UPWARD __FE_UNDEFINED
61 #endif
62 #ifndef FE_DOWNWARD
63 # define FE_DOWNWARD __FE_UNDEFINED
64 #endif
65
66 #define TEST_NAN_PAYLOAD_CANONICALIZE (SNAN_TESTS_PRESERVE_PAYLOAD \
67 ? TEST_NAN_PAYLOAD \
68 : 0)
69
70 const char qtype_str[] = TYPE_STR;
71
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. */
75
76 /* (pi * 3) / 4 */
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)
84 /* pi / ln(10) */
85 #define lit_pi_ln10_d LIT (1.364376353841841347485783625431355770)
86 /* pi / 2 */
87 #define lit_pi_2_d LITM (M_PI_2)
88 /* pi / 4 */
89 #define lit_pi_4_d LITM (M_PI_4)
90 /* pi */
91 #define lit_pi LITM (M_PI)
92
93 /* Other useful constants. */
94
95 /* e */
96 #define lit_e LITM (M_E)
97
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
109
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
121
122 /* For nexttoward tests. */
123 #define snan_value_ld __builtin_nansl ("")
124
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 }}
133 #endif
134
135 /* Structures for each kind of test. */
136 /* Used for both RUN_TEST_LOOP_f_f and RUN_TEST_LOOP_fp_f. */
137 struct test_f_f_data
138 {
139 const char *arg_str;
140 FLOAT arg;
141 struct
142 {
143 FLOAT expected;
144 int exceptions;
145 } rd, rn, rz, ru;
146 };
147 struct test_ff_f_data
148 {
149 const char *arg_str;
150 FLOAT arg1, arg2;
151 struct
152 {
153 FLOAT expected;
154 int exceptions;
155 } rd, rn, rz, ru;
156 };
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
161 {
162 const char *arg_str;
163 FLOAT arg1;
164 long double arg2;
165 struct
166 {
167 FLOAT expected;
168 int exceptions;
169 } rd, rn, rz, ru;
170 };
171 #ifdef ARG_FLOAT
172 struct test_a_f_data
173 {
174 const char *arg_str;
175 ARG_FLOAT arg;
176 struct
177 {
178 FLOAT expected;
179 int exceptions;
180 } rd, rn, rz, ru;
181 };
182 struct test_aa_f_data
183 {
184 const char *arg_str;
185 ARG_FLOAT arg1, arg2;
186 struct
187 {
188 FLOAT expected;
189 int exceptions;
190 } rd, rn, rz, ru;
191 };
192 struct test_aaa_f_data
193 {
194 const char *arg_str;
195 ARG_FLOAT arg1, arg2, arg3;
196 struct
197 {
198 FLOAT expected;
199 int exceptions;
200 } rd, rn, rz, ru;
201 };
202 #endif
203 struct test_fi_f_data
204 {
205 const char *arg_str;
206 FLOAT arg1;
207 int arg2;
208 struct
209 {
210 FLOAT expected;
211 int exceptions;
212 } rd, rn, rz, ru;
213 };
214 struct test_fl_f_data
215 {
216 const char *arg_str;
217 FLOAT arg1;
218 long int arg2;
219 struct
220 {
221 FLOAT expected;
222 int exceptions;
223 } rd, rn, rz, ru;
224 };
225 struct test_fL_f_data
226 {
227 const char *arg_str;
228 FLOAT arg1;
229 long long int arg2;
230 struct
231 {
232 FLOAT expected;
233 int exceptions;
234 } rd, rn, rz, ru;
235 };
236 struct test_if_f_data
237 {
238 const char *arg_str;
239 int arg1;
240 FLOAT arg2;
241 struct
242 {
243 FLOAT expected;
244 int exceptions;
245 } rd, rn, rz, ru;
246 };
247 struct test_fff_f_data
248 {
249 const char *arg_str;
250 FLOAT arg1, arg2, arg3;
251 struct
252 {
253 FLOAT expected;
254 int exceptions;
255 } rd, rn, rz, ru;
256 };
257 struct test_fiu_M_data
258 {
259 const char *arg_str;
260 FLOAT arg1;
261 int arg2;
262 unsigned int arg3;
263 struct
264 {
265 intmax_t expected;
266 int exceptions;
267 } rd, rn, rz, ru;
268 };
269 struct test_fiu_U_data
270 {
271 const char *arg_str;
272 FLOAT arg1;
273 int arg2;
274 unsigned int arg3;
275 struct
276 {
277 uintmax_t expected;
278 int exceptions;
279 } rd, rn, rz, ru;
280 };
281 struct test_c_f_data
282 {
283 const char *arg_str;
284 FLOAT argr, argc;
285 struct
286 {
287 FLOAT expected;
288 int exceptions;
289 } rd, rn, rz, ru;
290 };
291 /* Used for both RUN_TEST_LOOP_f_f1 and RUN_TEST_LOOP_fI_f1. */
292 struct test_f_f1_data
293 {
294 const char *arg_str;
295 FLOAT arg;
296 struct
297 {
298 FLOAT expected;
299 int exceptions;
300 int extra_test;
301 int extra_expected;
302 } rd, rn, rz, ru;
303 };
304 struct test_fF_f1_data
305 {
306 const char *arg_str;
307 FLOAT arg;
308 struct
309 {
310 FLOAT expected;
311 int exceptions;
312 int extra_test;
313 FLOAT extra_expected;
314 } rd, rn, rz, ru;
315 };
316 struct test_ffI_f1_data
317 {
318 const char *arg_str;
319 FLOAT arg1, arg2;
320 struct
321 {
322 FLOAT expected;
323 int exceptions;
324 int extra_test;
325 int extra_expected;
326 } rd, rn, rz, ru;
327 };
328 struct test_c_c_data
329 {
330 const char *arg_str;
331 FLOAT argr, argc;
332 struct
333 {
334 FLOAT expr, expc;
335 int exceptions;
336 } rd, rn, rz, ru;
337 };
338 struct test_cc_c_data
339 {
340 const char *arg_str;
341 FLOAT arg1r, arg1c, arg2r, arg2c;
342 struct
343 {
344 FLOAT expr, expc;
345 int exceptions;
346 } rd, rn, rz, ru;
347 };
348 /* Used for all of RUN_TEST_LOOP_f_i, RUN_TEST_LOOP_f_i_tg,
349 RUN_TEST_LOOP_f_b and RUN_TEST_LOOP_f_b_tg. */
350 struct test_f_i_data
351 {
352 const char *arg_str;
353 FLOAT arg;
354 struct
355 {
356 int expected;
357 int exceptions;
358 } rd, rn, rz, ru;
359 };
360 /* Used for RUN_TEST_LOOP_f_i_tg_u and RUN_TEST_LOOP_f_b_tg_u. */
361 #if TEST_COND_intel96
362 struct test_j_i_data_u
363 {
364 const char *arg_str;
365 ieee_long_double_shape_type arg;
366 struct
367 {
368 int expected;
369 int exceptions;
370 } rd, rn, rz, ru;
371 };
372 #endif
373 /* Used for RUN_TEST_LOOP_ff_b, RUN_TEST_LOOP_fpfp_b and
374 RUN_TEST_LOOP_ff_i_tg. */
375 struct test_ff_i_data
376 {
377 const char *arg_str;
378 FLOAT arg1, arg2;
379 struct
380 {
381 int expected;
382 int exceptions;
383 } rd, rn, rz, ru;
384 };
385 struct test_f_l_data
386 {
387 const char *arg_str;
388 FLOAT arg;
389 struct
390 {
391 long int expected;
392 int exceptions;
393 } rd, rn, rz, ru;
394 };
395 struct test_f_L_data
396 {
397 const char *arg_str;
398 FLOAT arg;
399 struct
400 {
401 long long int expected;
402 int exceptions;
403 } rd, rn, rz, ru;
404 };
405 struct test_fFF_11_data
406 {
407 const char *arg_str;
408 FLOAT arg;
409 struct
410 {
411 int exceptions;
412 int extra1_test;
413 FLOAT extra1_expected;
414 int extra2_test;
415 FLOAT extra2_expected;
416 } rd, rn, rz, ru;
417 };
418 /* Used for both RUN_TEST_LOOP_Ff_b1 and RUN_TEST_LOOP_Ffp_b1. */
419 struct test_Ff_b1_data
420 {
421 const char *arg_str;
422 FLOAT arg;
423 struct
424 {
425 int expected;
426 int exceptions;
427 int extra_test;
428 FLOAT extra_expected;
429 } rd, rn, rz, ru;
430 };
431
432 /* Set the rounding mode, or restore the saved value. */
433 #define IF_ROUND_INIT_ /* Empty. */
434 #define IF_ROUND_INIT_FE_DOWNWARD \
435 int save_round_mode = fegetround (); \
436 if (ROUNDING_TESTS (FLOAT, FE_DOWNWARD) \
437 && !TEST_MATHVEC \
438 && fesetround (FE_DOWNWARD) == 0)
439 #define IF_ROUND_INIT_FE_TONEAREST \
440 int save_round_mode = fegetround (); \
441 if (ROUNDING_TESTS (FLOAT, FE_TONEAREST) \
442 && fesetround (FE_TONEAREST) == 0)
443 #define IF_ROUND_INIT_FE_TOWARDZERO \
444 int save_round_mode = fegetround (); \
445 if (ROUNDING_TESTS (FLOAT, FE_TOWARDZERO) \
446 && !TEST_MATHVEC \
447 && fesetround (FE_TOWARDZERO) == 0)
448 #define IF_ROUND_INIT_FE_UPWARD \
449 int save_round_mode = fegetround (); \
450 if (ROUNDING_TESTS (FLOAT, FE_UPWARD) \
451 && !TEST_MATHVEC \
452 && fesetround (FE_UPWARD) == 0)
453 #define ROUND_RESTORE_ /* Empty. */
454 #define ROUND_RESTORE_FE_DOWNWARD \
455 fesetround (save_round_mode)
456 #define ROUND_RESTORE_FE_TONEAREST \
457 fesetround (save_round_mode)
458 #define ROUND_RESTORE_FE_TOWARDZERO \
459 fesetround (save_round_mode)
460 #define ROUND_RESTORE_FE_UPWARD \
461 fesetround (save_round_mode)
462
463 /* Field name to use for a given rounding mode. */
464 #define RM_ rn
465 #define RM_FE_DOWNWARD rd
466 #define RM_FE_TONEAREST rn
467 #define RM_FE_TOWARDZERO rz
468 #define RM_FE_UPWARD ru
469
470 /* Common setup for an individual test. */
471 #define COMMON_TEST_SETUP(ARG_STR) \
472 char *test_name; \
473 if (asprintf (&test_name, "%s (%s)", this_func, (ARG_STR)) == -1) \
474 abort ()
475
476 /* Setup for a test with an extra output. */
477 #define EXTRA_OUTPUT_TEST_SETUP(ARG_STR, N) \
478 char *extra##N##_name; \
479 if (asprintf (&extra##N##_name, "%s (%s) extra output " #N, \
480 this_func, (ARG_STR)) == -1) \
481 abort ()
482
483 /* Common cleanup after an individual test. */
484 #define COMMON_TEST_CLEANUP \
485 free (test_name)
486
487 /* Cleanup for a test with an extra output. */
488 #define EXTRA_OUTPUT_TEST_CLEANUP(N) \
489 free (extra##N##_name)
490
491 /* Run an individual test, including any required setup and checking
492 of results, or loop over all tests in an array. */
493 #define RUN_TEST_1_f(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
494 EXCEPTIONS) \
495 do \
496 if (enable_test (EXCEPTIONS)) \
497 { \
498 COMMON_TEST_SETUP (ARG_STR); \
499 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG), \
500 EXPECTED, EXCEPTIONS); \
501 COMMON_TEST_CLEANUP; \
502 } \
503 while (0)
504 #define RUN_TEST_LOOP_1_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
505 IF_ROUND_INIT_ ## ROUNDING_MODE \
506 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
507 RUN_TEST_1_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
508 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
509 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
510 ROUND_RESTORE_ ## ROUNDING_MODE
511 #define RUN_TEST_LOOP_f_f RUN_TEST_LOOP_1_f
512 #define RUN_TEST_LOOP_a_f RUN_TEST_LOOP_1_f
513 #define RUN_TEST_fp_f(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
514 EXCEPTIONS) \
515 do \
516 if (enable_test (EXCEPTIONS)) \
517 { \
518 COMMON_TEST_SETUP (ARG_STR); \
519 check_float (test_name, FUNC_TEST (FUNC_NAME) (&(ARG)), \
520 EXPECTED, EXCEPTIONS); \
521 COMMON_TEST_CLEANUP; \
522 } \
523 while (0)
524 #define RUN_TEST_LOOP_fp_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
525 IF_ROUND_INIT_ ## ROUNDING_MODE \
526 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
527 RUN_TEST_fp_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
528 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
529 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
530 ROUND_RESTORE_ ## ROUNDING_MODE
531 #define RUN_TEST_2_f(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
532 EXCEPTIONS) \
533 do \
534 if (enable_test (EXCEPTIONS)) \
535 { \
536 COMMON_TEST_SETUP (ARG_STR); \
537 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG1, ARG2), \
538 EXPECTED, EXCEPTIONS); \
539 COMMON_TEST_CLEANUP; \
540 } \
541 while (0)
542 #define RUN_TEST_LOOP_2_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
543 IF_ROUND_INIT_ ## ROUNDING_MODE \
544 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
545 RUN_TEST_2_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \
546 (ARRAY)[i].arg2, \
547 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
548 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
549 ROUND_RESTORE_ ## ROUNDING_MODE
550 #define RUN_TEST_ff_f RUN_TEST_2_f
551 #define RUN_TEST_LOOP_ff_f RUN_TEST_LOOP_2_f
552 #define RUN_TEST_LOOP_fj_f RUN_TEST_LOOP_2_f
553 #define RUN_TEST_LOOP_aa_f RUN_TEST_LOOP_2_f
554 #define RUN_TEST_fi_f RUN_TEST_2_f
555 #define RUN_TEST_LOOP_fi_f RUN_TEST_LOOP_2_f
556 #define RUN_TEST_fl_f RUN_TEST_2_f
557 #define RUN_TEST_LOOP_fl_f RUN_TEST_LOOP_2_f
558 #define RUN_TEST_fL_f RUN_TEST_2_f
559 #define RUN_TEST_LOOP_fL_f RUN_TEST_LOOP_2_f
560 #define RUN_TEST_if_f RUN_TEST_2_f
561 #define RUN_TEST_LOOP_if_f RUN_TEST_LOOP_2_f
562 #define RUN_TEST_3_f(ARG_STR, FUNC_NAME, ARG1, ARG2, ARG3, \
563 EXPECTED, EXCEPTIONS) \
564 do \
565 if (enable_test (EXCEPTIONS)) \
566 { \
567 COMMON_TEST_SETUP (ARG_STR); \
568 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG1, ARG2, ARG3), \
569 EXPECTED, EXCEPTIONS); \
570 COMMON_TEST_CLEANUP; \
571 } \
572 while (0)
573 #define RUN_TEST_LOOP_3_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
574 IF_ROUND_INIT_ ## ROUNDING_MODE \
575 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
576 RUN_TEST_3_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \
577 (ARRAY)[i].arg2, (ARRAY)[i].arg3, \
578 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
579 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
580 ROUND_RESTORE_ ## ROUNDING_MODE
581 #define RUN_TEST_LOOP_fff_f RUN_TEST_LOOP_3_f
582 #define RUN_TEST_LOOP_aaa_f RUN_TEST_LOOP_3_f
583 #define RUN_TEST_fiu_M(ARG_STR, FUNC_NAME, ARG1, ARG2, ARG3, \
584 EXPECTED, EXCEPTIONS) \
585 do \
586 if (enable_test (EXCEPTIONS)) \
587 { \
588 COMMON_TEST_SETUP (ARG_STR); \
589 check_intmax_t (test_name, \
590 FUNC_TEST (FUNC_NAME) (ARG1, ARG2, ARG3), \
591 EXPECTED, EXCEPTIONS); \
592 COMMON_TEST_CLEANUP; \
593 } \
594 while (0)
595 #define RUN_TEST_LOOP_fiu_M(FUNC_NAME, ARRAY, ROUNDING_MODE) \
596 IF_ROUND_INIT_ ## ROUNDING_MODE \
597 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
598 RUN_TEST_fiu_M ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \
599 (ARRAY)[i].arg2, (ARRAY)[i].arg3, \
600 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
601 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
602 ROUND_RESTORE_ ## ROUNDING_MODE
603 #define RUN_TEST_fiu_U(ARG_STR, FUNC_NAME, ARG1, ARG2, ARG3, \
604 EXPECTED, EXCEPTIONS) \
605 do \
606 if (enable_test (EXCEPTIONS)) \
607 { \
608 COMMON_TEST_SETUP (ARG_STR); \
609 check_uintmax_t (test_name, \
610 FUNC_TEST (FUNC_NAME) (ARG1, ARG2, ARG3), \
611 EXPECTED, EXCEPTIONS); \
612 COMMON_TEST_CLEANUP; \
613 } \
614 while (0)
615 #define RUN_TEST_LOOP_fiu_U(FUNC_NAME, ARRAY, ROUNDING_MODE) \
616 IF_ROUND_INIT_ ## ROUNDING_MODE \
617 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
618 RUN_TEST_fiu_U ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \
619 (ARRAY)[i].arg2, (ARRAY)[i].arg3, \
620 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
621 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
622 ROUND_RESTORE_ ## ROUNDING_MODE
623 #define RUN_TEST_c_f(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
624 EXCEPTIONS) \
625 do \
626 if (enable_test (EXCEPTIONS)) \
627 { \
628 COMMON_TEST_SETUP (ARG_STR); \
629 check_float (test_name, \
630 FUNC_TEST (FUNC_NAME) (BUILD_COMPLEX (ARG1, ARG2)),\
631 EXPECTED, EXCEPTIONS); \
632 COMMON_TEST_CLEANUP; \
633 } \
634 while (0)
635 #define RUN_TEST_LOOP_c_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \
636 IF_ROUND_INIT_ ## ROUNDING_MODE \
637 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
638 RUN_TEST_c_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].argr, \
639 (ARRAY)[i].argc, \
640 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
641 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
642 ROUND_RESTORE_ ## ROUNDING_MODE
643 #define RUN_TEST_f_f1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
644 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
645 EXTRA_EXPECTED) \
646 do \
647 if (enable_test (EXCEPTIONS)) \
648 { \
649 COMMON_TEST_SETUP (ARG_STR); \
650 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
651 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG), EXPECTED, \
652 EXCEPTIONS); \
653 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
654 if (EXTRA_TEST) \
655 check_int (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, 0); \
656 EXTRA_OUTPUT_TEST_CLEANUP (1); \
657 COMMON_TEST_CLEANUP; \
658 } \
659 while (0)
660 #define RUN_TEST_LOOP_f_f1(FUNC_NAME, ARRAY, ROUNDING_MODE, EXTRA_VAR) \
661 IF_ROUND_INIT_ ## ROUNDING_MODE \
662 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
663 RUN_TEST_f_f1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
664 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
665 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
666 EXTRA_VAR, \
667 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
668 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
669 ROUND_RESTORE_ ## ROUNDING_MODE
670 #define RUN_TEST_fF_f1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
671 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
672 EXTRA_EXPECTED) \
673 do \
674 if (enable_test (EXCEPTIONS)) \
675 { \
676 COMMON_TEST_SETUP (ARG_STR); \
677 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
678 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG, &(EXTRA_VAR)), \
679 EXPECTED, EXCEPTIONS); \
680 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
681 if (EXTRA_TEST) \
682 check_float (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, 0); \
683 EXTRA_OUTPUT_TEST_CLEANUP (1); \
684 COMMON_TEST_CLEANUP; \
685 } \
686 while (0)
687 #define RUN_TEST_LOOP_fF_f1(FUNC_NAME, ARRAY, ROUNDING_MODE, EXTRA_VAR) \
688 IF_ROUND_INIT_ ## ROUNDING_MODE \
689 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
690 RUN_TEST_fF_f1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
691 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
692 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
693 EXTRA_VAR, \
694 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
695 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
696 ROUND_RESTORE_ ## ROUNDING_MODE
697 #define RUN_TEST_fI_f1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
698 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
699 EXTRA_EXPECTED) \
700 do \
701 if (enable_test (EXCEPTIONS)) \
702 { \
703 COMMON_TEST_SETUP (ARG_STR); \
704 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
705 check_float (test_name, FUNC_TEST (FUNC_NAME) (ARG, &(EXTRA_VAR)), \
706 EXPECTED, EXCEPTIONS); \
707 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
708 if (EXTRA_TEST) \
709 check_int (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, 0); \
710 EXTRA_OUTPUT_TEST_CLEANUP (1); \
711 COMMON_TEST_CLEANUP; \
712 } \
713 while (0)
714 #define RUN_TEST_LOOP_fI_f1(FUNC_NAME, ARRAY, ROUNDING_MODE, EXTRA_VAR) \
715 IF_ROUND_INIT_ ## ROUNDING_MODE \
716 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
717 RUN_TEST_fI_f1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
718 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
719 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
720 EXTRA_VAR, \
721 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
722 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
723 ROUND_RESTORE_ ## ROUNDING_MODE
724 #define RUN_TEST_ffI_f1_mod8(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
725 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
726 EXTRA_EXPECTED) \
727 do \
728 if (enable_test (EXCEPTIONS)) \
729 { \
730 COMMON_TEST_SETUP (ARG_STR); \
731 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
732 check_float (test_name, \
733 FUNC_TEST (FUNC_NAME) (ARG1, ARG2, &(EXTRA_VAR)), \
734 EXPECTED, EXCEPTIONS); \
735 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
736 if (EXTRA_TEST) \
737 check_int (extra1_name, (EXTRA_VAR) % 8, EXTRA_EXPECTED, 0); \
738 EXTRA_OUTPUT_TEST_CLEANUP (1); \
739 COMMON_TEST_CLEANUP; \
740 } \
741 while (0)
742 #define RUN_TEST_LOOP_ffI_f1_mod8(FUNC_NAME, ARRAY, ROUNDING_MODE, \
743 EXTRA_VAR) \
744 IF_ROUND_INIT_ ## ROUNDING_MODE \
745 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
746 RUN_TEST_ffI_f1_mod8 ((ARRAY)[i].arg_str, FUNC_NAME, \
747 (ARRAY)[i].arg1, (ARRAY)[i].arg2, \
748 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
749 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
750 EXTRA_VAR, \
751 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
752 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
753 ROUND_RESTORE_ ## ROUNDING_MODE
754 #define RUN_TEST_Ff_b1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
755 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
756 EXTRA_EXPECTED) \
757 do \
758 if (enable_test (EXCEPTIONS)) \
759 { \
760 COMMON_TEST_SETUP (ARG_STR); \
761 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
762 /* Clear any exceptions from comparison involving sNaN \
763 EXTRA_EXPECTED. */ \
764 feclearexcept (FE_ALL_EXCEPT); \
765 check_bool (test_name, FUNC_TEST (FUNC_NAME) (&(EXTRA_VAR), \
766 (ARG)), \
767 EXPECTED, EXCEPTIONS); \
768 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
769 if (EXTRA_TEST) \
770 check_float (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, \
771 (EXCEPTIONS) & TEST_NAN_PAYLOAD); \
772 EXTRA_OUTPUT_TEST_CLEANUP (1); \
773 COMMON_TEST_CLEANUP; \
774 } \
775 while (0)
776 #define RUN_TEST_LOOP_Ff_b1(FUNC_NAME, ARRAY, ROUNDING_MODE, \
777 EXTRA_VAR) \
778 IF_ROUND_INIT_ ## ROUNDING_MODE \
779 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
780 RUN_TEST_Ff_b1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
781 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
782 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
783 EXTRA_VAR, \
784 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
785 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
786 ROUND_RESTORE_ ## ROUNDING_MODE
787 #define RUN_TEST_Ffp_b1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
788 EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \
789 EXTRA_EXPECTED) \
790 do \
791 if (enable_test (EXCEPTIONS)) \
792 { \
793 COMMON_TEST_SETUP (ARG_STR); \
794 (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \
795 check_bool (test_name, FUNC_TEST (FUNC_NAME) (&(EXTRA_VAR), \
796 &(ARG)), \
797 EXPECTED, EXCEPTIONS); \
798 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
799 if (EXTRA_TEST) \
800 check_float (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, \
801 (EXCEPTIONS) & TEST_NAN_PAYLOAD); \
802 EXTRA_OUTPUT_TEST_CLEANUP (1); \
803 COMMON_TEST_CLEANUP; \
804 } \
805 while (0)
806 #define RUN_TEST_LOOP_Ffp_b1(FUNC_NAME, ARRAY, ROUNDING_MODE, \
807 EXTRA_VAR) \
808 IF_ROUND_INIT_ ## ROUNDING_MODE \
809 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
810 RUN_TEST_Ffp_b1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
811 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
812 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
813 EXTRA_VAR, \
814 (ARRAY)[i].RM_##ROUNDING_MODE.extra_test, \
815 (ARRAY)[i].RM_##ROUNDING_MODE.extra_expected); \
816 ROUND_RESTORE_ ## ROUNDING_MODE
817 #define RUN_TEST_c_c(ARG_STR, FUNC_NAME, ARGR, ARGC, EXPR, EXPC, \
818 EXCEPTIONS) \
819 do \
820 if (enable_test (EXCEPTIONS)) \
821 { \
822 COMMON_TEST_SETUP (ARG_STR); \
823 check_complex (test_name, \
824 FUNC_TEST (FUNC_NAME) (BUILD_COMPLEX (ARGR, ARGC)), \
825 BUILD_COMPLEX (EXPR, EXPC), EXCEPTIONS); \
826 COMMON_TEST_CLEANUP; \
827 } \
828 while (0)
829 #define RUN_TEST_LOOP_c_c(FUNC_NAME, ARRAY, ROUNDING_MODE) \
830 IF_ROUND_INIT_ ## ROUNDING_MODE \
831 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
832 RUN_TEST_c_c ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].argr, \
833 (ARRAY)[i].argc, \
834 (ARRAY)[i].RM_##ROUNDING_MODE.expr, \
835 (ARRAY)[i].RM_##ROUNDING_MODE.expc, \
836 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
837 ROUND_RESTORE_ ## ROUNDING_MODE
838 #define RUN_TEST_cc_c(ARG_STR, FUNC_NAME, ARG1R, ARG1C, ARG2R, ARG2C, \
839 EXPR, EXPC, EXCEPTIONS) \
840 do \
841 if (enable_test (EXCEPTIONS)) \
842 { \
843 COMMON_TEST_SETUP (ARG_STR); \
844 check_complex (test_name, \
845 FUNC_TEST (FUNC_NAME) (BUILD_COMPLEX (ARG1R, ARG1C), \
846 BUILD_COMPLEX (ARG2R, ARG2C)), \
847 BUILD_COMPLEX (EXPR, EXPC), EXCEPTIONS); \
848 COMMON_TEST_CLEANUP; \
849 } \
850 while (0)
851 #define RUN_TEST_LOOP_cc_c(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_cc_c ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1r, \
855 (ARRAY)[i].arg1c, (ARRAY)[i].arg2r, \
856 (ARRAY)[i].arg2c, \
857 (ARRAY)[i].RM_##ROUNDING_MODE.expr, \
858 (ARRAY)[i].RM_##ROUNDING_MODE.expc, \
859 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
860 ROUND_RESTORE_ ## ROUNDING_MODE
861 #define RUN_TEST_f_i(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \
862 do \
863 if (enable_test (EXCEPTIONS)) \
864 { \
865 COMMON_TEST_SETUP (ARG_STR); \
866 check_int (test_name, FUNC_TEST (FUNC_NAME) (ARG), EXPECTED, \
867 EXCEPTIONS); \
868 COMMON_TEST_CLEANUP; \
869 } \
870 while (0)
871 #define RUN_TEST_LOOP_f_i(FUNC_NAME, ARRAY, ROUNDING_MODE) \
872 IF_ROUND_INIT_ ## ROUNDING_MODE \
873 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
874 RUN_TEST_f_i ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
875 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
876 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
877 ROUND_RESTORE_ ## ROUNDING_MODE
878 #define RUN_TEST_f_i_tg(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
879 EXCEPTIONS) \
880 do \
881 if (enable_test (EXCEPTIONS)) \
882 { \
883 COMMON_TEST_SETUP (ARG_STR); \
884 check_int (test_name, FUNC_NAME (ARG), EXPECTED, EXCEPTIONS); \
885 COMMON_TEST_CLEANUP; \
886 } \
887 while (0)
888 #define RUN_TEST_LOOP_f_i_tg(FUNC_NAME, ARRAY, ROUNDING_MODE) \
889 IF_ROUND_INIT_ ## ROUNDING_MODE \
890 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
891 RUN_TEST_f_i_tg ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
892 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
893 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
894 ROUND_RESTORE_ ## ROUNDING_MODE
895 #define RUN_TEST_LOOP_j_b_tg_u(FUNC_NAME, ARRAY, ROUNDING_MODE) \
896 IF_ROUND_INIT_ ## ROUNDING_MODE \
897 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
898 RUN_TEST_f_b_tg ((ARRAY)[i].arg_str, FUNC_NAME, \
899 (FLOAT)(ARRAY)[i].arg.value, \
900 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
901 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
902 ROUND_RESTORE_ ## ROUNDING_MODE
903 #define RUN_TEST_LOOP_j_i_tg_u(FUNC_NAME, ARRAY, ROUNDING_MODE) \
904 IF_ROUND_INIT_ ## ROUNDING_MODE \
905 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
906 RUN_TEST_f_i_tg ((ARRAY)[i].arg_str, FUNC_NAME, \
907 (FLOAT)(ARRAY)[i].arg.value, \
908 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
909 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
910 ROUND_RESTORE_ ## ROUNDING_MODE
911 #define RUN_TEST_ff_b(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
912 EXCEPTIONS) \
913 do \
914 if (enable_test (EXCEPTIONS)) \
915 { \
916 COMMON_TEST_SETUP (ARG_STR); \
917 check_bool (test_name, FUNC_TEST (FUNC_NAME) (ARG1, ARG2), \
918 EXPECTED, EXCEPTIONS); \
919 COMMON_TEST_CLEANUP; \
920 } \
921 while (0)
922 #define RUN_TEST_LOOP_ff_b(FUNC_NAME, ARRAY, ROUNDING_MODE) \
923 IF_ROUND_INIT_ ## ROUNDING_MODE \
924 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
925 RUN_TEST_ff_b ((ARRAY)[i].arg_str, FUNC_NAME, \
926 (ARRAY)[i].arg1, (ARRAY)[i].arg2, \
927 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
928 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
929 ROUND_RESTORE_ ## ROUNDING_MODE
930 #define RUN_TEST_fpfp_b(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
931 EXCEPTIONS) \
932 do \
933 if (enable_test (EXCEPTIONS)) \
934 { \
935 COMMON_TEST_SETUP (ARG_STR); \
936 check_bool (test_name, \
937 FUNC_TEST (FUNC_NAME) (&(ARG1), &(ARG2)), \
938 EXPECTED, EXCEPTIONS); \
939 COMMON_TEST_CLEANUP; \
940 } \
941 while (0)
942 #define RUN_TEST_LOOP_fpfp_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_fpfp_b ((ARRAY)[i].arg_str, FUNC_NAME, \
946 (ARRAY)[i].arg1, (ARRAY)[i].arg2, \
947 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
948 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
949 ROUND_RESTORE_ ## ROUNDING_MODE
950 #define RUN_TEST_ff_i_tg(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \
951 EXCEPTIONS) \
952 do \
953 if (enable_test (EXCEPTIONS)) \
954 { \
955 COMMON_TEST_SETUP (ARG_STR); \
956 check_int (test_name, FUNC_NAME (ARG1, ARG2), EXPECTED, \
957 EXCEPTIONS); \
958 COMMON_TEST_CLEANUP; \
959 } \
960 while (0)
961 #define RUN_TEST_LOOP_ff_i_tg(FUNC_NAME, ARRAY, ROUNDING_MODE) \
962 IF_ROUND_INIT_ ## ROUNDING_MODE \
963 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
964 RUN_TEST_ff_i_tg ((ARRAY)[i].arg_str, FUNC_NAME, \
965 (ARRAY)[i].arg1, (ARRAY)[i].arg2, \
966 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
967 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
968 ROUND_RESTORE_ ## ROUNDING_MODE
969 #define RUN_TEST_f_b(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \
970 do \
971 if (enable_test (EXCEPTIONS)) \
972 { \
973 COMMON_TEST_SETUP (ARG_STR); \
974 check_bool (test_name, FUNC_TEST (FUNC_NAME) (ARG), EXPECTED, \
975 EXCEPTIONS); \
976 COMMON_TEST_CLEANUP; \
977 } \
978 while (0)
979 #define RUN_TEST_LOOP_f_b(FUNC_NAME, ARRAY, ROUNDING_MODE) \
980 IF_ROUND_INIT_ ## ROUNDING_MODE \
981 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
982 RUN_TEST_f_b ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
983 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
984 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
985 ROUND_RESTORE_ ## ROUNDING_MODE
986 #define RUN_TEST_f_b_tg(ARG_STR, FUNC_NAME, ARG, EXPECTED, \
987 EXCEPTIONS) \
988 do \
989 if (enable_test (EXCEPTIONS)) \
990 { \
991 COMMON_TEST_SETUP (ARG_STR); \
992 check_bool (test_name, FUNC_NAME (ARG), EXPECTED, EXCEPTIONS); \
993 COMMON_TEST_CLEANUP; \
994 } \
995 while (0)
996 #define RUN_TEST_LOOP_f_b_tg(FUNC_NAME, ARRAY, ROUNDING_MODE) \
997 IF_ROUND_INIT_ ## ROUNDING_MODE \
998 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
999 RUN_TEST_f_b_tg ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
1000 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
1001 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
1002 ROUND_RESTORE_ ## ROUNDING_MODE
1003 #define RUN_TEST_f_l(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \
1004 do \
1005 if (enable_test (EXCEPTIONS)) \
1006 { \
1007 COMMON_TEST_SETUP (ARG_STR); \
1008 check_long (test_name, FUNC_TEST (FUNC_NAME) (ARG), EXPECTED, \
1009 EXCEPTIONS); \
1010 COMMON_TEST_CLEANUP; \
1011 } \
1012 while (0)
1013 #define RUN_TEST_LOOP_f_l(FUNC_NAME, ARRAY, ROUNDING_MODE) \
1014 IF_ROUND_INIT_ ## ROUNDING_MODE \
1015 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
1016 RUN_TEST_f_l ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
1017 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
1018 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
1019 ROUND_RESTORE_ ## ROUNDING_MODE
1020 #define RUN_TEST_f_L(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \
1021 do \
1022 if (enable_test (EXCEPTIONS)) \
1023 { \
1024 COMMON_TEST_SETUP (ARG_STR); \
1025 check_longlong (test_name, FUNC_TEST (FUNC_NAME) (ARG), \
1026 EXPECTED, EXCEPTIONS); \
1027 COMMON_TEST_CLEANUP; \
1028 } \
1029 while (0)
1030 #define RUN_TEST_LOOP_f_L(FUNC_NAME, ARRAY, ROUNDING_MODE) \
1031 IF_ROUND_INIT_ ## ROUNDING_MODE \
1032 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
1033 RUN_TEST_f_L ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
1034 (ARRAY)[i].RM_##ROUNDING_MODE.expected, \
1035 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions); \
1036 ROUND_RESTORE_ ## ROUNDING_MODE
1037 #define RUN_TEST_fFF_11(ARG_STR, FUNC_NAME, ARG, EXCEPTIONS, \
1038 EXTRA1_VAR, EXTRA1_TEST, \
1039 EXTRA1_EXPECTED, EXTRA2_VAR, \
1040 EXTRA2_TEST, EXTRA2_EXPECTED) \
1041 do \
1042 if (enable_test (EXCEPTIONS)) \
1043 { \
1044 COMMON_TEST_SETUP (ARG_STR); \
1045 FUNC_TEST (FUNC_NAME) (ARG, &(EXTRA1_VAR), &(EXTRA2_VAR)); \
1046 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \
1047 if (EXTRA1_TEST) \
1048 check_float (extra1_name, EXTRA1_VAR, EXTRA1_EXPECTED, \
1049 EXCEPTIONS); \
1050 EXTRA_OUTPUT_TEST_CLEANUP (1); \
1051 EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 2); \
1052 if (EXTRA2_TEST) \
1053 check_float (extra2_name, EXTRA2_VAR, EXTRA2_EXPECTED, 0); \
1054 EXTRA_OUTPUT_TEST_CLEANUP (2); \
1055 COMMON_TEST_CLEANUP; \
1056 } \
1057 while (0)
1058 #define RUN_TEST_LOOP_fFF_11(FUNC_NAME, ARRAY, ROUNDING_MODE, \
1059 EXTRA1_VAR, EXTRA2_VAR) \
1060 IF_ROUND_INIT_ ## ROUNDING_MODE \
1061 for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \
1062 RUN_TEST_fFF_11 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \
1063 (ARRAY)[i].RM_##ROUNDING_MODE.exceptions, \
1064 EXTRA1_VAR, \
1065 (ARRAY)[i].RM_##ROUNDING_MODE.extra1_test, \
1066 (ARRAY)[i].RM_##ROUNDING_MODE.extra1_expected, \
1067 EXTRA2_VAR, \
1068 (ARRAY)[i].RM_##ROUNDING_MODE.extra2_test, \
1069 (ARRAY)[i].RM_##ROUNDING_MODE.extra2_expected); \
1070 ROUND_RESTORE_ ## ROUNDING_MODE
1071
1072 #if TEST_MATHVEC
1073 # define TEST_SUFF VEC_SUFF
1074 # define TEST_SUFF_STR
1075 #elif TEST_NARROW
1076 # define TEST_SUFF
1077 # define TEST_SUFF_STR "_" ARG_TYPE_STR
1078 #else
1079 # define TEST_SUFF
1080 # define TEST_SUFF_STR
1081 #endif
1082
1083 #define STR_CONCAT(a, b, c) __STRING (a##b##c)
1084 #define STR_CON3(a, b, c) STR_CONCAT (a, b, c)
1085
1086 #if TEST_NARROW
1087 # define TEST_COND_any_ibm128 (TEST_COND_ibm128 || TEST_COND_arg_ibm128)
1088 #else
1089 # define TEST_COND_any_ibm128 TEST_COND_ibm128
1090 #endif
1091
1092 /* Start and end the tests for a given function. */
1093 #define START(FUN, SUFF, EXACT) \
1094 CHECK_ARCH_EXT; \
1095 const char *this_func \
1096 = STR_CON3 (FUN, SUFF, TEST_SUFF) TEST_SUFF_STR; \
1097 init_max_error (this_func, EXACT, TEST_COND_any_ibm128)
1098 #define END \
1099 check_max_error (this_func)
1100 #define END_COMPLEX \
1101 check_complex_max_error (this_func)
1102
1103 /* Run tests for a given function in all rounding modes. */
1104 #define ALL_RM_TEST(FUNC, EXACT, ARRAY, LOOP_MACRO, END_MACRO, ...) \
1105 do \
1106 { \
1107 do \
1108 { \
1109 START (FUNC,, EXACT); \
1110 LOOP_MACRO (FUNC, ARRAY, , ## __VA_ARGS__); \
1111 END_MACRO; \
1112 } \
1113 while (0); \
1114 do \
1115 { \
1116 START (FUNC, _downward, EXACT); \
1117 LOOP_MACRO (FUNC, ARRAY, FE_DOWNWARD, ## __VA_ARGS__); \
1118 END_MACRO; \
1119 } \
1120 while (0); \
1121 do \
1122 { \
1123 START (FUNC, _towardzero, EXACT); \
1124 LOOP_MACRO (FUNC, ARRAY, FE_TOWARDZERO, ## __VA_ARGS__); \
1125 END_MACRO; \
1126 } \
1127 while (0); \
1128 do \
1129 { \
1130 START (FUNC, _upward, EXACT); \
1131 LOOP_MACRO (FUNC, ARRAY, FE_UPWARD, ## __VA_ARGS__); \
1132 END_MACRO; \
1133 } \
1134 while (0); \
1135 } \
1136 while (0);
1137
1138 /* Short description of program. */
1139 const char doc[] = "Math test suite: " TEST_MSG ;
1140
1141 static void do_test (void);
1142
1143 int
1144 main (int argc, char **argv)
1145 {
1146 libm_test_init (argc, argv);
1147 INIT_ARCH_EXT;
1148 do_test ();
1149 return libm_test_finish ();
1150 }
A mirror of the official glibc repository