Skip to content

Commit d7ce779

Browse files
martygrantmartygrant
authored
Merge pull request oneapi-src#1451 from oneapi-src/martin/parameteriseEnqueueMemBufferTests
[CTS] Modify various urEnqueueMemBuffer* conformance tests to use parameterized fixtures
2 parents 4aeb55e + 21015af commit d7ce779

File tree

8 files changed

+196
-94
lines changed

8 files changed

+196
-94
lines changed

‎test/conformance/enqueue/helpers.h

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -83,6 +83,77 @@ print2DTestString(const testing::TestParamInfo<typename T::ParamType> &info) {
8383
return test_name.str();
8484
}
8585

86+
struct mem_buffer_test_parameters_t {
87+
size_t count;
88+
ur_mem_flag_t mem_flag;
89+
};
90+
91+
static std::vector<mem_buffer_test_parameters_t> mem_buffer_test_parameters{
92+
{1024, UR_MEM_FLAG_READ_WRITE},
93+
{2500, UR_MEM_FLAG_READ_WRITE},
94+
{4096, UR_MEM_FLAG_READ_WRITE},
95+
{6000, UR_MEM_FLAG_READ_WRITE},
96+
{1024, UR_MEM_FLAG_WRITE_ONLY},
97+
{2500, UR_MEM_FLAG_WRITE_ONLY},
98+
{4096, UR_MEM_FLAG_WRITE_ONLY},
99+
{6000, UR_MEM_FLAG_WRITE_ONLY},
100+
{1024, UR_MEM_FLAG_READ_ONLY},
101+
{2500, UR_MEM_FLAG_READ_ONLY},
102+
{4096, UR_MEM_FLAG_READ_ONLY},
103+
{6000, UR_MEM_FLAG_READ_ONLY},
104+
{1024, UR_MEM_FLAG_ALLOC_HOST_POINTER},
105+
{2500, UR_MEM_FLAG_ALLOC_HOST_POINTER},
106+
{4096, UR_MEM_FLAG_ALLOC_HOST_POINTER},
107+
{6000, UR_MEM_FLAG_ALLOC_HOST_POINTER},
108+
};
109+
110+
struct mem_buffer_map_write_test_parameters_t {
111+
size_t count;
112+
ur_mem_flag_t mem_flag;
113+
ur_map_flag_t map_flag;
114+
};
115+
116+
template <typename T>
117+
inline std::string printMemBufferTestString(
118+
const testing::TestParamInfo<typename T::ParamType> &info) {
119+
// ParamType will be std::tuple<ur_device_handle_t, mem_buffer_test_parameters_t>
120+
const auto device_handle = std::get<0>(info.param);
121+
const auto platform_device_name = GetPlatformAndDeviceName(device_handle);
122+
123+
std::stringstream ss;
124+
ss << std::get<1>(info.param).count;
125+
ss << "_";
126+
ss << std::get<1>(info.param).mem_flag;
127+
128+
return platform_device_name + "__" + ss.str();
129+
}
130+
131+
template <typename T>
132+
inline std::string printMemBufferMapWriteTestString(
133+
const testing::TestParamInfo<typename T::ParamType> &info) {
134+
// ParamType will be std::tuple<ur_device_handle_t, mem_buffer_map_write_test_parameters_t>
135+
const auto device_handle = std::get<0>(info.param);
136+
const auto platform_device_name = GetPlatformAndDeviceName(device_handle);
137+
138+
std::stringstream ss;
139+
ss << std::get<1>(info.param).map_flag;
140+
141+
return platform_device_name + "__" + ss.str();
142+
}
143+
144+
template <typename T>
145+
inline std::string
146+
printFillTestString(const testing::TestParamInfo<typename T::ParamType> &info) {
147+
const auto device_handle = std::get<0>(info.param);
148+
const auto platform_device_name =
149+
uur::GetPlatformAndDeviceName(device_handle);
150+
std::stringstream test_name;
151+
test_name << platform_device_name << "__size__"
152+
<< std::get<1>(info.param).size << "__patternSize__"
153+
<< std::get<1>(info.param).pattern_size;
154+
return test_name.str();
155+
}
156+
86157
} // namespace uur
87158

88159
#endif // UUR_ENQUEUE_RECT_HELPERS_H_INCLUDED

‎test/conformance/enqueue/urEnqueueMemBufferCopy.cpp

Lines changed: 17 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -3,11 +3,12 @@
33
// See LICENSE.TXT
44
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
55

6+
#include "helpers.h"
67
#include <uur/fixtures.h>
78

