Skip to content

Commit 4ed505d

Browse files
damageboydamageboy
committed
Unify all different parametrized testing fixtures to one unified fixture that accepts various sorting patterns
1 parent 5036e03 commit 4ed505d

File tree

5 files changed

+240
-218
lines changed

5 files changed

+240
-218
lines changed

‎tests/fullsort/fullsort.avx2.cpp

+24-24
Original file line numberDiff line numberDiff line change
@@ -14,44 +14,44 @@ using VM = vxsort::vector_machine;
1414
using namespace vxsort;
1515

1616
#ifdef VXSORT_TEST_AVX2_I16
17-
struct VxSortAVX2_i16 : public SortWithSlackFixture<i16> {};
18-
auto vxsort_i16_params_avx2 = ValuesIn(SizeAndSlack<i16>::generate(10, 10000, 10, 32, 0x1000, 0x1));
19-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_i16, vxsort_i16_params_avx2, PrintSizeAndSlack<i16>());
17+
struct VxSortAVX2_i16 : public ParametrizedSortFixture<i16> {};
18+
auto vxsort_i16_params_avx2 = ValuesIn(SortTestParams<i16>::gen_mult(SortPattern::unique_values, 10, 10000, 10, 32, 0x1000, 0x1));
19+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_i16, vxsort_i16_params_avx2, PrintSortTestParams<i16>());
2020
#endif
2121
#ifdef VXSORT_TEST_AVX2_I32
22-
struct VxSortAVX2_i32 : public SortWithSlackFixture<i32> {};
23-
auto vxsort_i32_params_avx2 = ValuesIn(SizeAndSlack<i32>::generate(10, 1000000, 10, 16, 0x1000, 0x1));
24-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_i32, vxsort_i32_params_avx2, PrintSizeAndSlack<i32>());
22+
struct VxSortAVX2_i32 : public ParametrizedSortFixture<i32> {};
23+
auto vxsort_i32_params_avx2 = ValuesIn(SortTestParams<i32>::gen_mult(SortPattern::unique_values, 10, 1000000, 10, 16, 0x1000, 0x1));
24+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_i32, vxsort_i32_params_avx2, PrintSortTestParams<i32>());
2525
#endif
2626
#ifdef VXSORT_TEST_AVX2_I64
27-
struct VxSortAVX2_i64 : public SortWithSlackFixture<i64> {};
28-
auto vxsort_i64_params_avx2 = ValuesIn(SizeAndSlack<i64>::generate(10, 1000000, 10, 8, 0x1000, 0x1));
29-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_i64, vxsort_i64_params_avx2, PrintSizeAndSlack<i64>());
27+
struct VxSortAVX2_i64 : public ParametrizedSortFixture<i64> {};
28+
auto vxsort_i64_params_avx2 = ValuesIn(SortTestParams<i64>::gen_mult(SortPattern::unique_values, 10, 1000000, 10, 8, 0x1000, 0x1));
29+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_i64, vxsort_i64_params_avx2, PrintSortTestParams<i64>());
3030
#endif
3131
#ifdef VXSORT_TEST_AVX2_U16
32-
struct VxSortAVX2_u16 : public SortWithSlackFixture<u16> {};
33-
auto vxsort_u16_params_avx2 = ValuesIn(SizeAndSlack<u16>::generate(10, 1000000, 10, 16, 0x1000, 0x1));
34-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_u16, vxsort_u16_params_avx2, PrintSizeAndSlack<u16>());
32+
struct VxSortAVX2_u16 : public ParametrizedSortFixture<u16> {};
33+
auto vxsort_u16_params_avx2 = ValuesIn(SortTestParams<u16>::gen_mult(SortPattern::unique_values, 10, 1000000, 10, 16, 0x1000, 0x1));
34+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_u16, vxsort_u16_params_avx2, PrintSortTestParams<u16>());
3535
#endif
3636
#ifdef VXSORT_TEST_AVX2_U32
37-
struct VxSortAVX2_u32 : public SortWithSlackFixture<u32> {};
38-
auto vxsort_u32_params_avx2 = ValuesIn(SizeAndSlack<u32>::generate(10, 1000000, 10, 16, 0x1000, 0x1));
39-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_u32, vxsort_u32_params_avx2, PrintSizeAndSlack<u32>());
37+
struct VxSortAVX2_u32 : public ParametrizedSortFixture<u32> {};
38+
auto vxsort_u32_params_avx2 = ValuesIn(SortTestParams<u32>::gen_mult(SortPattern::unique_values, 10, 1000000, 10, 16, 0x1000, 0x1));
39+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_u32, vxsort_u32_params_avx2, PrintSortTestParams<u32>());
4040
#endif
4141
#ifdef VXSORT_TEST_AVX2_U64
42-
struct VxSortAVX2_u64 : public SortWithSlackFixture<u64> {};
43-
auto vxsort_u64_params_avx2 = ValuesIn(SizeAndSlack<u64>::generate(10, 1000000, 10, 8, 0x1000, 0x1));
44-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_u64, vxsort_u64_params_avx2, PrintSizeAndSlack<u64>());
42+
struct VxSortAVX2_u64 : public ParametrizedSortFixture<u64> {};
43+
auto vxsort_u64_params_avx2 = ValuesIn(SortTestParams<u64>::gen_mult(SortPattern::unique_values, 10, 1000000, 10, 8, 0x1000, 0x1));
44+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_u64, vxsort_u64_params_avx2, PrintSortTestParams<u64>());
4545
#endif
4646
#ifdef VXSORT_TEST_AVX2_F32
47-
struct VxSortAVX2_f32 : public SortWithSlackFixture<f32> {};
48-
auto vxsort_f32_params_avx2 = ValuesIn(SizeAndSlack<f32>::generate(10, 1000000, 10, 16, 1234.5, 0.1f));
49-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_f32, vxsort_f32_params_avx2, PrintSizeAndSlack<f32>());
47+
struct VxSortAVX2_f32 : public ParametrizedSortFixture<f32> {};
48+
auto vxsort_f32_params_avx2 = ValuesIn(SortTestParams<f32>::gen_mult(SortPattern::unique_values, 10, 1000000, 10, 16, 1234.5f, 0.1f));
49+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_f32, vxsort_f32_params_avx2, PrintSortTestParams<f32>());
5050
#endif
5151
#ifdef VXSORT_TEST_AVX2_F64
52-
struct VxSortAVX2_f64 : public SortWithSlackFixture<f64> {};
53-
auto vxsort_f64_params_avx2 = ValuesIn(SizeAndSlack<f64>::generate(10, 1000000, 10, 8, 1234.5, 0.1));
54-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_f64, vxsort_f64_params_avx2, PrintSizeAndSlack<f64>());
52+
struct VxSortAVX2_f64 : public ParametrizedSortFixture<f64> {};
53+
auto vxsort_f64_params_avx2 = ValuesIn(SortTestParams<f64>::gen_mult(SortPattern::unique_values, 10, 1000000, 10, 8, 1234.5, 0.1));
54+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX2_f64, vxsort_f64_params_avx2, PrintSortTestParams<f64>());
5555
#endif
5656

