Skip to content

Commit 9c652ff

Browse files
martygrantmartygrant
authored
Merge pull request intel#2521 from martygrant/martin/memory-info-unswitch
Move urMemoryGetInfo success test from a switch to individual tests
2 parents 4e834af + 2ce90d3 commit 9c652ff

File tree

8 files changed

+178
-223
lines changed

8 files changed

+178
-223
lines changed

‎test/conformance/adapter/urAdapterGetInfo.cpp

+24-31
Original file line numberDiff line numberDiff line change
@@ -11,25 +11,24 @@ using urAdapterGetInfoTest = uur::urAdapterTest;
1111

1212
UUR_INSTANTIATE_ADAPTER_TEST_SUITE_P(urAdapterGetInfoTest);
1313

14-
TEST_P(urAdapterGetInfoTest, Backend) {
14+
TEST_P(urAdapterGetInfoTest, SuccessBackend) {
1515
auto info_type = UR_ADAPTER_INFO_BACKEND;
1616
size_t size = 0;
17-
ASSERT_SUCCESS_OR_OPTIONAL_QUERY(
18-
urAdapterGetInfo(adapter, info_type, 0, nullptr, &size), info_type);
19-
ASSERT_NE(size, 0);
20-
17+
ASSERT_SUCCESS(urAdapterGetInfo(adapter, info_type, 0, nullptr, &size));
2118
ASSERT_EQ(size, sizeof(ur_adapter_backend_t));
2219

23-
std::vector<char> info_data(size);
20+
ur_adapter_backend_t backend = UR_ADAPTER_BACKEND_UNKNOWN;
2421
ASSERT_SUCCESS(
25-
urAdapterGetInfo(adapter, info_type, size, info_data.data(), nullptr));
22+
urAdapterGetInfo(adapter, info_type, size, &backend, nullptr));
23+
24+
ASSERT_TRUE(backend >= UR_ADAPTER_BACKEND_LEVEL_ZERO &&
25+
backend <= UR_ADAPTER_BACKEND_NATIVE_CPU);
2626
}
2727

28-
TEST_P(urAdapterGetInfoTest, ReferenceCount) {
28+
TEST_P(urAdapterGetInfoTest, SuccessReferenceCount) {
2929
auto info_type = UR_ADAPTER_INFO_REFERENCE_COUNT;
3030
size_t size = 0;
31-
ASSERT_SUCCESS_OR_OPTIONAL_QUERY(
32-
urAdapterGetInfo(adapter, info_type, 0, nullptr, &size), info_type);
31+
ASSERT_SUCCESS(urAdapterGetInfo(adapter, info_type, 0, nullptr, &size));
3332
ASSERT_EQ(size, sizeof(uint32_t));
3433

3534
uint32_t reference_count = 0;
@@ -38,6 +37,18 @@ TEST_P(urAdapterGetInfoTest, ReferenceCount) {
3837
ASSERT_GE(reference_count, 0);
3938
}
4039

40+
TEST_P(urAdapterGetInfoTest, SuccessVersion) {
41+
auto info_type = UR_ADAPTER_INFO_VERSION;
42+
size_t size = 0;
43+
ASSERT_SUCCESS(urAdapterGetInfo(adapter, info_type, 0, nullptr, &size));
44+
ASSERT_EQ(size, sizeof(uint32_t));
45+
46+
uint32_t returned_version = 46;
47+
ASSERT_SUCCESS(
48+
urAdapterGetInfo(adapter, info_type, size, &returned_version, nullptr));
49+
ASSERT_NE(42, returned_version);
50+
}
51+
4152
TEST_P(urAdapterGetInfoTest, InvalidNullHandleAdapter) {
4253
size_t size = 0;
4354
ASSERT_EQ_RESULT(
@@ -53,21 +64,21 @@ TEST_P(urAdapterGetInfoTest, InvalidEnumerationAdapterInfoType) {
5364
}
5465

5566
TEST_P(urAdapterGetInfoTest, InvalidSizeZero) {
56-
ur_adapter_backend_t backend;
67+
ur_adapter_backend_t backend = UR_ADAPTER_BACKEND_UNKNOWN;
5768
ASSERT_EQ_RESULT(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_BACKEND, 0,
5869
&backend, nullptr),
5970
UR_RESULT_ERROR_INVALID_SIZE);
6071
}
6172

6273
TEST_P(urAdapterGetInfoTest, InvalidSizeSmall) {
63-
ur_adapter_backend_t backend;
74+
ur_adapter_backend_t backend = UR_ADAPTER_BACKEND_UNKNOWN;
6475
ASSERT_EQ_RESULT(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_BACKEND,
6576
sizeof(backend) - 1, &backend, nullptr),
6677
UR_RESULT_ERROR_INVALID_SIZE);
6778
}
6879

6980
TEST_P(urAdapterGetInfoTest, InvalidNullPointerPropValue) {
70-
ur_adapter_backend_t backend;
81+
ur_adapter_backend_t backend = UR_ADAPTER_BACKEND_UNKNOWN;
7182
ASSERT_EQ_RESULT(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_BACKEND,
7283
sizeof(backend), nullptr, nullptr),
7384
UR_RESULT_ERROR_INVALID_NULL_POINTER);
@@ -78,21 +89,3 @@ TEST_P(urAdapterGetInfoTest, InvalidNullPointerPropSizeRet) {
7889
urAdapterGetInfo(adapter, UR_ADAPTER_INFO_BACKEND, 0, nullptr, nullptr),
7990
UR_RESULT_ERROR_INVALID_NULL_POINTER);
8091
}
81-
82-
TEST_P(urAdapterGetInfoTest, ReferenceCountNotZero) {
83-
uint32_t referenceCount = 0;
84-
85-
ASSERT_SUCCESS(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_REFERENCE_COUNT,
86-
sizeof(referenceCount), &referenceCount,
87-
nullptr));
88-
ASSERT_GT(referenceCount, 0);
89-
}
90-
91-
TEST_P(urAdapterGetInfoTest, ValidAdapterBackend) {
92-
ur_adapter_backend_t backend;
93-
ASSERT_SUCCESS(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_BACKEND,
94-
sizeof(backend), &backend, nullptr));
95-
96-
ASSERT_TRUE(backend >= UR_ADAPTER_BACKEND_LEVEL_ZERO &&
97-
backend <= UR_ADAPTER_BACKEND_NATIVE_CPU);
98-
}

