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