Repository navigation
Expand file tree
/
Copy pathtest.h
More file actions
826 lines (742 loc) · 34.1 KB
/
Copy pathtest.h
File metadata and controls
826 lines (742 loc) · 34.1 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
#if !defined(SIMDE_TESTS_H)
#define SIMDE_TESTS_H
#define SIMDE_NO_CHECK_IMMEDIATE_CONSTANT
#include "../simde/simde-common.h"
#include <time.h>
#include <stdlib.h>
#include <math.h>
#include <inttypes.h>
#include <stdarg.h>
typedef enum SimdeTestVecPos {
SIMDE_TEST_VEC_POS_SINGLE = 2,
SIMDE_TEST_VEC_POS_FIRST = 1,
SIMDE_TEST_VEC_POS_MIDDLE = 0,
SIMDE_TEST_VEC_POS_LAST = -1
} SimdeTestVecPos;
HEDLEY_DIAGNOSTIC_PUSH
SIMDE_DIAGNOSTIC_DISABLE_VLA_
HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION
SIMDE_DIAGNOSTIC_DISABLE_PADDED_
SIMDE_DIAGNOSTIC_DISABLE_ZERO_AS_NULL_POINTER_CONSTANT_
SIMDE_DIAGNOSTIC_DISABLE_CAST_FUNCTION_TYPE_
SIMDE_DIAGNOSTIC_DISABLE_NON_CONSTANT_AGGREGATE_INITIALIZER_
SIMDE_DIAGNOSTIC_DISABLE_C99_EXTENSIONS_
SIMDE_DIAGNOSTIC_DISABLE_NO_EMMS_INSTRUCTION_
SIMDE_DIAGNOSTIC_DISABLE_CPP98_COMPAT_PEDANTIC_
SIMDE_DIAGNOSTIC_DISABLE_ANNEX_K_
SIMDE_DIAGNOSTIC_DISABLE_DISABLED_MACRO_EXPANSION_
#if \
HEDLEY_HAS_BUILTIN(__builtin_abort) || \
HEDLEY_GCC_VERSION_CHECK(3,4,6) || \
HEDLEY_ARM_VERSION_CHECK(4,1,0)
#define simde_abort() __builtin_abort()
#elif defined(SIMDE_HAVE_STDLIB_H)
#define simde_abort() abort()
#endif
#define SIMDE_TEST_ASSERT_CONTINUE 0
#define SIMDE_TEST_ASSERT_TRAP 1
#define SIMDE_TEST_ASSERT_ABORT 2
#if !defined(SIMDE_TEST_ASSERT_FAILURE)
#if defined(SIMDE_TEST_BARE)
#define SIMDE_TEST_ASSERT_FAILURE SIMDE_TEST_ASSERT_CONTINUE
#else
#define SIMDE_TEST_ASSERT_FAILURE SIMDE_TEST_ASSERT_ABORT
#endif
#endif
#if !defined(SIMDE_TEST_ASSERT_ABORT) && !defined(SIMDE_TEST_ASSERT_CONTINUE) && !defined(SIMDE_TEST_ASSERT_TRAP)
#if defined(SIMDE_TEST_BARE)
#define SIMDE_TEST_ASSERT_CONTINUE
#else
#define SIMDE_TEST_ASSERT_ABORT
#endif
#endif
#if SIMDE_TEST_ASSERT_FAILURE == SIMDE_TEST_ASSERT_ABORT
#define SIMDE_TEST_ASSERT_RETURN(value) ((void) 0)
#else
#define SIMDE_TEST_ASSERT_RETURN(value) return value
#endif
#if defined(SIMDE_TEST_BARE)
#define SIMDE_CODEGEN_FP stderr
#else
#define SIMDE_CODEGEN_FP stdout
#endif
#if SIMDE_TEST_ASSERT_FAILURE == 2
HEDLEY_NO_RETURN
#endif
HEDLEY_PRINTF_FORMAT(1, 2)
static void
simde_test_debug_printf_(const char* format, ...) {
va_list ap;
va_start(ap, format);
vfprintf(stderr, format, ap);
va_end(ap);
fflush(stderr);
/* Debug trap is great for local development where you can attach a
* debugger, but processes exiting with a SIGTRAP seem to be rather
* confusing for CI. */
#if SIMDE_TEST_ASSERT_FAILURE == 1
simde_trap();
#elif SIMDE_TEST_ASSERT_FAILURE == 2
simde_abort();
#endif
}
#if !defined(SIMDE_TEST_STRUCT_MODIFIERS)
#define SIMDE_TEST_STRUCT_MODIFIERS static const
#endif
HEDLEY_PRINTF_FORMAT(3, 4)
static void
simde_test_codegen_snprintf_(char* str, size_t size, const char* format, ...) {
va_list ap;
int w;
va_start(ap, format);
w = vsnprintf(str, size, format, ap);
va_end(ap);
if (w > HEDLEY_STATIC_CAST(int, size)) {
simde_test_debug_printf_("Not enough space to write value (given %zu bytes, need %d bytes)\n", size, w + 1);
}
}
static void
simde_test_codegen_f32(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], simde_float32 value) {
if (simde_math_isnan(value)) {
simde_test_codegen_snprintf_(buf, buf_len, " SIMDE_MATH_NANF");
} else if (simde_math_isinf(value)) {
simde_test_codegen_snprintf_(buf, buf_len, "%5cSIMDE_MATH_INFINITYF", value < 0 ? '-' : ' ');
} else {
simde_test_codegen_snprintf_(buf, buf_len, "SIMDE_FLOAT32_C(%9.2f)", HEDLEY_STATIC_CAST(double, value));
}
}
static void
simde_test_codegen_f64(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], simde_float64 value) {
if (simde_math_isnan(value)) {
simde_test_codegen_snprintf_(buf, buf_len, " SIMDE_MATH_NAN");
} else if (simde_math_isinf(value)) {
simde_test_codegen_snprintf_(buf, buf_len, "%7cSIMDE_MATH_INFINITY", value < 0 ? '-' : ' ');
} else {
simde_test_codegen_snprintf_(buf, buf_len, "SIMDE_FLOAT64_C(%9.2f)", HEDLEY_STATIC_CAST(double, value));
}
}
static void
simde_test_codegen_i8(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], int8_t value) {
if (value == INT8_MIN) {
simde_test_codegen_snprintf_(buf, buf_len, " INT8_MIN");
} else if (value == INT8_MAX) {
simde_test_codegen_snprintf_(buf, buf_len, " INT8_MAX");
} else {
simde_test_codegen_snprintf_(buf, buf_len, "%cINT8_C(%4" PRId8 ")", (value < 0) ? '-' : ' ', HEDLEY_STATIC_CAST(int8_t, (value < 0) ? -value : value));
}
}
static void
simde_test_codegen_i16(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], int16_t value) {
if (value == INT16_MIN) {
simde_test_codegen_snprintf_(buf, buf_len, "%15s", "INT16_MIN");
} else if (value == INT16_MAX) {
simde_test_codegen_snprintf_(buf, buf_len, "%15s", "INT16_MAX");
} else {
simde_test_codegen_snprintf_(buf, buf_len, "%cINT16_C(%6" PRId16 ")", (value < 0) ? '-' : ' ', HEDLEY_STATIC_CAST(int16_t, (value < 0) ? -value : value));
}
}
static void
simde_test_codegen_i32(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], int32_t value) {
if (value == INT32_MIN) {
simde_test_codegen_snprintf_(buf, buf_len, "%20s", "INT32_MIN");
} else if (value == INT32_MAX) {
simde_test_codegen_snprintf_(buf, buf_len, "%20s", "INT32_MAX");
} else {
simde_test_codegen_snprintf_(buf, buf_len, "%cINT32_C(%12" PRId32 ")", (value < 0) ? '-' : ' ', HEDLEY_STATIC_CAST(int32_t, (value < 0) ? -value : value));
}
}
static void
simde_test_codegen_i64(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], int64_t value) {
if (value == INT64_MIN) {
simde_test_codegen_snprintf_(buf, buf_len, "%29s", "INT64_MIN");
} else if (value == INT64_MAX) {
simde_test_codegen_snprintf_(buf, buf_len, "%29s", "INT64_MAX");
} else {
simde_test_codegen_snprintf_(buf, buf_len, "%cINT64_C(%20" PRId64 ")", (value < 0) ? '-' : ' ', HEDLEY_STATIC_CAST(int64_t, (value < 0) ? -value : value));
}
}
static void
simde_test_codegen_u8(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], uint8_t value) {
if (value == UINT8_MAX) {
simde_test_codegen_snprintf_(buf, buf_len, " UINT8_MAX");
} else {
simde_test_codegen_snprintf_(buf, buf_len, "UINT8_C(%3" PRIu8 ")", value);
}
}
static void
simde_test_codegen_u16(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], uint16_t value) {
if (value == UINT16_MAX) {
simde_test_codegen_snprintf_(buf, buf_len, "%15s", "UINT16_MAX");
} else {
simde_test_codegen_snprintf_(buf, buf_len, "UINT16_C(%5" PRIu16 ")", value);
}
}
static void
simde_test_codegen_u32(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], uint32_t value) {
if (value == UINT32_MAX) {
simde_test_codegen_snprintf_(buf, buf_len, "%20s", "UINT32_MAX");
} else {
simde_test_codegen_snprintf_(buf, buf_len, "UINT32_C(%10" PRIu32 ")", value);
}
}
static void
simde_test_codegen_u64(size_t buf_len, char buf[HEDLEY_ARRAY_PARAM(buf_len)], uint64_t value) {
if (value == UINT64_MAX) {
simde_test_codegen_snprintf_(buf, buf_len, "%29s", "UINT64_MAX");
} else {
simde_test_codegen_snprintf_(buf, buf_len, "UINT64_C(%20" PRIu64 ")", value);
}
}
static void
simde_test_codegen_write_indent(int indent) {
for (int i = 0 ; i < indent ; i++) {
fputs(" ", SIMDE_CODEGEN_FP);
}
}
static int simde_test_codegen_rand(void) {
/* Single-threaded programs are so nice */
static int is_init = 0;
if (HEDLEY_UNLIKELY(!is_init)) {
#if !defined(HEDLEY_EMSCRIPTEN_VERSION)
FILE* fp = fopen("/dev/urandom", "r");
if (fp == NULL)
fp = fopen("/dev/random", "r");
if (fp != NULL) {
unsigned int seed;
size_t nread = fread(&seed, sizeof(seed), 1, fp);
fclose(fp);
if (nread == 1) {
srand(seed);
is_init = 1;
}
}
#endif
if (!is_init) {
srand(HEDLEY_STATIC_CAST(unsigned int, time(NULL)));
is_init = 1;
}
}
return rand();
}
static void
simde_test_codegen_random_memory(size_t buf_len, uint8_t buf[HEDLEY_ARRAY_PARAM(buf_len)]) {
for (size_t i = 0 ; i < buf_len ; i++) {
buf[i] = HEDLEY_STATIC_CAST(uint8_t, simde_test_codegen_rand() & 0xff);
}
}
static simde_float32
simde_test_codegen_random_f32(simde_float32 min, simde_float32 max) {
simde_float32 v = (HEDLEY_STATIC_CAST(simde_float32, simde_test_codegen_rand()) / (HEDLEY_STATIC_CAST(simde_float32, RAND_MAX) / (max - min))) + min;
return simde_math_roundf(v * SIMDE_FLOAT32_C(100.0)) / SIMDE_FLOAT32_C(100.0);
}
static simde_float64
simde_test_codegen_random_f64(simde_float64 min, simde_float64 max) {
simde_float64 v = (HEDLEY_STATIC_CAST(simde_float64, simde_test_codegen_rand()) / (HEDLEY_STATIC_CAST(simde_float64, RAND_MAX) / (max - min))) + min;
return simde_math_round(v * SIMDE_FLOAT64_C(100.0)) / SIMDE_FLOAT64_C(100.0);
}
typedef enum SimdeTestVecFloatMask {
SIMDE_TEST_VEC_FLOAT_DEFAULT = 0,
SIMDE_TEST_VEC_FLOAT_PAIR = 1,
SIMDE_TEST_VEC_FLOAT_NAN = 2,
SIMDE_TEST_VEC_FLOAT_EQUAL = 4,
SIMDE_TEST_VEC_FLOAT_ROUND = 8
}
#if \
(HEDLEY_HAS_ATTRIBUTE(flag_enum) && !defined(HEDLEY_IBM_VERSION)) && \
(!defined(__cplusplus) || SIMDE_DETECT_CLANG_VERSION_CHECK(5,0,0))
__attribute__((__flag_enum__))
#endif
SimdeTestVecFloatType;
/* This is a bit messy, sorry. And I haven't really tested with
* anything greater than 4-element vectors, there is no input
* validation, etc. I'm not going to lose any sleep since it's
* just a test harness, but you probably shouldn't use this API
* directly since there is a good chance it will change. */
static void
simde_test_codegen_calc_pair(int pairwise, size_t test_sets, size_t vectors_per_set, size_t elements_per_vector, size_t pos, size_t* a, size_t* b) {
(void) test_sets; // <- for validating ranges
if (pairwise) {
*a = (((pos * 2) + 0) % elements_per_vector) + ((((pos * 2) + 0) / elements_per_vector) * elements_per_vector);
*b = (((pos * 2) + 1) % elements_per_vector) + ((((pos * 2) + 1) / elements_per_vector) * elements_per_vector);
} else {
size_t elements_per_set = elements_per_vector * vectors_per_set;
size_t set_num = pos / elements_per_vector;
size_t pos_in_set = pos % elements_per_vector;
*a = (elements_per_set * set_num) + pos_in_set;
*b = *a + elements_per_vector;
}
}
static void
simde_test_codegen_float_set_value_(size_t element_size, size_t pos, void* values, simde_float32 f32_val, simde_float64 f64_val) {
switch (element_size) {
case sizeof(simde_float32):
HEDLEY_REINTERPRET_CAST(simde_float32*, values)[pos] = f32_val;
break;
case sizeof(simde_float64):
HEDLEY_REINTERPRET_CAST(simde_float64*, values)[pos] = f64_val;
break;
}
}
static void
simde_test_codegen_random_vfX_full_(
size_t test_sets, size_t vectors_per_set, size_t elements_per_vector,
size_t elem_size, void* values,
simde_float64 min, simde_float64 max,
SimdeTestVecFloatType vec_type) {
for (size_t i = 0 ; i < (test_sets * vectors_per_set * elements_per_vector) ; i++) {
simde_float64 v = simde_test_codegen_random_f64(min, max);
if (vec_type & SIMDE_TEST_VEC_FLOAT_ROUND) {
if (simde_test_codegen_rand() & 7) {
do {
v = HEDLEY_STATIC_CAST(simde_float64, HEDLEY_STATIC_CAST(int64_t, v));
if (simde_test_codegen_rand() & 7)
v += 0.5;
} while (v > max || v < min);
}
}
simde_test_codegen_float_set_value_(elem_size, i, values, HEDLEY_STATIC_CAST(simde_float32, v), v);
}
int pairwise = !!(vec_type & SIMDE_TEST_VEC_FLOAT_PAIR);
size_t pos = 0;
size_t a, b;
if (vec_type & SIMDE_TEST_VEC_FLOAT_NAN) {
simde_test_codegen_calc_pair(pairwise, test_sets, vectors_per_set, elements_per_vector, pos++, &a, &b);
simde_test_codegen_float_set_value_(elem_size, a, values, SIMDE_MATH_NANF, SIMDE_MATH_NAN);
simde_test_codegen_calc_pair(pairwise, test_sets, vectors_per_set, elements_per_vector, pos++, &a, &b);
simde_test_codegen_float_set_value_(elem_size, b, values, SIMDE_MATH_NANF, SIMDE_MATH_NAN);
simde_test_codegen_calc_pair(pairwise, test_sets, vectors_per_set, elements_per_vector, pos++, &a, &b);
simde_test_codegen_float_set_value_(elem_size, a, values, SIMDE_MATH_NANF, SIMDE_MATH_NAN);
simde_test_codegen_float_set_value_(elem_size, b, values, SIMDE_MATH_NANF, SIMDE_MATH_NAN);
}
if (vec_type & SIMDE_TEST_VEC_FLOAT_EQUAL) {
simde_test_codegen_calc_pair(pairwise, test_sets, vectors_per_set, elements_per_vector, pos++, &a, &b);
simde_float64 v = simde_test_codegen_random_f64(min, max);
simde_test_codegen_float_set_value_(elem_size, a, values, HEDLEY_STATIC_CAST(simde_float32, v), v);
simde_test_codegen_float_set_value_(elem_size, b, values, HEDLEY_STATIC_CAST(simde_float32, v), v);
}
}
static void
simde_test_codegen_random_vf32_full(
size_t test_sets, size_t vectors_per_set, size_t elements_per_vector,
simde_float32 values[HEDLEY_ARRAY_PARAM(test_sets * vectors_per_set * elements_per_vector)],
simde_float32 min, simde_float32 max,
SimdeTestVecFloatType vec_type) {
simde_test_codegen_random_vfX_full_(test_sets, vectors_per_set, elements_per_vector,
sizeof(simde_float32), values,
HEDLEY_STATIC_CAST(simde_float64, min), HEDLEY_STATIC_CAST(simde_float64, max),
vec_type);
}
static void
simde_test_codegen_random_vf64_full(
size_t test_sets, size_t vectors_per_set, size_t elements_per_vector,
simde_float64 values[HEDLEY_ARRAY_PARAM(test_sets * vectors_per_set * elements_per_vector)],
simde_float64 min, simde_float64 max,
SimdeTestVecFloatType vec_type) {
simde_test_codegen_random_vfX_full_(test_sets, vectors_per_set, elements_per_vector,
sizeof(simde_float64), values,
min, max,
vec_type);
}
static void
simde_test_codegen_random_vf32(size_t elem_count, simde_float32 values[HEDLEY_ARRAY_PARAM(elem_count)], simde_float32 min, simde_float32 max) {
for (size_t i = 0 ; i < elem_count ; i++) {
values[i] = simde_test_codegen_random_f32(min, max);
}
}
static void
simde_test_codegen_random_vf64(size_t elem_count, simde_float64 values[HEDLEY_ARRAY_PARAM(elem_count)], simde_float64 min, simde_float64 max) {
for (size_t i = 0 ; i < elem_count ; i++) {
values[i] = simde_test_codegen_random_f64(min, max);
}
}
#define SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(T, symbol_identifier) \
static T simde_test_codegen_random_##symbol_identifier(void) { \
T r; \
simde_test_codegen_random_memory(sizeof(r), HEDLEY_REINTERPRET_CAST(uint8_t*, &r)); \
return r; \
}
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(int8_t, i8)
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(int16_t, i16)
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(int32_t, i32)
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(int64_t, i64)
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(uint8_t, u8)
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(uint16_t, u16)
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(uint32_t, u32)
SIMDE_TEST_CODEGEN_GENERATE_RANDOM_INT_FUNC_(uint64_t, u64)
#define SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(T, symbol_identifier, elements_per_line) \
static void \
simde_test_codegen_write_v##symbol_identifier(int indent, size_t elem_count, T values[HEDLEY_ARRAY_PARAM(elem_count)], SimdeTestVecPos pos) { \
switch (pos) { \
case SIMDE_TEST_VEC_POS_FIRST: \
simde_test_codegen_write_indent(indent); \
indent++; \
fputs("{ ", SIMDE_CODEGEN_FP); \
break; \
case SIMDE_TEST_VEC_POS_MIDDLE: \
case SIMDE_TEST_VEC_POS_LAST: \
indent++; \
simde_test_codegen_write_indent(indent); \
break; \
case SIMDE_TEST_VEC_POS_SINGLE: \
simde_test_codegen_write_indent(indent++); \
fputs("static const " #T " name[] = \n", SIMDE_CODEGEN_FP); \
simde_test_codegen_write_indent(indent); \
break; \
} \
\
fputs("{ ", SIMDE_CODEGEN_FP); \
for (size_t i = 0 ; i < elem_count ; i++) { \
if (i != 0) { \
fputc(',', SIMDE_CODEGEN_FP); \
if ((i % elements_per_line) == 0) { \
fputc('\n', SIMDE_CODEGEN_FP); \
simde_test_codegen_write_indent(indent + 1); \
} else { \
fputc(' ', SIMDE_CODEGEN_FP); \
} \
} \
\
char buf[53]; \
simde_test_codegen_##symbol_identifier(sizeof(buf), buf, values[i]); \
fputs(buf, SIMDE_CODEGEN_FP); \
} \
fputs(" }", SIMDE_CODEGEN_FP); \
\
switch (pos) { \
case SIMDE_TEST_VEC_POS_FIRST: \
case SIMDE_TEST_VEC_POS_MIDDLE: \
fputc(',', SIMDE_CODEGEN_FP); \
break; \
case SIMDE_TEST_VEC_POS_LAST: \
fputs(" },", SIMDE_CODEGEN_FP); \
break; \
case SIMDE_TEST_VEC_POS_SINGLE: \
fputs(";", SIMDE_CODEGEN_FP); \
break; \
} \
\
fputc('\n', SIMDE_CODEGEN_FP); \
}
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(simde_float32, f32, 4)
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(simde_float64, f64, 4)
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(int8_t, i8, 8)
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(int16_t, i16, 8)
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(int32_t, i32, 8)
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(int64_t, i64, 4)
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(uint8_t, u8, 8)
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(uint16_t, u16, 8)
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(uint32_t, u32, 8)
SIMDE_TEST_CODEGEN_GENERATE_WRITE_VECTOR_FUNC_(uint64_t, u64, 4)
#define SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(T, symbol_identifier) \
static void \
simde_test_codegen_write_##symbol_identifier(int indent, T value, SimdeTestVecPos pos) { \
switch (pos) { \
case SIMDE_TEST_VEC_POS_FIRST: \
simde_test_codegen_write_indent(indent); \
indent++; \
fputs("{ ", SIMDE_CODEGEN_FP); \
break; \
case SIMDE_TEST_VEC_POS_MIDDLE: \
case SIMDE_TEST_VEC_POS_LAST: \
indent++; \
simde_test_codegen_write_indent(indent); \
break; \
case SIMDE_TEST_VEC_POS_SINGLE: \
simde_test_codegen_write_indent(indent++); \
fputs("Hello", SIMDE_CODEGEN_FP); \
break; \
} \
\
{ \
char buf[53]; \
simde_test_codegen_##symbol_identifier(sizeof(buf), buf, value); \
fputs(buf, SIMDE_CODEGEN_FP); \
} \
\
switch (pos) { \
case SIMDE_TEST_VEC_POS_FIRST: \
case SIMDE_TEST_VEC_POS_MIDDLE: \
fputc(',', SIMDE_CODEGEN_FP); \
break; \
case SIMDE_TEST_VEC_POS_LAST: \
fputs(" },", SIMDE_CODEGEN_FP); \
break; \
case SIMDE_TEST_VEC_POS_SINGLE: \
break; \
} \
\
fputc('\n', SIMDE_CODEGEN_FP); \
}
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(int8_t, i8)
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(int16_t, i16)
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(int32_t, i32)
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(int64_t, i64)
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(uint8_t, u8)
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(uint16_t, u16)
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(uint32_t, u32)
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(uint64_t, u64)
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(simde_float32, f32)
SIMDE_TEST_CODEGEN_WRITE_SCALAR_FUNC_(simde_float64, f64)
HEDLEY_DIAGNOSTIC_PUSH
SIMDE_DIAGNOSTIC_DISABLE_FLOAT_EQUAL_
static int
simde_test_equal_f32(simde_float32 a, simde_float32 b, simde_float32 slop) {
if (simde_math_isnan(a)) {
return simde_math_isnan(b);
} else if (simde_math_isinf(a)) {
return !((a < b) || (a > b));
} else if (slop == SIMDE_FLOAT32_C(0.0)) {
return a == b;
} else {
simde_float32 lo = a - slop;
if (HEDLEY_UNLIKELY(lo == a))
lo = simde_math_nextafterf(a, -SIMDE_MATH_INFINITYF);
simde_float32 hi = a + slop;
if (HEDLEY_UNLIKELY(hi == a))
hi = simde_math_nextafterf(a, SIMDE_MATH_INFINITYF);
return ((b >= lo) && (b <= hi));
}
}
static int
simde_test_equal_f64(simde_float64 a, simde_float64 b, simde_float64 slop) {
if (simde_math_isnan(a)) {
return simde_math_isnan(b);
} else if (simde_math_isinf(a)) {
return !((a < b) || (a > b));
} else if (slop == SIMDE_FLOAT64_C(0.0)) {
return a == b;
} else {
simde_float64 lo = a - slop;
if (HEDLEY_UNLIKELY(lo == a))
lo = simde_math_nextafter(a, -SIMDE_MATH_INFINITY);
simde_float64 hi = a + slop;
if (HEDLEY_UNLIKELY(hi == a))
hi = simde_math_nextafter(a, SIMDE_MATH_INFINITY);
return ((b >= lo) && (b <= hi));
}
}
HEDLEY_DIAGNOSTIC_POP
static float
simde_test_f32_precision_to_slop(int precision) {
return HEDLEY_UNLIKELY(precision == INT_MAX) ? SIMDE_FLOAT32_C(0.0) : simde_math_powf(SIMDE_FLOAT32_C(10.0), -HEDLEY_STATIC_CAST(float, precision));
}
static double
simde_test_f64_precision_to_slop(int precision) {
return HEDLEY_UNLIKELY(precision == INT_MAX) ? SIMDE_FLOAT64_C(0.0) : simde_math_pow(SIMDE_FLOAT64_C(10.0), -HEDLEY_STATIC_CAST(double, precision));
}
static int
simde_assert_equal_vf32_(
size_t vec_len, simde_float32 const a[HEDLEY_ARRAY_PARAM(vec_len)], simde_float32 const b[HEDLEY_ARRAY_PARAM(vec_len)], simde_float32 slop,
const char* filename, int line, const char* astr, const char* bstr) {
for (size_t i = 0 ; i < vec_len ; i++) {
if (HEDLEY_UNLIKELY(!simde_test_equal_f32(a[i], b[i], slop))) {
simde_test_debug_printf_("%s:%d: assertion failed: %s[%zu] ~= %s[%zu] (%f ~= %f)\n",
filename, line, astr, i, bstr, i, HEDLEY_STATIC_CAST(double, a[i]), HEDLEY_STATIC_CAST(double, b[i]));
SIMDE_TEST_ASSERT_RETURN(1);
}
}
return 0;
}
#define simde_assert_equal_vf32(vec_len, a, b, precision) simde_assert_equal_vf32_(vec_len, a, b, simde_test_f32_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)
static int
simde_assert_equal_f32_(simde_float32 a, simde_float32 b, simde_float32 slop,
const char* filename, int line, const char* astr, const char* bstr) {
if (HEDLEY_UNLIKELY(!simde_test_equal_f32(a, b, slop))) {
simde_test_debug_printf_("%s:%d: assertion failed: %s ~= %s (%f ~= %f)\n",
filename, line, astr, bstr, HEDLEY_STATIC_CAST(double, a), HEDLEY_STATIC_CAST(double, b));
SIMDE_TEST_ASSERT_RETURN(1);
}
return 0;
}
#define simde_assert_equal_f32(a, b, precision) simde_assert_equal_f32_(a, b, simde_test_f32_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)
static int
simde_assert_equal_vf64_(
size_t vec_len, simde_float64 const a[HEDLEY_ARRAY_PARAM(vec_len)], simde_float64 const b[HEDLEY_ARRAY_PARAM(vec_len)], simde_float64 slop,
const char* filename, int line, const char* astr, const char* bstr) {
for (size_t i = 0 ; i < vec_len ; i++) {
if (HEDLEY_UNLIKELY(!simde_test_equal_f64(a[i], b[i], slop))) {
simde_test_debug_printf_("%s:%d: assertion failed: %s[%zu] ~= %s[%zu] (%f ~= %f)\n",
filename, line, astr, i, bstr, i, HEDLEY_STATIC_CAST(double, a[i]), HEDLEY_STATIC_CAST(double, b[i]));
SIMDE_TEST_ASSERT_RETURN(1);
}
}
return 0;
}
#define simde_assert_equal_vf64(vec_len, a, b, precision) simde_assert_equal_vf64_(vec_len, a, b, simde_test_f64_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)
static int
simde_assert_equal_f64_(simde_float64 a, simde_float64 b, simde_float64 slop,
const char* filename, int line, const char* astr, const char* bstr) {
if (HEDLEY_UNLIKELY(!simde_test_equal_f64(a, b, slop))) {
simde_test_debug_printf_("%s:%d: assertion failed: %s ~= %s (%f ~= %f)\n",
filename, line, astr, bstr, a, b);
SIMDE_TEST_ASSERT_RETURN(1);
}
return 0;
}
#define simde_assert_equal_f64(a, b, precision) simde_assert_equal_f64_(a, b, simde_test_f64_precision_to_slop(precision), __FILE__, __LINE__, #a, #b)
#define SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(T, symbol_identifier, fmt) \
static int \
simde_assert_equal_v##symbol_identifier##_( \
size_t vec_len, const T a[HEDLEY_ARRAY_PARAM(vec_len)], const T b[HEDLEY_ARRAY_PARAM(vec_len)], \
const char* filename, int line, const char* astr, const char* bstr) { \
for (size_t i = 0 ; i < vec_len ; i++) { \
if (HEDLEY_UNLIKELY(a[i] != b[i])) { \
simde_test_debug_printf_("%s:%d: assertion failed: %s[%zu] == %s[%zu] (%" fmt " == %" fmt ")\n", \
filename, line, astr, i, bstr, i, a[i], b[i]); \
SIMDE_TEST_ASSERT_RETURN(1); \
} \
} \
return 0; \
} \
\
static int \
simde_assert_equal_##symbol_identifier##_(T a, T b, \
const char* filename, int line, const char* astr, const char* bstr) { \
if (HEDLEY_UNLIKELY(a != b)) { \
simde_test_debug_printf_("%s:%d: assertion failed: %s == %s (%" fmt " == %" fmt ")\n", \
filename, line, astr, bstr, a, b); \
SIMDE_TEST_ASSERT_RETURN(1); \
} \
return 0; \
} \
\
static int \
simde_assert_close_v##symbol_identifier##_( \
size_t vec_len, const T a[HEDLEY_ARRAY_PARAM(vec_len)], const T b[HEDLEY_ARRAY_PARAM(vec_len)], const T slop, \
const char* filename, int line, const char* astr, const char* bstr) { \
for (size_t i = 0 ; i < vec_len ; i++) { \
if (((a[i] + slop) < b[i]) || ((a[i] - slop) > b[i])) { \
simde_test_debug_printf_("%s:%d: assertion failed: %s[%zu] == %s[%zu] (%" fmt " == %" fmt ")\n", \
filename, line, astr, i, bstr, i, a[i], b[i]); \
SIMDE_TEST_ASSERT_RETURN(1); \
} \
} \
return 0; \
} \
\
static int \
simde_assert_close_##symbol_identifier##_(T a, T b, T slop, \
const char* filename, int line, const char* astr, const char* bstr) { \
if (((a + slop) < b) || ((a - slop) > b)) { \
simde_test_debug_printf_("%s:%d: assertion failed: %s == %s +/- %" fmt " (%" fmt " == %" fmt ")\n", \
filename, line, astr, bstr, slop, a, b); \
SIMDE_TEST_ASSERT_RETURN(1); \
} \
return 0; \
}
static int
simde_assert_equal_i_(int a, int b, const char* filename, int line, const char* astr, const char* bstr) {
if (HEDLEY_UNLIKELY(a != b)) {
simde_test_debug_printf_("%s:%d: assertion failed: %s == %s (%d == %d)\n",
filename, line, astr, bstr, a, b);
SIMDE_TEST_ASSERT_RETURN(1);
}
return 0;
}
SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(int8_t, i8, PRId8)
SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(int16_t, i16, PRId16)
SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(int32_t, i32, PRId32)
SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(int64_t, i64, PRId64)
SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(uint8_t, u8, PRIu8)
SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(uint16_t, u16, PRIu16)
SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(uint32_t, u32, PRIu32)
SIMDE_TEST_GENERATE_ASSERT_EQUAL_FUNC_(uint64_t, u64, PRIu64)
#define simde_assert_equal_vi8(vec_len, a, b) do { if (simde_assert_equal_vi8_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_vi16(vec_len, a, b) do { if (simde_assert_equal_vi16_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_vi32(vec_len, a, b) do { if (simde_assert_equal_vi32_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_vi64(vec_len, a, b) do { if (simde_assert_equal_vi64_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_vu8(vec_len, a, b) do { if (simde_assert_equal_vu8_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_vu16(vec_len, a, b) do { if (simde_assert_equal_vu16_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_vu32(vec_len, a, b) do { if (simde_assert_equal_vu32_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_vu64(vec_len, a, b) do { if (simde_assert_equal_vu64_(vec_len, a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_i8(a, b) do { if (simde_assert_equal_i8_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_i16(a, b) do { if (simde_assert_equal_i16_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_i32(a, b) do { if (simde_assert_equal_i32_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_i64(a, b) do { if (simde_assert_equal_i64_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_u8(a, b) do { if (simde_assert_equal_u8_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_u16(a, b) do { if (simde_assert_equal_u16_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_u32(a, b) do { if (simde_assert_equal_u32_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_u64(a, b) do { if (simde_assert_equal_u64_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_equal_i(a, b) do { if (simde_assert_equal_i_(a, b, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_vi8(vec_len, a, b, slop) do { if (simde_assert_close_vi8_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_vi16(vec_len, a, b, slop) do { if (simde_assert_close_vi16_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_vi32(vec_len, a, b, slop) do { if (simde_assert_close_vi32_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_vi64(vec_len, a, b, slop) do { if (simde_assert_close_vi64_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_vu8(vec_len, a, b, slop) do { if (simde_assert_close_vu8_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_vu16(vec_len, a, b, slop) do { if (simde_assert_close_vu16_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_vu32(vec_len, a, b, slop) do { if (simde_assert_close_vu32_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_vu64(vec_len, a, b, slop) do { if (simde_assert_close_vu64_(vec_len, a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_i8(a, b, slop) do { if (simde_assert_close_i8_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_i16(a, b, slop) do { if (simde_assert_close_i16_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_i32(a, b, slop) do { if (simde_assert_close_i32_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_i64(a, b, slop) do { if (simde_assert_close_i64_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_u8(a, b, slop) do { if (simde_assert_close_u8_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_u16(a, b, slop) do { if (simde_assert_close_u16_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_u32(a, b, slop) do { if (simde_assert_close_u32_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_u64(a, b, slop) do { if (simde_assert_close_u64_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
#define simde_assert_close_i(a, b, slop) do { if (simde_assert_close_i_(a, b, slop, __FILE__, __LINE__, #a, #b)) { return 1; } } while (0)
/* Since each test is compiled in 4 different versions (C/C++ and
* native/emul), we need to be able to generate different symbols
* depending on preprocessor macros. */
#if defined(SIMDE_NO_NATIVE)
#if defined(__cplusplus)
#define SIMDE_TEST_GENERATE_VARIANT_SYMBOL_CURRENT(name) HEDLEY_CONCAT(name,_emul_cpp)
#define SIMDE_TEST_GENERATE_VARIANT_NAME_CURRENT(name) #name "/emul/cpp"
#else
#define SIMDE_TEST_GENERATE_VARIANT_SYMBOL_CURRENT(name) HEDLEY_CONCAT(name,_emul_c)
#define SIMDE_TEST_GENERATE_VARIANT_NAME_CURRENT(name) #name "/emul/c"
#endif
#else
#if defined(__cplusplus)
#define SIMDE_TEST_GENERATE_VARIANT_SYMBOL_CURRENT(name) HEDLEY_CONCAT(name,_native_cpp)
#define SIMDE_TEST_GENERATE_VARIANT_NAME_CURRENT(name) #name "/native/cpp"
#else
#define SIMDE_TEST_GENERATE_VARIANT_SYMBOL_CURRENT(name) HEDLEY_CONCAT(name,_native_c)
#define SIMDE_TEST_GENERATE_VARIANT_NAME_CURRENT(name) #name "/native/c"
#endif
#endif
/* The bare version basically assumes you just want to run a single
* test suite. It doesn't use munit, or any other dependencies so
* it's easy to use with creduce. */
#if defined(SIMDE_TEST_BARE)
#define SIMDE_TEST_FUNC_LIST_BEGIN static const struct { int (* func)(void); const char* name; } test_suite_tests[] = {
#define SIMDE_TEST_FUNC_LIST_ENTRY(name) { test_simde_##name, #name },
#define SIMDE_TEST_FUNC_LIST_END };
#define SIMDE_MUNIT_TEST_ARGS void
#else
HEDLEY_DIAGNOSTIC_PUSH
SIMDE_DIAGNOSTIC_DISABLE_CPP98_COMPAT_PEDANTIC_
SIMDE_DIAGNOSTIC_DISABLE_OLD_STYLE_CAST_
SIMDE_DIAGNOSTIC_DISABLE_VARIADIC_MACROS_
SIMDE_DIAGNOSTIC_DISABLE_RESERVED_ID_MACRO_
#include "munit/munit.h"
HEDLEY_DIAGNOSTIC_POP
#if \
HEDLEY_HAS_ATTRIBUTE(unused) || \
HEDLEY_GCC_VERSION_CHECK(3,1,0)
#define SIMDE_MUNIT_TEST_ARGS __attribute__((__unused__)) const MunitParameter params[], __attribute__((__unused__)) void* data
#else
/* Compilers other than emscripten are fine with casting away
* arguments. */
#define SIMDE_MUNIT_TEST_ARGS void
#endif
#define SIMDE_TEST_FUNC_LIST_BEGIN static MunitTest test_suite_tests[] = {
#if defined(__cplusplus)
#define SIMDE_TEST_FUNC_LIST_ENTRY(name) { \
const_cast<char*>("/" SIMDE_TEST_GENERATE_VARIANT_NAME_CURRENT(name)), \
HEDLEY_REINTERPRET_CAST(MunitTestFunc, test_simde_##name), \
NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL },
#else
#define SIMDE_TEST_FUNC_LIST_ENTRY(name) { \
(char*) "/" SIMDE_TEST_GENERATE_VARIANT_NAME_CURRENT(name), \
HEDLEY_REINTERPRET_CAST(MunitTestFunc, test_simde_##name), \
NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL },
#endif
#define SIMDE_TEST_FUNC_LIST_END { NULL, NULL, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL } };
#define SIMDE_TEST_SUITE_DECLARE_GETTERS(name) \
HEDLEY_C_DECL MunitSuite* HEDLEY_CONCAT(name, _native_c)(void); \
HEDLEY_C_DECL MunitSuite* HEDLEY_CONCAT(name, _emul_c)(void); \
HEDLEY_C_DECL MunitSuite* HEDLEY_CONCAT(name, _native_cpp)(void); \
HEDLEY_C_DECL MunitSuite* HEDLEY_CONCAT(name, _emul_cpp)(void);
#endif
#endif /* !defined(SIMDE_TESTS_H) */