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