5757
#ifdef VXSORT_TEST_AVX2_I16

‎tests/fullsort/fullsort.avx512.cpp

+24-24
Original file line numberDiff line numberDiff line change
@@ -14,51 +14,51 @@ using VM = vxsort::vector_machine;
1414
using namespace vxsort;
1515

1616
#ifdef VXSORT_TEST_AVX512_I16
17-
struct VxSortAVX512_i16 : public SortWithSlackFixture<i16> {};
18-
auto vxsort_i16_params_avx512 = ValuesIn(SizeAndSlack<i16>::generate(10, 10000, 10, 32, 0x1000, 0x1));
19-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_i16, vxsort_i16_params_avx512, PrintSizeAndSlack<i16>());
17+
struct VxSortAVX512_i16 : public ParametrizedSortFixture<i16> {};
18+
auto vxsort_i16_params_avx512 = ValuesIn(SortTestParams<i16>::gen_mult(SortPattern::unique_values, 10, 10000, 10, 32, 0x1000, 0x1));
19+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_i16, vxsort_i16_params_avx512, PrintSortTestParams<i16>());
2020
#endif
2121

2222
#ifdef VXSORT_TEST_AVX512_I32
23-
struct VxSortAVX512_i32 : public SortWithSlackFixture<i32> {};
24-
auto vxsort_i32_params_avx512 = ValuesIn(SizeAndSlack<i32>::generate(10, 1000000, 10, 32, 0x1000, 0x1));
25-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_i32, vxsort_i32_params_avx512, PrintSizeAndSlack<i32>());
23+
struct VxSortAVX512_i32 : public ParametrizedSortFixture<i32> {};
24+
auto vxsort_i32_params_avx512 = ValuesIn(SortTestParams<i32>::gen_mult(SortPattern::unique_values, 10, 1000000, 10, 32, 0x1000, 0x1));
25+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_i32, vxsort_i32_params_avx512, PrintSortTestParams<i32>());
2626
#endif
2727