8-
struct urEnqueueMemBufferCopyTest : uur::urQueueTest {
9+
struct urEnqueueMemBufferCopyTestWithParam : uur::urQueueTestWithParam<size_t> {
910
void SetUp() override {
10-
UUR_RETURN_ON_FATAL_FAILURE(urQueueTest::SetUp());
11+
UUR_RETURN_ON_FATAL_FAILURE(urQueueTestWithParam::SetUp());
1112
ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_WRITE_ONLY, size,
1213
nullptr, &src_buffer));
1314
ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_ONLY, size,
@@ -25,18 +26,23 @@ struct urEnqueueMemBufferCopyTest : uur::urQueueTest {
2526
if (src_buffer) {
2627
EXPECT_SUCCESS(urMemRelease(dst_buffer));
2728
}
28-
urQueueTest::TearDown();
29+
urQueueTestWithParam::TearDown();
2930
}
3031

31-
const size_t count = 1024;
32+
const size_t count = std::get<1>(this->GetParam());
3233
const size_t size = sizeof(uint32_t) * count;
3334
ur_mem_handle_t src_buffer = nullptr;
3435
ur_mem_handle_t dst_buffer = nullptr;
3536
std::vector<uint32_t> input;
3637
};
37-
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueMemBufferCopyTest);
3838

