Skip to content

Commit 6a44b93

Browse files
martygrantmartygrant
committed
[CTS] Modify various urEnqueueMemBuffer* conformance tests to use parameterized fixtures.
1 parent c98fdbc commit 6a44b93

File tree

8 files changed

+252
-96
lines changed

8 files changed

+252
-96
lines changed

‎test/conformance/enqueue/helpers.h‎

Lines changed: 52 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -96,6 +96,58 @@ print2DTestString(const testing::TestParamInfo<typename T::ParamType> &info) {
9696
return test_name.str();
9797
}
9898

99+
struct mem_buffer_test_parameters_t {
100+
size_t count;
101+
ur_mem_flag_t mem_flag;
102+
};
103+
104+
struct mem_buffer_map_write_test_parameters_t {
105+
size_t count;
106+
ur_mem_flag_t mem_flag;
107+
ur_map_flag_t map_flag;
108+
};
109+
110+
template <typename T>
111+
inline std::string printMemBufferTestString(
112+
const testing::TestParamInfo<typename T::ParamType> &info) {
113+
// ParamType will be std::tuple<ur_device_handle_t, test_parameters_t>
114+
const auto device_handle = std::get<0>(info.param);
115+
const auto platform_device_name = GetPlatformAndDeviceName(device_handle);
116+
117+
std::stringstream ss;
118+
ss << std::get<1>(info.param).count;
119+
ss << "_";
120+
ss << std::get<1>(info.param).mem_flag;
121+
122+
return platform_device_name + "__" + ss.str();
123+
}
124+
125+
template <typename T>
126+
inline std::string printMemBufferMapWriteTestString(
127+
const testing::TestParamInfo<typename T::ParamType> &info) {
128+
// ParamType will be std::tuple<ur_device_handle_t, mem_buffer_map_write_test_parameters_t>
129+
const auto device_handle = std::get<0>(info.param);
130+
const auto platform_device_name = GetPlatformAndDeviceName(device_handle);
131+
132+
std::stringstream ss;
133+
ss << std::get<1>(info.param).map_flag;
134+
135+
return platform_device_name + "__" + ss.str();
136+
}
137+
138+
template <typename T>
139+
inline std::string
140+
printFillTestString(const testing::TestParamInfo<typename T::ParamType> &info) {
141+
const auto device_handle = std::get<0>(info.param);
142+
const auto platform_device_name =
143+
uur::GetPlatformAndDeviceName(device_handle);
144+
std::stringstream test_name;
145+
test_name << platform_device_name << "__size__"
146+
<< std::get<1>(info.param).size << "__patternSize__"
147+
<< std::get<1>(info.param).pattern_size;
148+
return test_name.str();
149+
}
150+
99151
} // namespace uur
100152

101153
#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: 54 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -2,12 +2,36 @@
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);
9-
10-
TEST_P(urEnqueueMemBufferMapTest, SuccessRead) {
8+
using urEnqueueMemBufferMapTestWithParam =
9+
uur::urMemBufferQueueTestWithParam<uur::mem_buffer_test_parameters_t>;
10+
11+
static std::vector<uur::mem_buffer_test_parameters_t> test_parameters{
12+
{1024, UR_MEM_FLAG_READ_WRITE},
13+
{2500, UR_MEM_FLAG_READ_WRITE},
14+
{4096, UR_MEM_FLAG_READ_WRITE},
15+
{6000, UR_MEM_FLAG_READ_WRITE},
16+
{1024, UR_MEM_FLAG_WRITE_ONLY},
17+
{2500, UR_MEM_FLAG_WRITE_ONLY},
18+
{4096, UR_MEM_FLAG_WRITE_ONLY},
19+
{6000, UR_MEM_FLAG_WRITE_ONLY},
20+
{1024, UR_MEM_FLAG_READ_ONLY},
21+
{2500, UR_MEM_FLAG_READ_ONLY},
22+
{4096, UR_MEM_FLAG_READ_ONLY},
23+
{6000, UR_MEM_FLAG_READ_ONLY},
24+
{1024, UR_MEM_FLAG_ALLOC_HOST_POINTER},
25+
{2500, UR_MEM_FLAG_ALLOC_HOST_POINTER},
26+
{4096, UR_MEM_FLAG_ALLOC_HOST_POINTER},
27+
{6000, UR_MEM_FLAG_ALLOC_HOST_POINTER},
28+
};
29+
30+
UUR_TEST_SUITE_P(
31+
urEnqueueMemBufferMapTestWithParam, ::testing::ValuesIn(test_parameters),
32+
uur::printMemBufferTestString<urEnqueueMemBufferMapTestWithParam>);
33+
34+
TEST_P(urEnqueueMemBufferMapTestWithParam, SuccessRead) {
1135
const std::vector<uint32_t> input(count, 42);
1236
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,
1337
input.data(), 0, nullptr, nullptr));
@@ -21,22 +45,30 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessRead) {
2145
}
2246
}
2347

48+
static std::vector<uur::mem_buffer_map_write_test_parameters_t>
49+
map_write_test_parameters{
50+
{8, UR_MEM_FLAG_READ_WRITE, UR_MAP_FLAG_WRITE},
51+
{8, UR_MEM_FLAG_READ_WRITE, UR_MAP_FLAG_WRITE_INVALIDATE_REGION},
52+
};
53+
2454
using urEnqueueMemBufferMapTestWithWriteFlagParam =
25-
uur::urMemBufferQueueTestWithParam<ur_map_flag_t>;
55+
uur::urMemBufferQueueTestWithParam<
56+
uur::mem_buffer_map_write_test_parameters_t>;
57+
2658
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>);
59+
::testing::ValuesIn(map_write_test_parameters),
60+
uur::printMemBufferMapWriteTestString<
61+
urEnqueueMemBufferMapTestWithWriteFlagParam>);
3062