2828
#ifdef VXSORT_TEST_AVX512_I64
29-
struct VxSortAVX512_i64 : public SortWithSlackFixture<i64> {};
30-
auto vxsort_i64_params_avx512 = ValuesIn(SizeAndSlack<i64>::generate(10, 1000000, 10, 16, 0x1000, 0x1));
31-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_i64, vxsort_i64_params_avx512, PrintSizeAndSlack<i64>());
29+
struct VxSortAVX512_i64 : public ParametrizedSortFixture<i64> {};
30+
auto vxsort_i64_params_avx512 = ValuesIn(SortTestParams<i64>::gen_mult(SortPattern::unique_values, 10, 1000000, 10, 16, 0x1000, 0x1));
31+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_i64, vxsort_i64_params_avx512, PrintSortTestParams<i64>());
3232
#endif
3333

3434
#ifdef VXSORT_TEST_AVX512_U16
35-
struct VxSortAVX512_u16 : public SortWithSlackFixture<u16> {};
36-
auto vxsort_u16_params_avx512 = ValuesIn(SizeAndSlack<u16>::generate(10, 10000, 10, 32, 0x1000, 0x1));
37-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_u16, vxsort_u16_params_avx512, PrintSizeAndSlack<u16>());
35+
struct VxSortAVX512_u16 : public ParametrizedSortFixture<u16> {};
36+
auto vxsort_u16_params_avx512 = ValuesIn(SortTestParams<u16>::gen_mult(SortPattern::unique_values, 10, 10000, 10, 32, 0x1000, 0x1));
37+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_u16, vxsort_u16_params_avx512, PrintSortTestParams<u16>());
3838
#endif
3939

4040
#ifdef VXSORT_TEST_AVX512_U32
41-
struct VxSortAVX512_u32 : public SortWithSlackFixture<u32> {};
42-
auto vxsort_u32_params_avx512 = ValuesIn(SizeAndSlack<u32>::generate(10, 1000000, 10, 32, 0x1000, 0x1));
43-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_u32, vxsort_u32_params_avx512, PrintSizeAndSlack<u32>());
41+
struct VxSortAVX512_u32 : public ParametrizedSortFixture<u32> {};
42+
auto vxsort_u32_params_avx512 = ValuesIn(SortTestParams<u32>::gen_mult(SortPattern::unique_values, 10, 1000000, 10, 32, 0x1000, 0x1));
43+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_u32, vxsort_u32_params_avx512, PrintSortTestParams<u32>());
4444
#endif
4545

4646
#ifdef VXSORT_TEST_AVX512_U64
47-
struct VxSortAVX512_u64 : public SortWithSlackFixture<u64> {};
48-
auto vxsort_u64_params_avx512 = ValuesIn(SizeAndSlack<u64>::generate(10, 1000000, 10, 16, 0x1000, 0x1));
49-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_u64, vxsort_u64_params_avx512, PrintSizeAndSlack<u64>());
47+
struct VxSortAVX512_u64 : public ParametrizedSortFixture<u64> {};
48+
auto vxsort_u64_params_avx512 = ValuesIn(SortTestParams<u64>::gen_mult(SortPattern::unique_values, 10, 1000000, 10, 16, 0x1000, 0x1));
49+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_u64, vxsort_u64_params_avx512, PrintSortTestParams<u64>());
5050
#endif
5151

