Skip to content

Commit 0cceea4

Browse files
martygrantmartygrant
committed
Move urUSMGetMemAlloc/PoolGetInfo success test from a switch to individual tests.
1 parent 1918293 commit 0cceea4

5 files changed

+103
-100
lines changed

‎test/conformance/usm/urUSMGetMemAllocInfo.cpp

Lines changed: 74 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55

66
#include <uur/fixtures.h>
77

8-
struct urUSMGetMemAllocInfoTest
8+
struct urUSMGetMemAllocInfoPoolTest
99
: uur::urUSMDeviceAllocTestWithParam<ur_usm_alloc_info_t> {
1010
void SetUp() override {
1111
use_pool = getParam() == UR_USM_ALLOC_INFO_POOL;
@@ -14,100 +14,108 @@ struct urUSMGetMemAllocInfoTest
1414
}
1515
};
1616

17-
UUR_TEST_SUITE_P(urUSMGetMemAllocInfoTest,
18-
::testing::Values(UR_USM_ALLOC_INFO_TYPE,
19-
UR_USM_ALLOC_INFO_BASE_PTR,
20-
UR_USM_ALLOC_INFO_SIZE,
21-
UR_USM_ALLOC_INFO_DEVICE,
22-
UR_USM_ALLOC_INFO_POOL),
17+
UUR_TEST_SUITE_P(urUSMGetMemAllocInfoPoolTest,
18+
testing::Values(UR_USM_ALLOC_INFO_POOL),
2319
uur::deviceTestWithParamPrinter<ur_usm_alloc_info_t>);
2420

25-
static std::unordered_map<ur_usm_alloc_info_t, size_t> usm_info_size_map = {
26-
{UR_USM_ALLOC_INFO_TYPE, sizeof(ur_usm_type_t)},
27-
{UR_USM_ALLOC_INFO_BASE_PTR, sizeof(void *)},
28-
{UR_USM_ALLOC_INFO_SIZE, sizeof(size_t)},
29-
{UR_USM_ALLOC_INFO_DEVICE, sizeof(ur_device_handle_t)},
30-
{UR_USM_ALLOC_INFO_POOL, sizeof(ur_usm_pool_handle_t)},
31-
};
21+
TEST_P(urUSMGetMemAllocInfoPoolTest, SuccessPool) {
22+
size_t size = 0;
23+
auto info_type = UR_USM_ALLOC_INFO_POOL;
24+
ASSERT_SUCCESS(
25+
urUSMGetMemAllocInfo(context, ptr, info_type, 0, nullptr, &size));
26+
ASSERT_EQ(sizeof(ur_usm_pool_handle_t), size);
3227

33-
TEST_P(urUSMGetMemAllocInfoTest, Success) {
28+
ur_usm_pool_handle_t returned_pool = nullptr;
29+
ASSERT_SUCCESS(urUSMGetMemAllocInfo(context, ptr, info_type, size,
30+
&returned_pool, nullptr));
31+
32+
ASSERT_EQ(returned_pool, pool);
33+
}
34+
35+
using urUSMGetMemAllocInfoTest = uur::urUSMDeviceAllocTest;
36+
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urUSMGetMemAllocInfoTest);
37+
38+
TEST_P(urUSMGetMemAllocInfoTest, SuccessType) {
3439
size_t size = 0;
35-
auto alloc_info = getParam();
36-
ASSERT_SUCCESS_OR_OPTIONAL_QUERY(
37-
urUSMGetMemAllocInfo(context, ptr, alloc_info, 0, nullptr, &size),
38-
alloc_info);
39-
ASSERT_NE(size, 0);
40-
41-
if (const auto expected_size = usm_info_size_map.find(alloc_info);
42-
expected_size != usm_info_size_map.end()) {
43-
ASSERT_EQ(expected_size->second, size);
44-
}
40+
auto info_type = UR_USM_ALLOC_INFO_TYPE;
41+
ASSERT_SUCCESS(
42+
urUSMGetMemAllocInfo(context, ptr, info_type, 0, nullptr, &size));
43+
ASSERT_EQ(sizeof(ur_usm_type_t), size);
4544

46-
std::vector<uint8_t> info_data(size);
47-
ASSERT_SUCCESS(urUSMGetMemAllocInfo(context, ptr, alloc_info, size,
48-
info_data.data(), nullptr));
49-
switch (alloc_info) {
50-
case UR_USM_ALLOC_INFO_DEVICE: {
51-
auto returned_device =
52-
reinterpret_cast<ur_device_handle_t *>(info_data.data());
53-
ASSERT_EQ(*returned_device, device);
54-
break;
55-
}
56-
case UR_USM_ALLOC_INFO_SIZE: {
57-
auto returned_size = reinterpret_cast<size_t *>(info_data.data());
58-
ASSERT_GE(*returned_size, allocation_size);
59-
break;
60-
}
61-
case UR_USM_ALLOC_INFO_BASE_PTR: {
62-
auto returned_ptr = reinterpret_cast<void **>(info_data.data());
63-
ASSERT_EQ(*returned_ptr, ptr);
64-
break;
65-
}
66-
case UR_USM_ALLOC_INFO_POOL: {
67-
auto returned_pool =
68-
reinterpret_cast<ur_usm_pool_handle_t *>(info_data.data());
69-
ASSERT_EQ(*returned_pool, pool);
70-
break;
71-
}
72-
case UR_USM_ALLOC_INFO_TYPE: {
73-
auto returned_type =
74-
reinterpret_cast<ur_usm_type_t *>(info_data.data());
75-
ASSERT_EQ(*returned_type, UR_USM_TYPE_DEVICE);
76-
break;
77-
}
78-
default:
79-
break;
80-
}
45+
ur_usm_type_t returned_type = UR_USM_TYPE_FORCE_UINT32;
46+
ASSERT_SUCCESS(urUSMGetMemAllocInfo(context, ptr, info_type, size,
47+
&returned_type, nullptr));
48+
49+
ASSERT_EQ(returned_type, UR_USM_TYPE_DEVICE);
8150
}
8251

83-
using urUSMGetMemAllocInfoNegativeTest = uur::urUSMDeviceAllocTest;
84-
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urUSMGetMemAllocInfoNegativeTest);
52+
TEST_P(urUSMGetMemAllocInfoTest, SuccessBasePtr) {
53+
size_t size = 0;
54+
auto info_type = UR_USM_ALLOC_INFO_BASE_PTR;
55+
ASSERT_SUCCESS(
56+
urUSMGetMemAllocInfo(context, ptr, info_type, 0, nullptr, &size));
57+
ASSERT_GT(size, 0);
58+
59+
void *returned_ptr = nullptr;
60+
ASSERT_SUCCESS(urUSMGetMemAllocInfo(context, ptr, info_type, size,
61+
&returned_ptr, nullptr));
62+
63+
ASSERT_NE(returned_ptr, ptr);
64+
}
65+
66+
TEST_P(urUSMGetMemAllocInfoTest, SuccessSize) {
67+
size_t size = 0;
68+
auto info_type = UR_USM_ALLOC_INFO_SIZE;
69+
ASSERT_SUCCESS(
70+
urUSMGetMemAllocInfo(context, ptr, info_type, 0, nullptr, &size));
71+
ASSERT_EQ(sizeof(size_t), size);
72+
73+
size_t returned_size = 0;
74+
ASSERT_SUCCESS(urUSMGetMemAllocInfo(context, ptr, info_type, size,
75+
&returned_size, nullptr));
76+
77+
ASSERT_EQ(returned_size, allocation_size);
78+
}
79+
80+
TEST_P(urUSMGetMemAllocInfoTest, SuccessDevice) {
81+
size_t size = 0;
82+
auto info_type = UR_USM_ALLOC_INFO_DEVICE;
83+
ASSERT_SUCCESS(
84+
urUSMGetMemAllocInfo(context, ptr, info_type, 0, nullptr, &size));
85+
ASSERT_EQ(sizeof(ur_device_handle_t), size);
86+
87+
ur_device_handle_t returned_device = nullptr;
88+
ASSERT_SUCCESS(urUSMGetMemAllocInfo(context, ptr, info_type, size,
89+
&returned_device, nullptr));
90+
91+
ASSERT_EQ(returned_device, device);
92+
}
8593

