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