5252
#ifdef VXSORT_TEST_AVX512_F32
53-
struct VxSortAVX512_f32 : public SortWithSlackFixture<f32> {};
54-
auto vxsort_f32_params_avx512 = ValuesIn(SizeAndSlack<f32>::generate(10, 1000000, 10, 32, 1234.5, 0.1f));
55-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_f32, vxsort_f32_params_avx512, PrintSizeAndSlack<f32>());
53+
struct VxSortAVX512_f32 : public ParametrizedSortFixture<f32> {};
54+
auto vxsort_f32_params_avx512 = ValuesIn(SortTestParams<f32>::gen_mult(SortPattern::unique_values, 10, 1000000, 10, 32, 1234.5f, 0.1f));
55+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_f32, vxsort_f32_params_avx512, PrintSortTestParams<f32>());
5656
#endif
5757

5858
#ifdef VXSORT_TEST_AVX512_F64
59-
struct VxSortAVX512_f64 : public SortWithSlackFixture<f64> {};
60-
auto vxsort_f64_params_avx512 = ValuesIn(SizeAndSlack<f64>::generate(10, 1000000, 10, 16, 0x1000, 0x1));
61-
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_f64, vxsort_f64_params_avx512, PrintSizeAndSlack<f64>());
59+
struct VxSortAVX512_f64 : public ParametrizedSortFixture<f64> {};
60+
auto vxsort_f64_params_avx512 = ValuesIn(SortTestParams<f64>::gen_mult(SortPattern::unique_values, 10, 1000000, 10, 16, 1234.5, 0.1));
61+
INSTANTIATE_TEST_SUITE_P(VxSort, VxSortAVX512_f64, vxsort_f64_params_avx512, PrintSortTestParams<f64>());
6262
#endif
6363

6464

‎tests/smallsort/smallsort.avx2.cpp

+48-40
Original file line numberDiff line numberDiff line change
@@ -11,68 +11,76 @@ namespace vxsort_tests {
1111
using namespace vxsort::types;
1212
using VM = vxsort::vector_machine;
1313

14-
auto bitonic_machine_allvalues_avx2_16 = ValuesIn(range(16, 64, 16));
15-
auto bitonic_machine_allvalues_avx2_32 = ValuesIn(range(8, 32, 8));
16-
auto bitonic_machine_allvalues_avx2_64 = ValuesIn(range(4, 16, 4));
17-
18-
auto bitonic_allvalues_avx2_16 = ValuesIn(range(1, 8192, 1));
19-
auto bitonic_allvalues_avx2_32 = ValuesIn(range(1, 4096, 1));
20-
auto bitonic_allvalues_avx2_64 = ValuesIn(range(1, 2048, 1));
21-
2214
#ifdef VXSORT_TEST_AVX2_I16
23-
struct BitonicMachineAVX2_i16 : public SortFixture<i16> {};
24-
struct BitonicAVX2_i16 : public SortFixture<i16> {};
25-
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_i16, bitonic_machine_allvalues_avx2_16, PrintValue());
26-
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_i16, bitonic_allvalues_avx2_16, PrintValue());
15+
auto bitonic_machine_allvalues_avx2_i16 = ValuesIn(SortTestParams<i16>::gen_step(SortPattern::unique_values, 16, 64, 16, 0, 0x1000, 0x1));
16+
auto bitonic_allvalues_avx2_i16 = ValuesIn(SortTestParams<i16>::gen_step(SortPattern::unique_values, 1, 8192, 1, 0, 0x1000, 0x1));
17+
struct BitonicMachineAVX2_i16 : public ParametrizedSortFixture<i16> {};
18+
struct BitonicAVX2_i16 : public ParametrizedSortFixture<i16> {};
19+
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_i16, bitonic_machine_allvalues_avx2_i16, PrintSortTestParams<i16>());
20+
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_i16, bitonic_allvalues_avx2_i16, PrintSortTestParams<i16>());
2721
#endif
2822