3163
TEST_P(urEnqueueMemBufferMapTestWithWriteFlagParam, SuccessWrite) {
3264
const std::vector<uint32_t> input(count, 0);
3365
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,
3466
input.data(), 0, nullptr, nullptr));
3567

3668
uint32_t *map = nullptr;
37-
ASSERT_SUCCESS(urEnqueueMemBufferMap(queue, buffer, true, getParam(), 0,
38-
size, 0, nullptr, nullptr,
39-
(void **)&map));
69+
ASSERT_SUCCESS(urEnqueueMemBufferMap(queue, buffer, true,
70+
getParam().map_flag, 0, size, 0,
71+
nullptr, nullptr, (void **)&map));
4072
for (unsigned i = 0; i < count; ++i) {
4173
map[i] = 42;
4274
}
@@ -49,7 +81,7 @@ TEST_P(urEnqueueMemBufferMapTestWithWriteFlagParam, SuccessWrite) {
4981
}
5082
}
5183

52-
TEST_P(urEnqueueMemBufferMapTest, SuccessOffset) {
84+
TEST_P(urEnqueueMemBufferMapTestWithParam, SuccessOffset) {
5385
const std::vector<uint32_t> input(count, 0);
5486
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,
5587
input.data(), 0, nullptr, nullptr));
@@ -78,7 +110,7 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessOffset) {
78110
}
79111
}
80112

81-
TEST_P(urEnqueueMemBufferMapTest, SuccessPartialMap) {
113+
TEST_P(urEnqueueMemBufferMapTestWithParam, SuccessPartialMap) {
82114
const std::vector<uint32_t> input(count, 0);
83115
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,
84116
input.data(), 0, nullptr, nullptr));
@@ -106,7 +138,7 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessPartialMap) {
106138
}
107139
}
108140

109-
TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedRead) {
141+
TEST_P(urEnqueueMemBufferMapTestWithParam, SuccesPinnedRead) {
110142
const size_t memSize = sizeof(int);
111143
const int value = 20;
112144

@@ -130,7 +162,7 @@ TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedRead) {
130162
ASSERT_SUCCESS(urMemRelease(memObj));
131163
}
132164

133-
TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedWrite) {
165+
TEST_P(urEnqueueMemBufferMapTestWithParam, SuccesPinnedWrite) {
134166
const size_t memSize = sizeof(int);
135167
const int value = 30;
136168

@@ -157,7 +189,7 @@ TEST_P(urEnqueueMemBufferMapTest, SuccesPinnedWrite) {
157189
ASSERT_SUCCESS(urMemRelease(memObj));
158190
}
159191

160-
TEST_P(urEnqueueMemBufferMapTest, SuccessMultiMaps) {
192+
TEST_P(urEnqueueMemBufferMapTestWithParam, SuccessMultiMaps) {
161193
const std::vector<uint32_t> input(count, 0);
162194
ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,
163195
input.data(), 0, nullptr, nullptr));
@@ -198,39 +230,39 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessMultiMaps) {
198230
}
199231
}
200232

201-
TEST_P(urEnqueueMemBufferMapTest, InvalidNullHandleQueue) {
233+
TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullHandleQueue) {
202234
void *map = nullptr;
203235
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
204236
urEnqueueMemBufferMap(nullptr, buffer, true,
205237
UR_MAP_FLAG_READ | UR_MAP_FLAG_WRITE,
206238
0, size, 0, nullptr, nullptr, &map));
207239
}
208240

209-
TEST_P(urEnqueueMemBufferMapTest, InvalidNullHandleBuffer) {
241+
TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullHandleBuffer) {
210242
void *map = nullptr;
211243
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
212244
urEnqueueMemBufferMap(queue, nullptr, true,
213245
UR_MAP_FLAG_READ | UR_MAP_FLAG_WRITE,
214246
0, size, 0, nullptr, nullptr, &map));
215247
}
216248

217-
TEST_P(urEnqueueMemBufferMapTest, InvalidEnumerationMapFlags) {
249+
TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidEnumerationMapFlags) {
218250
void *map = nullptr;
219251
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION,
220252
urEnqueueMemBufferMap(queue, buffer, true,
221253
UR_MAP_FLAG_FORCE_UINT32, 0, size, 0,
222254
nullptr, nullptr, &map));
223255
}
224256

225-
TEST_P(urEnqueueMemBufferMapTest, InvalidNullPointerRetMap) {
257+
TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullPointerRetMap) {
226258
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
227259
urEnqueueMemBufferMap(queue, buffer, true,
228260
UR_MAP_FLAG_READ | UR_MAP_FLAG_WRITE,
229261
0, size, 0, nullptr, nullptr,
230262
nullptr));
231263
}
232264

233-
TEST_P(urEnqueueMemBufferMapTest, InvalidNullPtrEventWaitList) {
265+
TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullPtrEventWaitList) {
234266
void *map;
235267
ASSERT_EQ_RESULT(urEnqueueMemBufferMap(queue, buffer, true,
236268
UR_MAP_FLAG_READ | UR_MAP_FLAG_WRITE,
@@ -255,7 +287,7 @@ TEST_P(urEnqueueMemBufferMapTest, InvalidNullPtrEventWaitList) {
255287
ASSERT_SUCCESS(urEventRelease(validEvent));
256288
}
257289

258-
TEST_P(urEnqueueMemBufferMapTest, InvalidSize) {
290+
TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidSize) {
259291
void *map = nullptr;
260292
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE,
261293
urEnqueueMemBufferMap(queue, buffer, true, 0, 1, size, 0,

0 commit comments

Comments
 (0)