39-
TEST_P(urEnqueueMemBufferCopyTest, Success) {
39+
static std::vector<size_t> test_parameters{1024, 2500, 4096, 6000};
40+
41+
UUR_TEST_SUITE_P(urEnqueueMemBufferCopyTestWithParam,
42+
::testing::ValuesIn(test_parameters),
43+
uur::deviceTestWithParamPrinter<size_t>);
44+
45+
TEST_P(urEnqueueMemBufferCopyTestWithParam, Success) {
4046
ASSERT_SUCCESS(urEnqueueMemBufferCopy(queue, src_buffer, dst_buffer, 0, 0,
4147
size, 0, nullptr, nullptr));
4248
std::vector<uint32_t> output(count, 1);
@@ -45,25 +51,25 @@ TEST_P(urEnqueueMemBufferCopyTest, Success) {
4551
ASSERT_EQ(input, output);
4652
}
4753

48-
TEST_P(urEnqueueMemBufferCopyTest, InvalidNullHandleQueue) {
54+
TEST_P(urEnqueueMemBufferCopyTestWithParam, InvalidNullHandleQueue) {
4955
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
5056
urEnqueueMemBufferCopy(nullptr, src_buffer, dst_buffer, 0,
5157
0, size, 0, nullptr, nullptr));
5258
}
5359

54-
TEST_P(urEnqueueMemBufferCopyTest, InvalidNullHandleBufferSrc) {
60+
TEST_P(urEnqueueMemBufferCopyTestWithParam, InvalidNullHandleBufferSrc) {
5561
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
5662
urEnqueueMemBufferCopy(queue, nullptr, dst_buffer, 0, 0,
5763
size, 0, nullptr, nullptr));
5864
}
5965

60-
TEST_P(urEnqueueMemBufferCopyTest, InvalidNullHandleBufferDst) {
66+
TEST_P(urEnqueueMemBufferCopyTestWithParam, InvalidNullHandleBufferDst) {
6167
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
6268
urEnqueueMemBufferCopy(queue, src_buffer, nullptr, 0, 0,
6369
size, 0, nullptr, nullptr));
6470
}
6571

66-
TEST_P(urEnqueueMemBufferCopyTest, InvalidNullPtrEventWaitList) {
72+
TEST_P(urEnqueueMemBufferCopyTestWithParam, InvalidNullPtrEventWaitList) {
6773
ASSERT_EQ_RESULT(urEnqueueMemBufferCopy(queue, src_buffer, dst_buffer, 0, 0,
6874
size, 1, nullptr, nullptr),
6975
UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
@@ -83,7 +89,7 @@ TEST_P(urEnqueueMemBufferCopyTest, InvalidNullPtrEventWaitList) {
8389
ASSERT_SUCCESS(urEventRelease(validEvent));
8490
}
8591

86-
TEST_P(urEnqueueMemBufferCopyTest, InvalidSize) {
92+
TEST_P(urEnqueueMemBufferCopyTestWithParam, InvalidSize) {
8793
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE,
8894
urEnqueueMemBufferCopy(queue, src_buffer, dst_buffer, 1, 0,
8995
size, 0, nullptr, nullptr));

‎test/conformance/enqueue/urEnqueueMemBufferFill.cpp

Lines changed: 2 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -2,26 +2,14 @@
22
// Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions.
33
// See LICENSE.TXT
44
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
5+
#include "helpers.h"
56
#include <uur/fixtures.h>
67

78
struct testParametersFill {
89
size_t size;
910
size_t pattern_size;
1011
};
1112

12-
template <typename T>
13-
inline std::string
14-
printFillTestString(const testing::TestParamInfo<typename T::ParamType> &info) {
15-
const auto device_handle = std::get<0>(info.param);
16-
const auto platform_device_name =
17-
uur::GetPlatformAndDeviceName(device_handle);
18-
std::stringstream test_name;
19-
test_name << platform_device_name << "__size__"
20-
<< std::get<1>(info.param).size << "__patternSize__"
21-
<< std::get<1>(info.param).pattern_size;
22-
return test_name.str();
23-
}
24-
2513
struct urEnqueueMemBufferFillTest
2614
: uur::urQueueTestWithParam<testParametersFill> {
2715
void SetUp() override {
@@ -76,7 +64,7 @@ static std::vector<testParametersFill> test_cases{
7664
{256, 32}};
7765

7866
UUR_TEST_SUITE_P(urEnqueueMemBufferFillTest, testing::ValuesIn(test_cases),
79-
printFillTestString<urEnqueueMemBufferFillTest>);
67+
uur::printFillTestString<urEnqueueMemBufferFillTest>);
8068

8169
TEST_P(urEnqueueMemBufferFillTest, Success) {
8270
ASSERT_SUCCESS(urEnqueueMemBufferFill(queue, buffer, pattern.data(),

‎test/conformance/enqueue/urEnqueueMemBufferMap.cpp

Lines changed: 35 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -2,12 +2,18 @@
22
// Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions.
33
// See LICENSE.TXT
44
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
5+
#include "helpers.h"
56
#include <uur/fixtures.h>
67

7-
using urEnqueueMemBufferMapTest = uur::urMemBufferQueueTest;
8-
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEnqueueMemBufferMapTest);
8+
using urEnqueueMemBufferMapTestWithParam =
9+
uur::urMemBufferQueueTestWithParam<uur::mem_buffer_test_parameters_t>;
910

10-
TEST_P(urEnqueueMemBufferMapTest, SuccessRead) {
11+
UUR_TEST_SUITE_P(
12+
urEnqueueMemBufferMapTestWithParam,
13+
::testing::ValuesIn(uur::mem_buffer_test_parameters),
14+
uur::printMemBufferTestString<urEnqueueMemBufferMapTestWithParam>);
15+
16+
TEST_P(urEnqueueMemBufferMapTestWithParam, SuccessRead) {
1117
const std::vector<uint32_t> input(count, 42);
1218
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,
1319
input.data(), 0, nullptr, nullptr));
@@ -21,22 +27,30 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessRead) {
2127
}
2228
}
2329

30+
static std::vector<uur::mem_buffer_map_write_test_parameters_t>
31+
map_write_test_parameters{
32+
{8, UR_MEM_FLAG_READ_WRITE, UR_MAP_FLAG_WRITE},
33+
{8, UR_MEM_FLAG_READ_WRITE, UR_MAP_FLAG_WRITE_INVALIDATE_REGION},
34+
};
35+
2436
using urEnqueueMemBufferMapTestWithWriteFlagParam =
25-
uur::urMemBufferQueueTestWithParam<ur_map_flag_t>;
37+
uur::urMemBufferQueueTestWithParam<
38+
uur::mem_buffer_map_write_test_parameters_t>;
39+
2640
UUR_TEST_SUITE_P(urEnqueueMemBufferMapTestWithWriteFlagParam,
27-
::testing::Values(UR_MAP_FLAG_WRITE,
28-
UR_MAP_FLAG_WRITE_INVALIDATE_REGION),
29-
uur::deviceTestWithParamPrinter<ur_map_flag_t>);
41+
::testing::ValuesIn(map_write_test_parameters),
42+
uur::printMemBufferMapWriteTestString<
43+
urEnqueueMemBufferMapTestWithWriteFlagParam>);
3044

3145
TEST_P(urEnqueueMemBufferMapTestWithWriteFlagParam, SuccessWrite) {
3246
const std::vector<uint32_t> input(count, 0);
3347
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,
3448
input.data(), 0, nullptr, nullptr));
3549

3650
uint32_t *map = nullptr;
37-
ASSERT_SUCCESS(urEnqueueMemBufferMap(queue, buffer, true, getParam(), 0,
38-
size, 0, nullptr, nullptr,
39-
(void **)&map));
51+
ASSERT_SUCCESS(urEnqueueMemBufferMap(queue, buffer, true,
52+
getParam().map_flag, 0, size, 0,
53+
nullptr, nullptr, (void **)&map));
4054
for (unsigned i = 0; i < count; ++i) {
4155
map[i] = 42;
4256
}
@@ -49,7 +63,7 @@ TEST_P(urEnqueueMemBufferMapTestWithWriteFlagParam, SuccessWrite) {
4963
}
5064
}
5165

52-
TEST_P(urEnqueueMemBufferMapTest, SuccessOffset) {
66+
TEST_P(urEnqueueMemBufferMapTestWithParam, SuccessOffset) {
5367
const std::vector<uint32_t> input(count, 0);
5468
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,
5569
input.data(), 0, nullptr, nullptr));
@@ -78,7 +92,7 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessOffset) {
7892
}
7993
}
8094

81-
TEST_P(urEnqueueMemBufferMapTest, SuccessPartialMap) {
95+
TEST_P(urEnqueueMemBufferMapTestWithParam, SuccessPartialMap) {
8296
const std::vector<uint32_t> input(count, 0);
8397
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,
8498
input.data(), 0, nullptr, nullptr));
@@ -106,7 +120,7 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessPartialMap) {
106120
}
107121
}
108122