2923
#ifdef VXSORT_TEST_AVX2_I32
30-
struct BitonicMachineAVX2_i32 : public SortFixture<i32> {};
31-
struct BitonicAVX2_i32 : public SortFixture<i32> {};
32-
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_i32, bitonic_machine_allvalues_avx2_32, PrintValue());
33-
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_i32, bitonic_allvalues_avx2_32, PrintValue());
24+
auto bitonic_machine_allvalues_avx2_i32 = ValuesIn(SortTestParams<i32>::gen_step(SortPattern::unique_values, 8, 32, 8, 0, 0x1000, 0x1));
25+
auto bitonic_allvalues_avx2_i32 = ValuesIn(SortTestParams<i32>::gen_step(SortPattern::unique_values, 1, 4096, 1, 0, 0x1000, 0x1));
26+
struct BitonicMachineAVX2_i32: public ParametrizedSortFixture<i32> {};
27+
struct BitonicAVX2_i32 : public ParametrizedSortFixture<i32> {};
28+
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_i32, bitonic_machine_allvalues_avx2_i32, PrintSortTestParams<i32>());
29+
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_i32, bitonic_allvalues_avx2_i32, PrintSortTestParams<i32>());
3430
#endif
3531

3632
#ifdef VXSORT_TEST_AVX2_I64
37-
struct BitonicMachineAVX2_i64 : public SortFixture<i64> {};
38-
struct BitonicAVX2_i64 : public SortFixture<i64> {};
39-
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_i64, bitonic_machine_allvalues_avx2_64, PrintValue());
40-
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_i64, bitonic_allvalues_avx2_64, PrintValue());
33+
auto bitonic_machine_allvalues_avx2_i64 = ValuesIn(SortTestParams<i64>::gen_step(SortPattern::unique_values, 4, 16, 4, 0, 0x1000, 0x1));
34+
auto bitonic_allvalues_avx2_i64 = ValuesIn(SortTestParams<i64>::gen_step(SortPattern::unique_values, 1, 2048, 1, 0, 0x1000, 0x1));
35+
struct BitonicMachineAVX2_i64 : public ParametrizedSortFixture<i64> {};
36+
struct BitonicAVX2_i64 : public ParametrizedSortFixture<i64> {};
37+
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_i64, bitonic_machine_allvalues_avx2_i64, PrintSortTestParams<i64>());
38+
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_i64, bitonic_allvalues_avx2_i64, PrintSortTestParams<i64>());
4139
#endif
4240

4341
#ifdef VXSORT_TEST_AVX2_U16
44-
struct BitonicMachineAVX2_u16 : public SortFixture<u16> {};
45-
struct BitonicAVX2_u16 : public SortFixture<u16> {};
46-
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_u16, bitonic_machine_allvalues_avx2_16, PrintValue());
47-
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_u16, bitonic_allvalues_avx2_16, PrintValue());
42+
auto bitonic_machine_allvalues_avx2_u16 = ValuesIn(SortTestParams<u16>::gen_step(SortPattern::unique_values, 16, 64, 16, 0, 0x1000, 0x1));
43+
auto bitonic_allvalues_avx2_u16 = ValuesIn(SortTestParams<u16>::gen_step(SortPattern::unique_values, 1, 8192, 1, 0, 0x1000, 0x1));
44+
struct BitonicMachineAVX2_u16 : public ParametrizedSortFixture<u16> {};
45+
struct BitonicAVX2_u16 : public ParametrizedSortFixture<u16> {};
46+
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_u16, bitonic_machine_allvalues_avx2_u16, PrintSortTestParams<u16>());
47+
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_u16, bitonic_allvalues_avx2_u16, PrintSortTestParams<u16>());
4848
#endif
4949

5050
#ifdef VXSORT_TEST_AVX2_U32
51-
struct BitonicMachineAVX2_u32 : public SortFixture<u32> {};
52-
struct BitonicAVX2_u32 : public SortFixture<u32> {};
53-
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_u32, bitonic_machine_allvalues_avx2_32, PrintValue());
54-
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_u32, bitonic_allvalues_avx2_32, PrintValue());
51+
auto bitonic_machine_allvalues_avx2_u32 = ValuesIn(SortTestParams<u32>::gen_step(SortPattern::unique_values, 8, 32, 8, 0, 0x1000, 0x1));
52+
auto bitonic_allvalues_avx2_u32 = ValuesIn(SortTestParams<u32>::gen_step(SortPattern::unique_values, 1, 4096, 1, 0, 0x1000, 0x1));
53+
struct BitonicMachineAVX2_u32 : public ParametrizedSortFixture<u32> {};
54+
struct BitonicAVX2_u32 : public ParametrizedSortFixture<u32> {};
55+
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_u32, bitonic_machine_allvalues_avx2_u32, PrintSortTestParams<u32>());
56+
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_u32, bitonic_allvalues_avx2_u32, PrintSortTestParams<u32>());
5557
#endif
5658

