Skip to content

Commit 02ea5ef

Browse files
martygrantmartygrant
committed
Move GetInfo queries into separate tests rather than being done in a switch statement in one test.
Remove tests for owned/unowned native queue, as it is being handled in #2193.
1 parent 80c359c commit 02ea5ef

File tree

3 files changed

+129
-138
lines changed

3 files changed

+129
-138
lines changed

‎test/conformance/queue/queue_adapter_native_cpu.match‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -3,12 +3,12 @@ urQueueCreateTest.CheckContext/*
33
urQueueCreateWithParamTest.SuccessWithProperties/*
44
urQueueCreateWithParamTest.MatchingDeviceHandles/*
55
urQueueFlushTest.Success/*
6-
urQueueGetInfoTestWithInfoParam.Success/*__UR_QUEUE_INFO_CONTEXT
7-
urQueueGetInfoTestWithInfoParam.Success/*__UR_QUEUE_INFO_DEVICE
8-
urQueueGetInfoTestWithInfoParam.Success/*__UR_QUEUE_INFO_FLAGS
9-
urQueueGetInfoTestWithInfoParam.Success/*__UR_QUEUE_INFO_REFERENCE_COUNT
10-
urQueueGetInfoTestWithInfoParam.Success/*__UR_QUEUE_INFO_EMPTY
11-
urQueueGetInfoDeviceQueueTestWithInfoParam.Success/*
6+
urQueueGetInfoTest.Context/*
7+
urQueueGetInfoTest.Device/*
8+
urQueueGetInfoTest.Flags/*
9+
urQueueGetInfoTest.ReferenceCount/*
1210
urQueueGetInfoTest.InvalidSizeSmall/*
11+
urQueueGetInfoDeviceQueueTestWithInfoParam.DeviceDefault/*
12+
urQueueGetInfoDeviceQueueTestWithInfoParam.Size/*
1313
urQueueRetainTest.Success/*
1414
urQueueReleaseTest.Success/*

‎test/conformance/queue/urQueueCreateWithNativeHandle.cpp‎

Lines changed: 0 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -54,33 +54,3 @@ TEST_P(urQueueCreateWithNativeHandleTest, InvalidNullPointer) {
5454
nullptr, nullptr),
5555
UR_RESULT_ERROR_INVALID_NULL_POINTER);
5656
}
57-
58-
TEST_P(urQueueCreateWithNativeHandleTest, SuccessWithOwnedNativeHandle) {
59-
ur_native_handle_t native_handle = 0;
60-
{
61-
UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
62-
urQueueGetNativeHandle(queue, nullptr, &native_handle));
63-
}
64-
65-
ur_queue_handle_t q = nullptr;
66-
ur_queue_native_properties_t properties{
67-
UR_STRUCTURE_TYPE_QUEUE_NATIVE_PROPERTIES, nullptr, true};
68-
ASSERT_SUCCESS(urQueueCreateWithNativeHandle(native_handle, context, device,
69-
&properties, &q));
70-
ASSERT_NE(q, nullptr);
71-
}
72-
73-
TEST_P(urQueueCreateWithNativeHandleTest, SuccessWithUnOwnedNativeHandle) {
74-
ur_native_handle_t native_handle = 0;
75-
{
76-
UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
77-
urQueueGetNativeHandle(queue, nullptr, &native_handle));
78-
}
79-
80-
ur_queue_handle_t q = nullptr;
81-
ur_queue_native_properties_t properties{
82-
UR_STRUCTURE_TYPE_QUEUE_NATIVE_PROPERTIES, nullptr, false};
83-
ASSERT_SUCCESS(urQueueCreateWithNativeHandle(native_handle, context, device,
84-
&properties, &q));
85-
ASSERT_NE(q, nullptr);
86-
}

‎test/conformance/queue/urQueueGetInfo.cpp‎

Lines changed: 123 additions & 102 deletions
Original file line numberDiff line numberDiff line change
@@ -5,120 +5,80 @@
55
#include <map>
66
#include <uur/fixtures.h>
77

8-
std::unordered_map<ur_queue_info_t, size_t> queue_info_size_map = {
9-
{UR_QUEUE_INFO_CONTEXT, sizeof(ur_context_handle_t)},
10-
{UR_QUEUE_INFO_DEVICE, sizeof(ur_device_handle_t)},
11-
{UR_QUEUE_INFO_DEVICE_DEFAULT, sizeof(ur_queue_handle_t)},
12-
{UR_QUEUE_INFO_FLAGS, sizeof(ur_queue_flags_t)},
13-
{UR_QUEUE_INFO_REFERENCE_COUNT, sizeof(uint32_t)},
14-
{UR_QUEUE_INFO_SIZE, sizeof(uint32_t)},
15-
{UR_QUEUE_INFO_EMPTY, sizeof(ur_bool_t)},
16-
};
8+
using urQueueGetInfoTest = uur::urQueueTest;
9+
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urQueueGetInfoTest);
1710

18-
using urQueueGetInfoTestWithInfoParam =
19-
uur::urQueueTestWithParam<ur_queue_info_t>;
11+
TEST_P(urQueueGetInfoTest, Context) {
12+
size_t size = 0;
13+
auto infoType = UR_QUEUE_INFO_CONTEXT;
14+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
15+
ASSERT_NE(size, 0);
16+
ASSERT_EQ(sizeof(ur_context_handle_t), size);
17+
18+
std::vector<uint8_t> data(size);
19+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
2020

21-
UUR_TEST_SUITE_P(urQueueGetInfoTestWithInfoParam,
22-
::testing::Values(UR_QUEUE_INFO_CONTEXT, UR_QUEUE_INFO_DEVICE,
23-
UR_QUEUE_INFO_FLAGS,
24-
UR_QUEUE_INFO_REFERENCE_COUNT,
25-
UR_QUEUE_INFO_EMPTY),
26-
uur::deviceTestWithParamPrinter<ur_queue_info_t>);
21+
auto returned_context =
22+
reinterpret_cast<ur_context_handle_t *>(data.data());
23+
ASSERT_EQ(context, *returned_context);
24+
}
2725

28-
TEST_P(urQueueGetInfoTestWithInfoParam, Success) {
29-
ur_queue_info_t info_type = getParam();
26+
TEST_P(urQueueGetInfoTest, Device) {
3027
size_t size = 0;
31-
auto result = urQueueGetInfo(queue, info_type, 0, nullptr, &size);
28+
auto infoType = UR_QUEUE_INFO_DEVICE;
29+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
30+
ASSERT_NE(size, 0);
31+
ASSERT_EQ(sizeof(ur_device_handle_t), size);
3232

33-
if (result == UR_RESULT_SUCCESS) {
34-
ASSERT_NE(size, 0);
33+
std::vector<uint8_t> data(size);
34+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
3535

36-
if (const auto expected_size = queue_info_size_map.find(info_type);
37-
expected_size != queue_info_size_map.end()) {
38-
ASSERT_EQ(expected_size->second, size);
39-
}
36+
auto returned_device = reinterpret_cast<ur_device_handle_t *>(data.data());
37+
ASSERT_EQ(device, *returned_device);
38+
}
4039

41-
std::vector<uint8_t> data(size);
42-
ASSERT_SUCCESS(
43-
urQueueGetInfo(queue, info_type, size, data.data(), nullptr));
44-
45-
switch (info_type) {
46-
case UR_QUEUE_INFO_CONTEXT: {
47-
auto returned_context =
48-
reinterpret_cast<ur_context_handle_t *>(data.data());
49-
ASSERT_EQ(context, *returned_context);
50-
break;
51-
}
52-
case UR_QUEUE_INFO_DEVICE: {
53-
auto returned_device =
54-
reinterpret_cast<ur_device_handle_t *>(data.data());
55-
ASSERT_EQ(*returned_device, device);
56-
break;
57-
}
58-
case UR_QUEUE_INFO_DEVICE_DEFAULT: {
59-
auto returned_default_queue =
60-
reinterpret_cast<ur_queue_handle_t *>(data.data());
61-
ASSERT_EQ(*returned_default_queue, queue);
62-
break;
63-
}
64-
case UR_QUEUE_INFO_FLAGS: {
65-
auto returned_flags =
66-
reinterpret_cast<ur_queue_flags_t *>(data.data());
67-
EXPECT_EQ(*returned_flags, *returned_flags & UR_QUEUE_FLAGS_MASK);
68-
break;
69-
}
70-
case UR_QUEUE_INFO_REFERENCE_COUNT: {
71-
auto returned_reference_count =
72-
reinterpret_cast<uint32_t *>(data.data());
73-
ASSERT_GT(*returned_reference_count, 0U);
74-
break;
75-
}
76-
case UR_QUEUE_INFO_EMPTY: {
77-
auto returned_empty_queue =
78-
reinterpret_cast<ur_bool_t *>(data.data());
79-
ASSERT_TRUE(returned_empty_queue);
80-
break;
81-
}
82-
default:
83-
break;
84-
}
85-
} else {
86-
ASSERT_EQ_RESULT(result, UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION);
87-
}
40+
TEST_P(urQueueGetInfoTest, Flags) {
41+
size_t size = 0;
42+
auto infoType = UR_QUEUE_INFO_FLAGS;
43+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
44+
ASSERT_NE(size, 0);
45+
ASSERT_EQ(sizeof(ur_queue_flags_t), size);
46+
47+
std::vector<uint8_t> data(size);
48+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
49+
50+
auto returned_flags = reinterpret_cast<ur_queue_flags_t *>(data.data());
51+
EXPECT_EQ(*returned_flags, queue_properties.flags);
8852
}
8953

90-
struct urQueueGetInfoDeviceQueueTestWithInfoParam
91-
: public uur::urContextTestWithParam<ur_queue_info_t> {
92-
void SetUp() {
93-
urContextTestWithParam<ur_queue_info_t>::SetUp();
94-
ur_queue_flags_t deviceQueueCapabilities;
95-
ASSERT_SUCCESS(
96-
urDeviceGetInfo(device, UR_DEVICE_INFO_QUEUE_ON_DEVICE_PROPERTIES,
97-
sizeof(deviceQueueCapabilities),
98-
&deviceQueueCapabilities, nullptr));
99-
if (!deviceQueueCapabilities) {
100-
GTEST_SKIP() << "Queue on device is not supported.";
101-
}
102-
ASSERT_SUCCESS(
103-
urQueueCreate(context, device, &queueProperties, &queue));
104-
}
54+
TEST_P(urQueueGetInfoTest, ReferenceCount) {
55+
size_t size = 0;
56+
auto infoType = UR_QUEUE_INFO_REFERENCE_COUNT;
57+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
58+
ASSERT_NE(size, 0);
59+
ASSERT_EQ(sizeof(uint32_t), size);
10560

106-
void TearDown() {
107-
if (queue) {
108-
ASSERT_SUCCESS(urQueueRelease(queue));
109-
}
110-
urContextTestWithParam<ur_queue_info_t>::TearDown();
111-
}
61+
std::vector<uint8_t> data(size);
62+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
11263

113-
ur_queue_handle_t queue = nullptr;
114-
ur_queue_properties_t queueProperties = {
115-
UR_STRUCTURE_TYPE_QUEUE_PROPERTIES, nullptr,
116-
UR_QUEUE_FLAG_ON_DEVICE | UR_QUEUE_FLAG_ON_DEVICE_DEFAULT |
117-
UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE};
118-
};
64+
auto returned_reference_count = reinterpret_cast<uint32_t *>(data.data());
65+
ASSERT_GT(*returned_reference_count, 0U);
66+
}
11967

120-
using urQueueGetInfoTest = uur::urQueueTest;
121-
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urQueueGetInfoTest);
68+
TEST_P(urQueueGetInfoTest, EmptyQueue) {
69+
size_t size = 0;
70+
auto infoType = UR_QUEUE_INFO_EMPTY;
71+
UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
72+
urQueueGetInfo(queue, infoType, 0, nullptr, &size));
73+
ASSERT_NE(size, 0);
74+
ASSERT_EQ(sizeof(ur_bool_t), size);
75+
76+
std::vector<uint8_t> data(size);
77+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
78+
79+
auto returned_empty_queue = reinterpret_cast<ur_bool_t *>(data.data());
80+
ASSERT_TRUE(returned_empty_queue);
81+
}
12282

12383
TEST_P(urQueueGetInfoTest, InvalidNullHandleQueue) {
12484
ur_context_handle_t context = nullptr;
@@ -163,3 +123,64 @@ TEST_P(urQueueGetInfoTest, InvalidNullPointerPropSizeRet) {
163123
UR_RESULT_ERROR_INVALID_NULL_POINTER,
164124
urQueueGetInfo(queue, UR_QUEUE_INFO_CONTEXT, 0, nullptr, nullptr));
165125
}
126+
127+
struct urQueueGetInfoDeviceQueueTestWithInfoParam : public uur::urQueueTest {
128+
void SetUp() {
129+
urQueueGetInfoTest::SetUp();
130+
ur_queue_flags_t deviceQueueCapabilities;
131+
ASSERT_SUCCESS(
132+
urDeviceGetInfo(device, UR_DEVICE_INFO_QUEUE_ON_DEVICE_PROPERTIES,
133+
sizeof(deviceQueueCapabilities),
134+
&deviceQueueCapabilities, nullptr));
135+
if (!deviceQueueCapabilities) {
136+
GTEST_SKIP() << "Queue on device is not supported.";
137+
}
138+
ASSERT_SUCCESS(
139+
urQueueCreate(context, device, &queueProperties, &queue));
140+
}
141+
142+
void TearDown() {
143+
if (queue) {
144+
ASSERT_SUCCESS(urQueueRelease(queue));
145+
}
146+
urQueueGetInfoTest::TearDown();
147+
}
148+
149+
ur_queue_handle_t queue = nullptr;
150+
ur_queue_properties_t queueProperties = {
151+
UR_STRUCTURE_TYPE_QUEUE_PROPERTIES, nullptr,
152+
UR_QUEUE_FLAG_ON_DEVICE | UR_QUEUE_FLAG_ON_DEVICE_DEFAULT |
153+
UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE};
154+
};
155+
156+
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urQueueGetInfoDeviceQueueTestWithInfoParam);
157+
158+
TEST_P(urQueueGetInfoDeviceQueueTestWithInfoParam, DeviceDefault) {
159+
160+
size_t size = 0;
161+
auto infoType = UR_QUEUE_INFO_DEVICE_DEFAULT;
162+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
163+
ASSERT_NE(size, 0);
164+
ASSERT_EQ(sizeof(ur_queue_handle_t), size);
165+
166+
std::vector<uint8_t> data(size);
167+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
168+
169+
auto returned_queue = reinterpret_cast<ur_queue_handle_t *>(data.data());
170+
ASSERT_EQ(queue, *returned_queue);
171+
}
172+
173+
TEST_P(urQueueGetInfoDeviceQueueTestWithInfoParam, Size) {
174+
175+
size_t size = 0;
176+
auto infoType = UR_QUEUE_INFO_SIZE;
177+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, 0, nullptr, &size));
178+
ASSERT_NE(size, 0);
179+
ASSERT_EQ(sizeof(uint32_t), size);
180+
181+
std::vector<uint8_t> data(size);
182+
ASSERT_SUCCESS(urQueueGetInfo(queue, infoType, size, data.data(), nullptr));
183+
184+
auto returned_size = reinterpret_cast<uint32_t *>(data.data());
185+
ASSERT_GT(*returned_size, 0);
186+
}

0 commit comments

Comments
 (0)