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