5759
#ifdef VXSORT_TEST_AVX2_U64
58-
struct BitonicMachineAVX2_u64 : public SortFixture<u64> {};
59-
struct BitonicAVX2_u64 : public SortFixture<u64> {};
60-
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_u64, bitonic_machine_allvalues_avx2_64, PrintValue());
61-
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_u64, bitonic_allvalues_avx2_64, PrintValue());
60+
auto bitonic_machine_allvalues_avx2_u64 = ValuesIn(SortTestParams<u64>::gen_step(SortPattern::unique_values, 4, 16, 4, 0, 0x1000, 0x1));
61+
auto bitonic_allvalues_avx2_u64 = ValuesIn(SortTestParams<u64>::gen_step(SortPattern::unique_values, 1, 2048, 1, 0, 0x1000, 0x1));
62+
struct BitonicMachineAVX2_u64 : public ParametrizedSortFixture<u64> {};
63+
struct BitonicAVX2_u64 : public ParametrizedSortFixture<u64> {};
64+
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_u64, bitonic_machine_allvalues_avx2_u64, PrintSortTestParams<u64>());
65+
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_u64, bitonic_allvalues_avx2_u64, PrintSortTestParams<u64>());
6266
#endif
6367

6468
#ifdef VXSORT_TEST_AVX2_F32
65-
struct BitonicMachineAVX2_f32 : public SortFixture<f32> {};
66-
struct BitonicAVX2_f32 : public SortFixture<f32> {};
67-
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_f32, bitonic_machine_allvalues_avx2_32, PrintValue());
68-
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_f32, bitonic_allvalues_avx2_32, PrintValue());
69+
auto bitonic_machine_allvalues_avx2_f32 = ValuesIn(SortTestParams<f32>::gen_step(SortPattern::unique_values, 8, 32, 8, 0, 1234.5f, 0.1f));
70+
auto bitonic_allvalues_avx2_f32 = ValuesIn(SortTestParams<f32>::gen_step(SortPattern::unique_values, 1, 4096, 1, 0, 1234.5f, 0.1f));
71+
struct BitonicMachineAVX2_f32 : public ParametrizedSortFixture<f32> {};
72+
struct BitonicAVX2_f32 : public ParametrizedSortFixture<f32> {};
73+
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_f32, bitonic_machine_allvalues_avx2_f32, PrintSortTestParams<f32>());
74+
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_f32, bitonic_allvalues_avx2_f32, PrintSortTestParams<f32>());
6975
#endif
7076

7177
#ifdef VXSORT_TEST_AVX2_F64
72-
struct BitonicMachineAVX2_f64 : public SortFixture<f64> {};
73-
struct BitonicAVX2_f64 : public SortFixture<f64> {};
74-
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_f64, bitonic_machine_allvalues_avx2_64, PrintValue());
75-
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_f64, bitonic_allvalues_avx2_64, PrintValue());
78+
auto bitonic_machine_allvalues_avx2_f64 = ValuesIn(SortTestParams<f64>::gen_step(SortPattern::unique_values, 4, 16, 4, 0, 1234.5, 0.1));
79+
auto bitonic_allvalues_avx2_f64 = ValuesIn(SortTestParams<f64>::gen_step(SortPattern::unique_values, 1, 2048, 1, 0, 1234.5, 0.1));
80+
struct BitonicMachineAVX2_f64 : public ParametrizedSortFixture<f64> {};
81+
struct BitonicAVX2_f64 : public ParametrizedSortFixture<f64> {};
82+
INSTANTIATE_TEST_SUITE_P(BitonicMachineAVX2, BitonicMachineAVX2_f64, bitonic_machine_allvalues_avx2_f64, PrintSortTestParams<f64>());
83+
INSTANTIATE_TEST_SUITE_P(BitonicAVX2, BitonicAVX2_f64, bitonic_allvalues_avx2_f64, PrintSortTestParams<f64>());
7684
#endif
7785

7886
#ifdef VXSORT_TEST_AVX2_I16

0 commit comments

Comments
 (0)