86-
TEST_P(urUSMGetMemAllocInfoNegativeTest, InvalidNullHandleContext) {
94+
TEST_P(urUSMGetMemAllocInfoTest, InvalidNullHandleContext) {
8795
ur_usm_type_t USMType;
8896
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
8997
urUSMGetMemAllocInfo(nullptr, ptr, UR_USM_ALLOC_INFO_TYPE,
9098
sizeof(ur_usm_type_t), &USMType,
9199
nullptr));
92100
}
93101

94-
TEST_P(urUSMGetMemAllocInfoNegativeTest, InvalidNullPointerMem) {
102+
TEST_P(urUSMGetMemAllocInfoTest, InvalidNullPointerMem) {
95103
ur_usm_type_t USMType;
96104
ASSERT_EQ_RESULT(
97105
UR_RESULT_ERROR_INVALID_NULL_POINTER,
98106
urUSMGetMemAllocInfo(context, nullptr, UR_USM_ALLOC_INFO_TYPE,
99107
sizeof(ur_usm_type_t), &USMType, nullptr));
100108
}
101109

102-
TEST_P(urUSMGetMemAllocInfoNegativeTest, InvalidEnumeration) {
110+
TEST_P(urUSMGetMemAllocInfoTest, InvalidEnumeration) {
103111
ur_usm_type_t USMType;
104112
ASSERT_EQ_RESULT(
105113
UR_RESULT_ERROR_INVALID_ENUMERATION,
106114
urUSMGetMemAllocInfo(context, ptr, UR_USM_ALLOC_INFO_FORCE_UINT32,
107115
sizeof(ur_usm_type_t), &USMType, nullptr));
108116
}
109117

110-
TEST_P(urUSMGetMemAllocInfoNegativeTest, InvalidValuePropSize) {
118+
TEST_P(urUSMGetMemAllocInfoTest, InvalidValuePropSize) {
111119
ur_usm_type_t USMType;
112120
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE,
113121
urUSMGetMemAllocInfo(context, ptr, UR_USM_ALLOC_INFO_TYPE,

‎test/conformance/usm/urUSMPoolGetInfo.cpp

Lines changed: 21 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -3,41 +3,36 @@
33
// See LICENSE.TXT
44
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
55
#include "ur_api.h"
6-
#include <map>
76
#include <uur/fixtures.h>
87

9-
std::unordered_map<ur_usm_pool_info_t, size_t> pool_info_size_map = {
10-
{UR_USM_POOL_INFO_CONTEXT, sizeof(ur_context_handle_t)},
11-
{UR_USM_POOL_INFO_REFERENCE_COUNT, sizeof(uint32_t)},
12-
};
8+
using urUSMPoolGetInfoTest = uur::urUSMPoolTest;
9+
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urUSMPoolGetInfoTest);
1310

14-
using urUSMPoolGetInfoTestWithInfoParam =
15-
uur::urUSMPoolTestWithParam<ur_usm_pool_info_t>;
11+
TEST_P(urUSMPoolGetInfoTest, SuccessReferenceCount) {
12+
size_t size = 0;
13+
auto infoType = UR_USM_POOL_INFO_REFERENCE_COUNT;
14+
ASSERT_SUCCESS(urUSMPoolGetInfo(pool, infoType, 0, nullptr, &size));
15+
ASSERT_EQ(sizeof(uint32_t), size);
1616

17-
UUR_TEST_SUITE_P(urUSMPoolGetInfoTestWithInfoParam,
18-
::testing::Values(UR_USM_POOL_INFO_CONTEXT,
19-
UR_USM_POOL_INFO_REFERENCE_COUNT),
20-
uur::deviceTestWithParamPrinter<ur_usm_pool_info_t>);
17+
ur_context_handle_t returned_context = nullptr;
18+
ASSERT_SUCCESS(
19+
urUSMPoolGetInfo(pool, infoType, size, &returned_context, nullptr));
2120

22-
TEST_P(urUSMPoolGetInfoTestWithInfoParam, Success) {
23-
ur_usm_pool_info_t info_type = getParam();
24-
size_t size = 0;
25-
ASSERT_SUCCESS_OR_OPTIONAL_QUERY(
26-
urUSMPoolGetInfo(pool, info_type, 0, nullptr, &size), info_type);
27-
ASSERT_NE(size, 0);
21+
ASSERT_EQ(context, returned_context);
22+
}
2823

29-
if (const auto expected_size = pool_info_size_map.find(info_type);
30-
expected_size != pool_info_size_map.end()) {
31-
ASSERT_EQ(expected_size->second, size);
32-
}
24+
TEST_P(urUSMPoolGetInfoTest, SuccessContext) {
25+
size_t size = 0;
26+
auto infoType = UR_USM_POOL_INFO_CONTEXT;
27+
ASSERT_SUCCESS(urUSMPoolGetInfo(pool, infoType, 0, nullptr, &size));
28+
ASSERT_EQ(sizeof(ur_context_handle_t), size);
3329

34-
std::vector<uint8_t> data(size);
30+
ur_context_handle_t returned_context = nullptr;
3531
ASSERT_SUCCESS(
36-
urUSMPoolGetInfo(pool, info_type, size, data.data(), nullptr));
37-
}
32+
urUSMPoolGetInfo(pool, infoType, size, &returned_context, nullptr));
3833

39-
using urUSMPoolGetInfoTest = uur::urUSMPoolTest;
40-
UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urUSMPoolGetInfoTest);
34+
ASSERT_EQ(context, returned_context);
35+
}
4136

4237
TEST_P(urUSMPoolGetInfoTest, InvalidNullHandlePool) {
4338
ur_context_handle_t context = nullptr;

‎test/conformance/usm/usm_adapter_hip.match

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,7 @@ urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/*__UsePoolEnabled_32_204
2121
urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/*__UsePoolEnabled_64_8
2222
urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/*__UsePoolEnabled_64_512
2323
urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/*__UsePoolEnabled_64_2048
24-
urUSMGetMemAllocInfoTest.Success/*__UR_USM_ALLOC_INFO_POOL
24+
urUSMGetMemAllocInfoPoolTest.SuccessPool/*
2525
urUSMHostAllocTest.Success/*__UsePoolEnabled
2626
urUSMHostAllocTest.SuccessWithDescriptors/*__UsePoolEnabled
2727
urUSMHostAllocTest.InvalidNullHandleContext/*__UsePoolEnabled
@@ -46,8 +46,8 @@ urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/*__UsePoolEnabled_64_512
4646
urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/*__UsePoolEnabled_64_2048
4747
urUSMPoolCreateTest.Success/*
4848
urUSMPoolCreateTest.SuccessWithFlag/*
49-
urUSMPoolGetInfoTestWithInfoParam.Success/*__UR_USM_POOL_INFO_CONTEXT
50-
urUSMPoolGetInfoTestWithInfoParam.Success/*__UR_USM_POOL_INFO_REFERENCE_COUNT
49+
urUSMPoolGetInfoTest.SuccessContext/*
50+
urUSMPoolGetInfoTest.SuccessReferenceCount/*
5151
urUSMPoolGetInfoTest.InvalidNullHandlePool/*
5252
urUSMPoolGetInfoTest.InvalidEnumerationProperty/*
5353
urUSMPoolGetInfoTest.InvalidSizeZero/*

‎test/conformance/usm/usm_adapter_level_zero_v2.match

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1 +1 @@
1-
urUSMGetMemAllocInfoTest.Success/*___UR_USM_ALLOC_INFO_POOL
1+
urUSMGetMemAllocInfoPoolTest.SuccessPool/*

‎test/conformance/usm/usm_adapter_native_cpu.match

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -4,10 +4,10 @@ urUSMFreeTest.SuccessDeviceAlloc/*
44
urUSMFreeTest.SuccessHostAlloc/*
55
urUSMFreeTest.SuccessSharedAlloc/*
66
urUSMFreeDuringExecutionTest.*
7-
urUSMGetMemAllocInfoTest.Success/*__UR_USM_ALLOC_INFO_TYPE
8-
urUSMGetMemAllocInfoTest.Success/*__UR_USM_ALLOC_INFO_BASE_PTR
9-
urUSMGetMemAllocInfoTest.Success/*__UR_USM_ALLOC_INFO_SIZE
10-
urUSMGetMemAllocInfoTest.Success/*__UR_USM_ALLOC_INFO_DEVICE
7+
urUSMPoolGetInfoTest.SuccessType/*
8+
urUSMPoolGetInfoTest.SuccessBasePtr/*
9+
urUSMPoolGetInfoTest.SuccessSize/*
10+
urUSMPoolGetInfoTest.SuccessDevice/*
1111
urUSMGetMemAllocInfoNegativeTest.InvalidNullHandleContext/*
1212
urUSMGetMemAllocInfoNegativeTest.InvalidNullPointerMem/*
1313
urUSMGetMemAllocInfoNegativeTest.InvalidEnumeration/*

0 commit comments

Comments
 (0)