‎test/conformance/event/urEventGetInfo.cpp

+8-8
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ TEST_P(urEventGetInfoTest, SuccessCommandQueue) {
1414
ASSERT_SUCCESS(urEventGetInfo(event, info_type, 0, nullptr, &size));
1515
ASSERT_EQ(size, sizeof(ur_queue_handle_t));
1616

17-
ur_queue_handle_t returned_queue;
17+
ur_queue_handle_t returned_queue = nullptr;
1818
ASSERT_SUCCESS(
1919
urEventGetInfo(event, info_type, size, &returned_queue, nullptr));
2020

@@ -28,7 +28,7 @@ TEST_P(urEventGetInfoTest, SuccessContext) {
2828
ASSERT_SUCCESS(urEventGetInfo(event, info_type, 0, nullptr, &size));
2929
ASSERT_EQ(size, sizeof(ur_context_handle_t));
3030

31-
ur_context_handle_t returned_context;
31+
ur_context_handle_t returned_context = nullptr;
3232
ASSERT_SUCCESS(
3333
urEventGetInfo(event, info_type, size, &returned_context, nullptr));
3434

@@ -42,7 +42,7 @@ TEST_P(urEventGetInfoTest, SuccessCommandType) {
4242
ASSERT_SUCCESS(urEventGetInfo(event, info_type, 0, nullptr, &size));
4343
ASSERT_EQ(size, sizeof(ur_command_t));
4444

45-
ur_command_t returned_command_type;
45+
ur_command_t returned_command_type = UR_COMMAND_FORCE_UINT32;
4646
ASSERT_SUCCESS(urEventGetInfo(event, info_type, size,
4747
&returned_command_type, nullptr));
4848

@@ -56,7 +56,7 @@ TEST_P(urEventGetInfoTest, SuccessCommandExecutionStatus) {
5656
ASSERT_SUCCESS(urEventGetInfo(event, info_type, 0, nullptr, &size));
5757
ASSERT_EQ(size, sizeof(ur_event_status_t));
5858

59-
ur_event_status_t returned_status;
59+
ur_event_status_t returned_status = UR_EVENT_STATUS_FORCE_UINT32;
6060
ASSERT_SUCCESS(
6161
urEventGetInfo(event, info_type, size, &returned_status, nullptr));
6262

@@ -70,7 +70,7 @@ TEST_P(urEventGetInfoTest, SuccessReferenceCount) {
7070
ASSERT_SUCCESS(urEventGetInfo(event, info_type, 0, nullptr, &size));
7171
ASSERT_EQ(size, sizeof(uint32_t));
7272

73-
uint32_t returned_reference_count;
73+
uint32_t returned_reference_count = 0;
7474
ASSERT_SUCCESS(urEventGetInfo(event, info_type, size,
7575
&returned_reference_count, nullptr));
7676

@@ -91,7 +91,7 @@ TEST_P(urEventGetInfoTest, InvalidNullHandle) {
9191
}
9292

9393
TEST_P(urEventGetInfoTest, InvalidEnumeration) {
94-
size_t size;
94+
size_t size = 0;
9595
ASSERT_EQ_RESULT(
9696
urEventGetInfo(event, UR_EVENT_INFO_FORCE_UINT32, 0, nullptr, &size),
9797
UR_RESULT_ERROR_INVALID_ENUMERATION);
@@ -111,9 +111,9 @@ TEST_P(urEventGetInfoTest, InvalidSizePropSize) {
111111
}
112112

113113
TEST_P(urEventGetInfoTest, InvalidSizePropSizeSmall) {
114-
ur_queue_handle_t q;
114+
ur_queue_handle_t queue = nullptr;
115115
ASSERT_EQ_RESULT(urEventGetInfo(event, UR_EVENT_INFO_COMMAND_QUEUE,
116-
sizeof(q) - 1, &q, nullptr),
116+
sizeof(queue) - 1, &queue, nullptr),
117117
UR_RESULT_ERROR_INVALID_SIZE);
118118
}
119119

‎test/conformance/memory/memory_adapter_level_zero.match

+1-1
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ urMemBufferPartitionWithFlagsTest.Success/*__UR_MEM_FLAG_READ_ONLY
44
urMemBufferPartitionTest.InvalidValueCreateType/*
55
urMemBufferPartitionTest.InvalidValueBufferCreateInfoOutOfBounds/*
66
{{OPT}}urMemImageCreateWithNativeHandleTest.Success/*
7-
{{OPT}}urMemGetInfoImageTest.Success/*__UR_MEM_INFO_SIZE
7+
{{OPT}}urMemGetInfoImageTest.SuccessSize/*
88
{{OPT}}urMemImageCreateTestWithImageFormatParam.Success/*__UR_IMAGE_CHANNEL_ORDER_RGBA__*
99

1010
# These tests fail in the "Multi device testing" job, but pass in the hardware specific test

‎test/conformance/memory/memory_adapter_native_cpu.match

+3-1
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,9 @@ urMemBufferPartitionWithFlagsTest.Success/*__UR_MEM_FLAG_WRITE_ONLY
22
urMemBufferPartitionWithFlagsTest.Success/*__UR_MEM_FLAG_READ_ONLY
33
urMemBufferPartitionTest.InvalidValueCreateType/*
44
urMemBufferPartitionTest.InvalidValueBufferCreateInfoOutOfBounds/*
5-
urMemGetInfoTestWithParam.Success/*
5+
urMemGetInfoTest.SuccessSize/*
6+
urMemGetInfoTest.SuccessContext/*
7+
urMemGetInfoTest.SuccessReferenceCount/*
68
urMemGetInfoTest.InvalidSizeSmall/*
79
urMemReleaseTest.Success/*
810
urMemReleaseTest.CheckReferenceCount/*

‎test/conformance/memory/urMemGetInfo.cpp

+90-96
Original file line numberDiff line numberDiff line change
@@ -6,61 +6,51 @@
66
#include <map>
77
#include <uur/fixtures.h>
88

9-
using urMemGetInfoTestWithParam = uur::urMemBufferTestWithParam<ur_mem_info_t>;
10-
11-
static constexpr std::array<ur_mem_info_t, 3> mem_info_values{
12-
UR_MEM_INFO_SIZE, UR_MEM_INFO_CONTEXT, UR_MEM_INFO_REFERENCE_COUNT};
13-
static std::unordered_map<ur_mem_info_t, size_t> mem_info_size_map = {
14-
{UR_MEM_INFO_SIZE, sizeof(size_t)},
15-
{UR_MEM_INFO_CONTEXT, sizeof(ur_context_handle_t)},
16-
{UR_MEM_INFO_REFERENCE_COUNT, sizeof(uint32_t)},
17-
};
18-
19-
UUR_TEST_SUITE_P(urMemGetInfoTestWithParam,
20-
::testing::ValuesIn(mem_info_values),
21-
uur::deviceTestWithParamPrinter<ur_mem_info_t>);
22-
23-
TEST_P(urMemGetInfoTestWithParam, Success) {
24-
ur_mem_info_t info = getParam();
25-
size_t size;
26-
ASSERT_SUCCESS_OR_OPTIONAL_QUERY(
27-
urMemGetInfo(buffer, info, 0, nullptr, &size), info);
28-
ASSERT_NE(size, 0);
29-
30-
if (const auto expected_size = mem_info_size_map.find(info);
31-
expected_size != mem_info_size_map.end()) {
32-
ASSERT_EQ(expected_size->second, size);
33-
}
34-
35-
std::vector<uint8_t> info_data(size);
36-
ASSERT_SUCCESS(urMemGetInfo(buffer, info, size, info_data.data(), nullptr));
37-
38-
switch (info) {
39-
case UR_MEM_INFO_CONTEXT: {
40-
auto returned_context =
41-
reinterpret_cast<ur_context_handle_t *>(info_data.data());
42-
ASSERT_EQ(context, *returned_context);
43-
break;
44-
}
45-
case UR_MEM_INFO_SIZE: {
46-
auto returned_size = reinterpret_cast<size_t *>(info_data.data());
47-
ASSERT_GE(*returned_size, allocation_size);
48-
break;
49-
}
50-
case UR_MEM_INFO_REFERENCE_COUNT: {
51-
const size_t ReferenceCount =
52-
*reinterpret_cast<const uint32_t *>(info_data.data());
53-
ASSERT_GT(ReferenceCount, 0);
54-
break;
55-
}
56-
default:
57-
break;
58-
}
59-
}
60-
619
using urMemGetInfoTest = uur::urMemBufferTest;
6210
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urMemGetInfoTest);
6311

12+
TEST_P(urMemGetInfoTest, SuccessSize) {
13+
ur_mem_info_t info_type = UR_MEM_INFO_SIZE;
14+
size_t size = 0;
15+
16+
ASSERT_SUCCESS(urMemGetInfo(buffer, info_type, 0, nullptr, &size));
17+
ASSERT_EQ(size, sizeof(size_t));
18+
19+
size_t returned_size = 0;
20+
ASSERT_SUCCESS(
21+
urMemGetInfo(buffer, info_type, size, &returned_size, nullptr));
22+
23+
ASSERT_GE(returned_size, allocation_size);
24+
}
25+
26+
TEST_P(urMemGetInfoTest, SuccessContext) {
27+
ur_mem_info_t info_type = UR_MEM_INFO_CONTEXT;
28+
size_t size = 0;
29+
30+
ASSERT_SUCCESS(urMemGetInfo(buffer, info_type, 0, nullptr, &size));
31+
ASSERT_EQ(size, sizeof(ur_context_handle_t));
32+
33+
ur_context_handle_t returned_context = nullptr;
34+
ASSERT_SUCCESS(
35+
urMemGetInfo(buffer, info_type, size, &returned_context, nullptr));
36+
37+
ASSERT_EQ(context, returned_context);
38+
}
39+
40+
TEST_P(urMemGetInfoTest, SuccessReferenceCount) {
41+
ur_mem_info_t info_type = UR_MEM_INFO_REFERENCE_COUNT;
42+
size_t size = 0;
43+
44+
ASSERT_SUCCESS(urMemGetInfo(buffer, info_type, 0, nullptr, &size));
45+
ASSERT_EQ(size, sizeof(uint32_t));
46+
47+
uint32_t returned_reference_count = 0;
48+
ASSERT_SUCCESS(urMemGetInfo(buffer, info_type, size,
49+
&returned_reference_count, nullptr));
50+
51+
ASSERT_GT(returned_reference_count, 0);
52+
}
53+
6454
TEST_P(urMemGetInfoTest, InvalidNullHandleMemory) {
6555
size_t mem_size = 0;
6656
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
@@ -102,48 +92,52 @@ TEST_P(urMemGetInfoTest, InvalidNullPointerPropSizeRet) {
10292
UR_RESULT_ERROR_INVALID_NULL_POINTER);
10393
}
10494

105-
using urMemGetInfoImageTest = uur::urMemImageTestWithParam<ur_mem_info_t>;
106-
UUR_TEST_SUITE_P(urMemGetInfoImageTest, ::testing::ValuesIn(mem_info_values),
107-
uur::deviceTestWithParamPrinter<ur_mem_info_t>);
108-
109-
TEST_P(urMemGetInfoImageTest, Success) {
110-
ur_mem_info_t info = getParam();
111-
size_t size;
112-
ASSERT_SUCCESS(urMemGetInfo(image, info, 0, nullptr, &size));
113-
ASSERT_NE(size, 0);
114-
115-
if (const auto expected_size = mem_info_size_map.find(info);
116-
expected_size != mem_info_size_map.end()) {
117-
ASSERT_EQ(expected_size->second, size);
118-
}
119-
120-
std::vector<uint8_t> info_data(size);
121-
ASSERT_SUCCESS(urMemGetInfo(image, info, size, info_data.data(), nullptr));
122-
123-
switch (info) {
124-
case UR_MEM_INFO_SIZE: {
125-
const size_t ExpectedPixelSize = sizeof(float) * 4 /*NumChannels*/;
126-
const size_t ExpectedImageSize = ExpectedPixelSize * desc.arraySize *
127-
desc.width * desc.height * desc.depth;
128-
const size_t ImageSizeBytes =
129-
*reinterpret_cast<const size_t *>(info_data.data());
130-
ASSERT_EQ(ImageSizeBytes, ExpectedImageSize);
131-
break;
132-
}
133-
case UR_MEM_INFO_CONTEXT: {
134-
ur_context_handle_t InfoContext =
135-
*reinterpret_cast<ur_context_handle_t *>(info_data.data());
136-
ASSERT_EQ(InfoContext, context);
137-
break;
138-
}
139-
case UR_MEM_INFO_REFERENCE_COUNT: {
140-
const size_t ReferenceCount =
141-
*reinterpret_cast<const uint32_t *>(info_data.data());
142-
ASSERT_GT(ReferenceCount, 0);
143-
break;
144-
}
145-
146-
default:
147-
break;
148-
}
95+
using urMemGetInfoImageTest = uur::urMemImageTest;
96+
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urMemGetInfoImageTest);
97+
98+
TEST_P(urMemGetInfoImageTest, SuccessSize) {
99+
ur_mem_info_t info_type = UR_MEM_INFO_SIZE;
100+
size_t size = 0;
101+
102+
ASSERT_SUCCESS(urMemGetInfo(image, info_type, 0, nullptr, &size));
103+
ASSERT_EQ(size, sizeof(size_t));
104+
105+
size_t image_size_bytes = 0;
106+
ASSERT_SUCCESS(
107+
urMemGetInfo(image, info_type, size, &image_size_bytes, nullptr));
108+
109+
const size_t expected_pixel_size = sizeof(uint8_t) * 4;
110+
const size_t expected_image_size = expected_pixel_size *
111+
image_desc.arraySize * image_desc.width *
112+
image_desc.height * image_desc.depth;
113+
114+
ASSERT_EQ(image_size_bytes, expected_image_size);
115+
}
116+
117+
TEST_P(urMemGetInfoImageTest, SuccessContext) {
118+
ur_mem_info_t info_type = UR_MEM_INFO_CONTEXT;
119+
size_t size = 0;
120+
121+
ASSERT_SUCCESS(urMemGetInfo(image, info_type, 0, nullptr, &size));
122+
ASSERT_EQ(size, sizeof(ur_context_handle_t));
123+
124+
ur_context_handle_t returned_context = nullptr;
125+
ASSERT_SUCCESS(
126+
urMemGetInfo(image, info_type, size, &returned_context, nullptr));
127+
128+
ASSERT_EQ(context, returned_context);
129+
}
130+
131+
TEST_P(urMemGetInfoImageTest, SuccessReferenceCount) {
132+
ur_mem_info_t info_type = UR_MEM_INFO_REFERENCE_COUNT;
133+
size_t size = 0;
134+
135+
ASSERT_SUCCESS(urMemGetInfo(image, info_type, 0, nullptr, &size));
136+
ASSERT_EQ(size, sizeof(uint32_t));
137+
138+
uint32_t returned_reference_count = 0;
139+
ASSERT_SUCCESS(urMemGetInfo(image, info_type, size,
140+
&returned_reference_count, nullptr));
141+
142+
ASSERT_GT(returned_reference_count, 0);
149143
}

0 commit comments

Comments
 (0)