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