109-
TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedRead) {
123+
TEST_P(urEnqueueMemBufferMapTestWithParam, SuccesPinnedRead) {
110124
const size_t memSize = sizeof(int);
111125
const int value = 20;
112126

@@ -130,7 +144,7 @@ TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedRead) {
130144
ASSERT_SUCCESS(urMemRelease(memObj));
131145
}
132146

133-
TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedWrite) {
147+
TEST_P(urEnqueueMemBufferMapTestWithParam, SuccesPinnedWrite) {
134148
const size_t memSize = sizeof(int);
135149
const int value = 30;
136150

@@ -157,7 +171,7 @@ TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedWrite) {
157171
ASSERT_SUCCESS(urMemRelease(memObj));
158172
}
159173

160-
TEST_P(urEnqueueMemBufferMapTest, SuccessMultiMaps) {
174+
TEST_P(urEnqueueMemBufferMapTestWithParam, SuccessMultiMaps) {
161175
const std::vector<uint32_t> input(count, 0);
162176
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,
163177
input.data(), 0, nullptr, nullptr));
@@ -198,39 +212,39 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessMultiMaps) {
198212
}
199213
}
200214

201-
TEST_P(urEnqueueMemBufferMapTest, InvalidNullHandleQueue) {
215+
TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullHandleQueue) {
202216
void *map = nullptr;
203217
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
204218
urEnqueueMemBufferMap(nullptr, buffer, true,
205219
UR_MAP_FLAG_READ | UR_MAP_FLAG_WRITE,
206220
0, size, 0, nullptr, nullptr, &map));
207221
}
208222

209-
TEST_P(urEnqueueMemBufferMapTest, InvalidNullHandleBuffer) {
223+
TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullHandleBuffer) {
210224
void *map = nullptr;
211225
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
212226
urEnqueueMemBufferMap(queue, nullptr, true,
213227
UR_MAP_FLAG_READ | UR_MAP_FLAG_WRITE,
214228
0, size, 0, nullptr, nullptr, &map));
215229
}
216230

217-
TEST_P(urEnqueueMemBufferMapTest, InvalidEnumerationMapFlags) {
231+
TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidEnumerationMapFlags) {
218232
void *map = nullptr;
219233
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION,
220234
urEnqueueMemBufferMap(queue, buffer, true,
221235
UR_MAP_FLAG_FORCE_UINT32, 0, size, 0,
222236
nullptr, nullptr, &map));
223237
}
224238

225-
TEST_P(urEnqueueMemBufferMapTest, InvalidNullPointerRetMap) {
239+
TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullPointerRetMap) {
226240
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
227241
urEnqueueMemBufferMap(queue, buffer, true,
228242
UR_MAP_FLAG_READ | UR_MAP_FLAG_WRITE,
229243
0, size, 0, nullptr, nullptr,
230244
nullptr));
231245
}
232246

233-
TEST_P(urEnqueueMemBufferMapTest, InvalidNullPtrEventWaitList) {
247+
TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullPtrEventWaitList) {
234248
void *map;
235249
ASSERT_EQ_RESULT(urEnqueueMemBufferMap(queue, buffer, true,
236250
UR_MAP_FLAG_READ | UR_MAP_FLAG_WRITE,
@@ -255,7 +269,7 @@ TEST_P(urEnqueueMemBufferMapTest, InvalidNullPtrEventWaitList) {
255269
ASSERT_SUCCESS(urEventRelease(validEvent));
256270
}
257271

258-
TEST_P(urEnqueueMemBufferMapTest, InvalidSize) {
272+
TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidSize) {
259273
void *map = nullptr;
260274
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE,
261275
urEnqueueMemBufferMap(queue, buffer, true, 0, 1, size, 0,

0 commit comments

Comments
 (0)