[llvm] [offload] add parameterized unit tests (PR #209115)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Jul 17 19:54:07 PDT 2026
https://github.com/EuphoricThinking updated https://github.com/llvm/llvm-project/pull/209115
>From 1e1664a4bdec1595c5f3f1749ee28fe81ca918d9 Mon Sep 17 00:00:00 2001
From: Agata Momot <agata.momot at intel.com>
Date: Mon, 15 Jun 2026 08:37:30 -0700
Subject: [PATCH] [offload] add parameterized unit tests
Previously, liboffload tests were parametrized only with different
devices. The following changes enable creating tests with additional
parameters, besides devices. The existing tests, which often used
C-style macros instead of incorporating Google Test features,
are rewritten so that macros are replaced fully with Google Test
parametrized fixtures.
This patch adds:
- a new fixture that allows for creating parameterized tests
- new macros for the instantiation of parameterized tests
- a helper header file that contains information related to
parameterized tests, including the definition of parameters
- new and refactored printers used in test instantiation
Moreover, selected existing tests are modified and parametrized in order
to make the code less repetitive and more concise. Tests with up to two
possible parameters are not parameterized.
Previously, the tests were already parameterized with
`TestEnvironment::Device`. However, this patch combines
`TestEnvironment::Device` with an additional parameter within
`OffloadParam = std::tuple<TestEnvironment::Device, T>`.
`OffloadParam<T>` is handled by a new fixture
`OffloadDeviceTestWithParam<T>`, which provides the `getTestParam()`
method for the parameter extraction. Other functionalities, such as
access to the `Host` and to the `Device`, are identical to the previous
version of `OffloadDeviceTest`.
In order to avoid code duplication, the unparameterized versions of
fixtures are aliases for parameterized fixtures, with `int` type chosen
arbitrarily as an ignored parameter type, for example: `using
OffloadDeviceTest = OffloadDeviceTestWithParam<int>;`. The single mock
parameter of value `0` is combined with the devices in the provided
macros, yielding tuples of type `std::tuple<TestEnvironment::Device,
int>`. The hidden `int` parameter is not used, but it enables users to
instantiate unparameterized tests without knowledge about the
implementation details. Moreover, it allows for modifying only one
version of the fixture (the one being aliased), without the need to also
change the other version: either parameterized or unparameterized.
The following macros are added in this patch:
- `OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM(FIXTURE, VALUES,
PRINTER)`: instantiates `FIXTURE` with parameters stored in the provided
container `VALUES` (a C-style array or an STL-style container) and with
the given printer. The used devices do not include the host.
- `OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE_WITH_PARAM(FIXTURE,
VALUES, PRINTER)`: similar to
`OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM`, but includes the
`Host` in the tested devices.
- `OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE(FIXTURE)`: instantiates
`FIXTURE` without additional parameters, but also includes the `Host` in
the used devices.
- `OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES(FIXTURE, DEVICES)`:
instantiates `FIXTURE` with the provided devices, internally using a
mock parameter. It is not intended for direct use and acts as a helper
macro for the instantiation of unparameterized tests.
- `OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES_WITH_PARAM(FIXTURE, VALUES,
DEVICES, PRINTER)`: instantiates `FIXTURE` with the provided devices,
parameters and the given printer. It is not intended for direct use and
acts as a helper macro for the instantiation of parameterized tests.
Since the new macros enable testing the `Host` as part of the used
devices, `offload/unittests/OffloadAPI/device/olGetHostInfo.cpp` is
deleted and its tests have been moved to
`offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp`.
The new helper header
`offload/unittests/OffloadAPI/common/Properties.hpp`:
- pairs properties with their sizes for tests similar to
`offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp`
- packs selected properties into containers or arrays for easier access
and instantiation of fixtures
---
offload/unittests/OffloadAPI/CMakeLists.txt | 3 +-
.../unittests/OffloadAPI/common/Fixtures.hpp | 125 +++++++--
.../OffloadAPI/common/Properties.hpp | 249 +++++++++++++++++
.../OffloadAPI/device/olGetDeviceInfo.cpp | 251 ++++--------------
.../OffloadAPI/device/olGetDeviceInfoSize.cpp | 83 ++----
.../OffloadAPI/device/olGetHostInfo.cpp | 195 --------------
.../OffloadAPI/memory/olGetMemInfo.cpp | 102 +++----
.../OffloadAPI/memory/olGetMemInfoSize.cpp | 47 ++--
.../OffloadAPI/memory/olMemAlloc.cpp | 32 +--
.../OffloadAPI/memory/olMemAllocAligned.cpp | 113 +-------
.../unittests/OffloadAPI/memory/olMemFree.cpp | 21 +-
.../OffloadAPI/platform/olGetPlatformInfo.cpp | 38 +--
.../platform/olGetPlatformInfoSize.cpp | 24 +-
.../OffloadAPI/symbol/olGetSymbolInfoSize.cpp | 29 +-
14 files changed, 559 insertions(+), 753 deletions(-)
create mode 100644 offload/unittests/OffloadAPI/common/Properties.hpp
delete mode 100644 offload/unittests/OffloadAPI/device/olGetHostInfo.cpp
diff --git a/offload/unittests/OffloadAPI/CMakeLists.txt b/offload/unittests/OffloadAPI/CMakeLists.txt
index 16d6b633d885f..44f831cb83ff7 100644
--- a/offload/unittests/OffloadAPI/CMakeLists.txt
+++ b/offload/unittests/OffloadAPI/CMakeLists.txt
@@ -6,8 +6,7 @@ add_subdirectory(device_code)
add_offload_unittest("device"
device/olIterateDevices.cpp
device/olGetDeviceInfo.cpp
- device/olGetDeviceInfoSize.cpp
- device/olGetHostInfo.cpp)
+ device/olGetDeviceInfoSize.cpp)
add_offload_unittest("event"
event/olCreateEvent.cpp
diff --git a/offload/unittests/OffloadAPI/common/Fixtures.hpp b/offload/unittests/OffloadAPI/common/Fixtures.hpp
index f6b7502c41882..6d940584faef8 100644
--- a/offload/unittests/OffloadAPI/common/Fixtures.hpp
+++ b/offload/unittests/OffloadAPI/common/Fixtures.hpp
@@ -180,13 +180,16 @@ struct OffloadTest : ::testing::Test {
ol_device_handle_t Host = TestEnvironment::getHostDevice();
};
-struct OffloadDeviceTest
+template <class T> using OffloadParam = std::tuple<TestEnvironment::Device, T>;
+
+template <class T>
+struct OffloadDeviceTestWithParam
: OffloadTest,
- ::testing::WithParamInterface<TestEnvironment::Device> {
+ ::testing::WithParamInterface<OffloadParam<T>> {
void SetUp() override {
RETURN_ON_FATAL_FAILURE(OffloadTest::SetUp());
- auto DeviceParam = GetParam();
+ auto &DeviceParam = std::get<0>(this->GetParam());
Device = DeviceParam.Handle;
if (Device == nullptr)
GTEST_SKIP() << "No available devices.";
@@ -204,14 +207,31 @@ struct OffloadDeviceTest
return Backend;
}
+ const OffloadParam<T> &getParamTuple() const { return this->GetParam(); }
+
+ const T &getTestParam() { return std::get<1>(getParamTuple()); }
+
ol_device_handle_t Device = nullptr;
};
-struct OffloadPlatformTest : OffloadDeviceTest {
+// In order to avoid code duplication, the unparameterized versions of fixtures
+// are aliases for parameterized fixtures, with `int` type chosen arbitrarily as
+// an ignored parameter type. The single mock parameter of value `0` is combined
+// with the devices in the provided macros, yielding tuples
+// `std::tuple<TestEnvironment::Device, int>`. The hidden `int` parameter is not
+// used, but it enables users to instantiate unparameterized tests without the
+// knowledge about the details related to the implementation of fixtures.
+// Moreover, it allows for modifying only one version of the fixture, without
+// the need to also change the other version: either parameterized or
+// unparameterized.
+using OffloadDeviceTest = OffloadDeviceTestWithParam<int>;
+
+template <typename T>
+struct OffloadPlatformTestWithParam : OffloadDeviceTestWithParam<T> {
void SetUp() override {
- RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::SetUp());
+ RETURN_ON_FATAL_FAILURE(OffloadDeviceTestWithParam<T>::SetUp());
- ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_PLATFORM,
+ ASSERT_SUCCESS(olGetDeviceInfo(this->Device, OL_DEVICE_INFO_PLATFORM,
sizeof(Platform), &Platform));
ASSERT_NE(Platform, nullptr);
}
@@ -219,17 +239,20 @@ struct OffloadPlatformTest : OffloadDeviceTest {
ol_platform_handle_t Platform = nullptr;
};
+using OffloadPlatformTest = OffloadPlatformTestWithParam<int>;
+
// Fixture for a generic program test. If you want a different program, use
// offloadQueueTest and create your own program handle with the binary you want.
-struct OffloadProgramTest : OffloadDeviceTest {
+template <typename T>
+struct OffloadProgramTestWithParam : OffloadDeviceTestWithParam<T> {
void SetUp() override { SetUpWith("foo"); }
void SetUpWith(const char *ProgramName) {
- RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::SetUp());
- ASSERT_TRUE(
- TestEnvironment::loadDeviceBinary(ProgramName, Device, DeviceBin));
+ RETURN_ON_FATAL_FAILURE(OffloadDeviceTestWithParam<T>::SetUp());
+ ASSERT_TRUE(TestEnvironment::loadDeviceBinary(ProgramName, this->Device,
+ DeviceBin));
ASSERT_GE(DeviceBin->getBufferSize(), 0lu);
- ASSERT_SUCCESS(olCreateProgram(Device, DeviceBin->getBufferStart(),
+ ASSERT_SUCCESS(olCreateProgram(this->Device, DeviceBin->getBufferStart(),
DeviceBin->getBufferSize(), &Program));
}
@@ -237,13 +260,15 @@ struct OffloadProgramTest : OffloadDeviceTest {
if (Program) {
olDestroyProgram(Program);
}
- RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::TearDown());
+ RETURN_ON_FATAL_FAILURE(OffloadDeviceTestWithParam<T>::TearDown());
}
ol_program_handle_t Program = nullptr;
std::unique_ptr<llvm::MemoryBuffer> DeviceBin;
};
+using OffloadProgramTest = OffloadProgramTestWithParam<int>;
+
struct OffloadKernelTest : OffloadProgramTest {
void SetUp() override {
RETURN_ON_FATAL_FAILURE(OffloadProgramTest::SetUp());
@@ -257,20 +282,24 @@ struct OffloadKernelTest : OffloadProgramTest {
ol_symbol_handle_t Kernel = nullptr;
};
-struct OffloadGlobalTest : OffloadProgramTest {
+template <typename T>
+struct OffloadGlobalTestWithParam : OffloadProgramTestWithParam<T> {
void SetUp() override {
- RETURN_ON_FATAL_FAILURE(OffloadProgramTest::SetUpWith("global"));
- ASSERT_SUCCESS(olGetSymbol(Program, "global",
+ RETURN_ON_FATAL_FAILURE(
+ OffloadProgramTestWithParam<T>::SetUpWith("global"));
+ ASSERT_SUCCESS(olGetSymbol(this->Program, "global",
OL_SYMBOL_KIND_GLOBAL_VARIABLE, &Global));
}
void TearDown() override {
- RETURN_ON_FATAL_FAILURE(OffloadProgramTest::TearDown());
+ RETURN_ON_FATAL_FAILURE(OffloadProgramTestWithParam<T>::TearDown());
}
ol_symbol_handle_t Global = nullptr;
};
+using OffloadGlobalTest = OffloadGlobalTestWithParam<int>;
+
struct OffloadQueueTest : OffloadDeviceTest {
void SetUp() override {
RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::SetUp());
@@ -338,13 +367,69 @@ struct LaunchSingleKernelTestBase : LaunchKernelTestBase {
ol_symbol_handle_t Kernel = nullptr;
};
+using DevicesVec = std::vector<TestEnvironment::Device>;
+
+inline DevicesVec getDevicesAndHost() {
+ DevicesVec Res(TestEnvironment::getDevices());
+ TestEnvironment::Device Host{TestEnvironment::getHostDevice(), "HOST"};
+
+ Res.push_back(Host);
+
+ return Res;
+}
+
+template <class T>
+inline std::string
+defaultPrinterWithParam(const ::testing::TestParamInfo<OffloadParam<T>> &info) {
+ auto device = std::get<0>(info.param);
+ auto param = std::get<1>(info.param);
+
+ std::string placeholder;
+ llvm::raw_string_ostream ss(placeholder);
+
+ ss << device.Name << "__" << param;
+
+ return SanitizeString(ss.str());
+}
+
+inline std::string
+defaultPrinter(const ::testing::TestParamInfo<OffloadParam<int>> &info) {
+ auto device = std::get<0>(info.param);
+
+ return SanitizeString(device.Name);
+}
+
// Devices might not be available for offload testing, so allow uninstantiated
// tests (as the device list will be empty). This means that all tests requiring
// a device will be silently skipped.
+#define OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES(FIXTURE, DEVICES) \
+ INSTANTIATE_TEST_SUITE_P( \
+ , FIXTURE, \
+ testing::Combine(::testing::ValuesIn(DEVICES), testing::ValuesIn({0})), \
+ defaultPrinter); \
+ GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(FIXTURE)
+
#define OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(FIXTURE) \
+ OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES(FIXTURE, TestEnvironment::getDevices())
+
+#define OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE(FIXTURE) \
+ OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES(FIXTURE, getDevicesAndHost())
+
+#define OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES_WITH_PARAM(FIXTURE, VALUES, \
+ DEVICES, PRINTER) \
INSTANTIATE_TEST_SUITE_P( \
- , FIXTURE, ::testing::ValuesIn(TestEnvironment::getDevices()), \
- [](const ::testing::TestParamInfo<TestEnvironment::Device> &info) { \
- return SanitizeString(info.param.Name); \
- }); \
+ , FIXTURE, \
+ testing::Combine(::testing::ValuesIn(TestEnvironment::getDevices()), \
+ ::testing::ValuesIn(VALUES)), \
+ PRINTER); \
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(FIXTURE)
+
+#define OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM(FIXTURE, VALUES, \
+ PRINTER) \
+ OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES_WITH_PARAM( \
+ FIXTURE, VALUES, TestEnvironment::getDevices(), PRINTER)
+
+#define OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE_WITH_PARAM( \
+ FIXTURE, VALUES, PRINTER) \
+ OFFLOAD_TESTS_INSTANTIATE_WITH_DEVICES_WITH_PARAM( \
+ FIXTURE, VALUES, getDevicesAndHost(), PRINTER)
diff --git a/offload/unittests/OffloadAPI/common/Properties.hpp b/offload/unittests/OffloadAPI/common/Properties.hpp
new file mode 100644
index 0000000000000..4efeb2226ff8e
--- /dev/null
+++ b/offload/unittests/OffloadAPI/common/Properties.hpp
@@ -0,0 +1,249 @@
+#pragma once
+
+#include "Fixtures.hpp"
+#include "OffloadAPI.h"
+
+inline constexpr size_t MAX_DEVICE_INFO_BYTES = 8;
+
+inline constexpr char zeroArray[MAX_DEVICE_INFO_BYTES] = {};
+
+template <typename T> struct SizedProperty {
+ size_t size;
+ T property;
+};
+
+template <typename T>
+using PropertiesWithSizeContainer = std::vector<SizedProperty<T>>;
+template <typename T> using PropertiesContainer = std::set<T>;
+template <typename T>
+using PropertiesTypes = std::unordered_map<T, SizedProperty<T>>;
+
+template <typename T>
+auto createPropertiesWithSizeContainer(
+ size_t PropSize, PropertiesContainer<T> SelectedProperties)
+ -> PropertiesWithSizeContainer<T> {
+ PropertiesWithSizeContainer<T> Res;
+ for (auto p : SelectedProperties) {
+ Res.push_back({PropSize, p});
+ }
+
+ return Res;
+}
+
+template <typename T>
+auto mergeProperties(
+ std::initializer_list<PropertiesWithSizeContainer<T>> properties)
+ -> PropertiesWithSizeContainer<T> {
+ PropertiesWithSizeContainer<T> finalProperties;
+
+ for (auto prop : properties) {
+ finalProperties.insert(finalProperties.end(), prop.begin(), prop.end());
+ }
+
+ return finalProperties;
+}
+
+template <typename T>
+PropertiesContainer<T>
+removeIrrelevantProperties(PropertiesContainer<T> base,
+ PropertiesContainer<T> unwanted) {
+ PropertiesContainer<T> res(base);
+
+ for (auto prop : unwanted) {
+ res.erase(prop);
+ }
+
+ return res;
+}
+
+template <typename T>
+PropertiesTypes<T> inline createTypesMap(
+ std::initializer_list<PropertiesWithSizeContainer<T>> properties) {
+ PropertiesTypes<T> Res;
+
+ for (auto container : properties) {
+ for (auto prop : container) {
+ Res.insert({prop.property, prop});
+ }
+ }
+
+ return Res;
+}
+
+// ol_device_info_t
+using DeviceInfoProp = PropertiesContainer<ol_device_info_t>;
+using DeviceInfoProperties = PropertiesWithSizeContainer<ol_device_info_t>;
+using DeviceInfoPropertiesTypes = PropertiesTypes<ol_device_info_t>;
+
+inline const DeviceInfoProp PropBool{OL_DEVICE_INFO_SINGLE_FP_SUPPORT,
+ OL_DEVICE_INFO_DOUBLE_FP_SUPPORT,
+ OL_DEVICE_INFO_HALF_FP_SUPPORT};
+inline const DeviceInfoProperties BoolProperties =
+ createPropertiesWithSizeContainer(sizeof(bool), PropBool);
+
+inline const DeviceInfoProp PropUint32{
+ OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE,
+ OL_DEVICE_INFO_MAX_WORK_SIZE,
+ OL_DEVICE_INFO_VENDOR_ID,
+ OL_DEVICE_INFO_NUM_COMPUTE_UNITS,
+ OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR,
+ OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT,
+ OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT,
+ OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG,
+ OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT,
+ OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE,
+ OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF,
+ OL_DEVICE_INFO_MAX_CLOCK_FREQUENCY,
+ OL_DEVICE_INFO_MEMORY_CLOCK_RATE,
+ OL_DEVICE_INFO_ADDRESS_BITS};
+inline const DeviceInfoProperties Uint32Properties =
+ createPropertiesWithSizeContainer(sizeof(uint32_t), PropUint32);
+
+inline const DeviceInfoProp PropUint64{
+ OL_DEVICE_INFO_MAX_MEM_ALLOC_SIZE, OL_DEVICE_INFO_GLOBAL_MEM_SIZE,
+ OL_DEVICE_INFO_WORK_GROUP_LOCAL_MEM_SIZE};
+inline const DeviceInfoProperties Uint64Properties =
+ createPropertiesWithSizeContainer(sizeof(uint64_t), PropUint64);
+
+inline const DeviceInfoProp PropCapabilitiesFlags{
+ OL_DEVICE_INFO_SINGLE_FP_CONFIG, OL_DEVICE_INFO_HALF_FP_CONFIG,
+ OL_DEVICE_INFO_DOUBLE_FP_CONFIG};
+// sizeof(ol_device_fp_capability_flags_t) == sizeof(uint32_t)
+inline const DeviceInfoProperties CapabilitesFlagsProperties =
+ createPropertiesWithSizeContainer(sizeof(ol_device_fp_capability_flags_t),
+ PropCapabilitiesFlags);
+
+inline const DeviceInfoProp PropIrrelevantGTCapabilities = {
+ OL_DEVICE_INFO_HALF_FP_CONFIG};
+inline const DeviceInfoProp Prop_RelevantGTCapabilites =
+ removeIrrelevantProperties(PropCapabilitiesFlags,
+ PropIrrelevantGTCapabilities);
+inline const DeviceInfoProperties RelevantGTCapabilitiesProperties =
+ createPropertiesWithSizeContainer(sizeof(ol_device_fp_capability_flags_t),
+ Prop_RelevantGTCapabilites);
+
+inline const DeviceInfoProp PropIrrelevantGTUint32 = {
+ OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF};
+inline const DeviceInfoProp Prop_RelevantGTUint32 =
+ removeIrrelevantProperties(PropUint32, PropIrrelevantGTUint32);
+inline const DeviceInfoProperties RelevantGTUint32Properties =
+ createPropertiesWithSizeContainer(sizeof(uint32_t), Prop_RelevantGTUint32);
+
+inline const DeviceInfoProp PropDeviceType{OL_DEVICE_INFO_TYPE};
+inline const DeviceInfoProperties DeviceTypeProperties =
+ createPropertiesWithSizeContainer(sizeof(ol_device_type_t), PropDeviceType);
+
+inline const DeviceInfoProp PropPlatform{OL_DEVICE_INFO_PLATFORM};
+inline const DeviceInfoProperties PlatformProperties =
+ createPropertiesWithSizeContainer(sizeof(ol_platform_handle_t),
+ PropPlatform);
+
+inline const DeviceInfoProp PropNames{
+ OL_DEVICE_INFO_NAME, OL_DEVICE_INFO_PRODUCT_NAME, OL_DEVICE_INFO_UID,
+ OL_DEVICE_INFO_VENDOR, OL_DEVICE_INFO_DRIVER_VERSION};
+inline const DeviceInfoProperties NamesProperties =
+ createPropertiesWithSizeContainer(0, PropNames);
+
+inline const DeviceInfoProp PropDimensions{
+ OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE_PER_DIMENSION,
+ OL_DEVICE_INFO_MAX_WORK_SIZE_PER_DIMENSION};
+inline const DeviceInfoProperties DimensionsProperties =
+ createPropertiesWithSizeContainer(sizeof(ol_dimensions_t), PropDimensions);
+
+inline const DeviceInfoPropertiesTypes propertiesTypes =
+ createTypesMap({BoolProperties, Uint32Properties, Uint64Properties,
+ CapabilitesFlagsProperties});
+
+inline bool defaultCheckIsNonZero(char *buffer) {
+ return memcmp(buffer, zeroArray, MAX_DEVICE_INFO_BYTES) != 0;
+}
+
+template <typename T>
+inline std::string defaultPropertyTestPrinter(
+ const ::testing::TestParamInfo<OffloadParam<SizedProperty<T>>> &info) {
+ auto device = std::get<0>(info.param);
+ auto paramData = std::get<1>(info.param);
+
+ std::string ss;
+ llvm::raw_string_ostream finalName(ss);
+
+ auto property = paramData.property;
+ finalName << device.Name << "__" << property;
+
+ return SanitizeString(finalName.str());
+}
+
+template <typename T>
+struct olPropertyTest : OffloadDeviceTestWithParam<SizedProperty<T>> {
+ void SetUp() override {
+ RETURN_ON_FATAL_FAILURE(
+ OffloadDeviceTestWithParam<SizedProperty<T>>::SetUp());
+
+ auto paramData = this->getTestParam();
+ PropertySize = paramData.size;
+ Property = paramData.property;
+ }
+
+ size_t PropertySize = 0;
+ T Property;
+};
+
+struct olGetHostDeviceInfoPropertyTest : olPropertyTest<ol_device_info_t> {
+ bool isHost() { return Host == this->Device; }
+};
+
+struct olGetHostDeviceInfoTest : OffloadDeviceTest {
+ void SetUp() override { RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::SetUp()); }
+
+ bool isHost() { return Host == this->Device; }
+};
+
+// ol_symbol_info
+using SymbolInfoTuple = SizedProperty<ol_symbol_info_t>;
+using SymbolInfoProp = PropertiesContainer<ol_symbol_info_t>;
+using SymbolInfoProperties = PropertiesWithSizeContainer<ol_symbol_info_t>;
+
+inline const SymbolInfoProp PropSymbolInfoGlobal{
+ OL_SYMBOL_INFO_KIND, OL_SYMBOL_INFO_GLOBAL_VARIABLE_ADDRESS,
+ OL_SYMBOL_INFO_GLOBAL_VARIABLE_SIZE};
+inline const SymbolInfoProperties SymbolGlobalProperties{
+ {sizeof(ol_symbol_kind_t), OL_SYMBOL_INFO_KIND},
+ {sizeof(void *), OL_SYMBOL_INFO_GLOBAL_VARIABLE_ADDRESS},
+ {sizeof(size_t), OL_SYMBOL_INFO_GLOBAL_VARIABLE_SIZE}};
+
+struct olGetSymbolInfoSizeGlobalTest
+ : OffloadGlobalTestWithParam<SymbolInfoTuple> {
+ void SetUp() override {
+ RETURN_ON_FATAL_FAILURE(
+ OffloadGlobalTestWithParam<SymbolInfoTuple>::SetUp());
+
+ auto paramData = this->getTestParam();
+ PropertySize = paramData.size;
+ Property = paramData.property;
+ }
+
+ size_t PropertySize = 0;
+ ol_symbol_info_t Property;
+};
+
+// ol_platform_info_t
+inline const ol_platform_info_t PlatformInfoNames[3] = {
+ OL_PLATFORM_INFO_NAME, OL_PLATFORM_INFO_VENDOR_NAME,
+ OL_PLATFORM_INFO_VERSION};
+
+// ol_alloc_type_t
+inline const ol_alloc_type_t AllocTypes[3] = {
+ OL_ALLOC_TYPE_DEVICE, OL_ALLOC_TYPE_MANAGED, OL_ALLOC_TYPE_HOST};
+inline const size_t TestAllocsNum = 1000;
+
+// ol_mem_info_t
+using MemInfoProp = PropertiesContainer<ol_mem_info_t>;
+using MemInfoProperties = PropertiesWithSizeContainer<ol_mem_info_t>;
+
+inline const MemInfoProp PropMemInfo{OL_MEM_INFO_DEVICE, OL_MEM_INFO_BASE,
+ OL_MEM_INFO_SIZE, OL_MEM_INFO_TYPE};
+inline const MemInfoProperties MemInfoSizeProperties{
+ {sizeof(ol_device_handle_t), OL_MEM_INFO_DEVICE},
+ {sizeof(void *), OL_MEM_INFO_BASE},
+ {sizeof(size_t), OL_MEM_INFO_SIZE},
+ {sizeof(ol_alloc_type_t), OL_MEM_INFO_TYPE}};
diff --git a/offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp b/offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp
index f2ea60cffdf12..9e810ececab53 100644
--- a/offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp
+++ b/offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp
@@ -6,257 +6,120 @@
//
//===----------------------------------------------------------------------===//
-#include "../common/Fixtures.hpp"
+#include "../common/Properties.hpp"
#include <OffloadAPI.h>
#include <gtest/gtest.h>
-using olGetDeviceInfoTest = OffloadDeviceTest;
-OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetDeviceInfoTest);
+DeviceInfoProperties JustSupportedProperties = mergeProperties(
+ {BoolProperties,
+ {propertiesTypes.at(OL_DEVICE_INFO_HALF_FP_CONFIG),
+ propertiesTypes.at(OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF)}});
-#define OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Dev, \
- Expr) \
- TEST_P(olGetDeviceInfoTest, Test##Dev##TestName) { \
- PropType Value; \
- ASSERT_SUCCESS(olGetDeviceInfo(Dev, PropName, sizeof(Value), &Value)); \
- Expr; \
- }
-
-#define OL_DEVICE_INFO_TEST_DEVICE_SUCCESS(TestName, PropType, PropName) \
- OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Device, {})
-
-#define OL_DEVICE_INFO_TEST_HOST_SUCCESS(TestName, PropType, PropName) \
- OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Host, {})
-
-#define OL_DEVICE_INFO_TEST_SUCCESS(TestName, PropType, PropName) \
- OL_DEVICE_INFO_TEST_DEVICE_SUCCESS(TestName, PropType, PropName) \
- OL_DEVICE_INFO_TEST_HOST_SUCCESS(TestName, PropType, PropName)
+DeviceInfoProperties NonZeroProperties =
+ mergeProperties({RelevantGTCapabilitiesProperties,
+ RelevantGTUint32Properties, Uint64Properties});
-#define OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(TestName, PropType, PropName, \
- LowBound) \
- OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Device, \
- ASSERT_GT(Value, LowBound))
+using olGetHostDeviceInfoPropertySupportTest = olGetHostDeviceInfoPropertyTest;
+using olGetHostDeviceInfoPropertyNonZeroTest = olGetHostDeviceInfoPropertyTest;
-#define OL_DEVICE_INFO_TEST_HOST_VALUE_GT(TestName, PropType, PropName, \
- LowBound) \
- OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Host, \
- ASSERT_GT(Value, LowBound))
+OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE_WITH_PARAM(
+ olGetHostDeviceInfoPropertySupportTest, JustSupportedProperties,
+ defaultPropertyTestPrinter<ol_device_info_t>);
-#define OL_DEVICE_INFO_TEST_VALUE_GT(TestName, PropType, PropName, LowBound) \
- OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(TestName, PropType, PropName, LowBound) \
- OL_DEVICE_INFO_TEST_HOST_VALUE_GT(TestName, PropType, PropName, LowBound)
+OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE_WITH_PARAM(
+ olGetHostDeviceInfoPropertyNonZeroTest, NonZeroProperties,
+ defaultPropertyTestPrinter<ol_device_info_t>);
-TEST_P(olGetDeviceInfoTest, SuccessType) {
- ol_device_type_t DeviceType;
- ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE,
- sizeof(ol_device_type_t), &DeviceType));
+// Properties without gt test
+TEST_P(olGetHostDeviceInfoPropertySupportTest, Success) {
+ char Value[MAX_DEVICE_INFO_BYTES];
+ ASSERT_SUCCESS(olGetDeviceInfo(Device, Property, PropertySize, &Value));
}
-TEST_P(olGetDeviceInfoTest, HostSuccessType) {
- ol_device_type_t DeviceType;
- ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_TYPE,
- sizeof(ol_device_type_t), &DeviceType));
- ASSERT_EQ(DeviceType, OL_DEVICE_TYPE_HOST);
-}
+TEST_P(olGetHostDeviceInfoPropertyNonZeroTest, Value) {
+ char Value[MAX_DEVICE_INFO_BYTES] = {};
+ ASSERT_SUCCESS(olGetDeviceInfo(Device, Property, PropertySize, &Value));
-TEST_P(olGetDeviceInfoTest, SuccessPlatform) {
- ol_platform_handle_t Platform = nullptr;
- ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_PLATFORM,
- sizeof(ol_platform_handle_t), &Platform));
- ASSERT_NE(Platform, nullptr);
+ ASSERT_TRUE(defaultCheckIsNonZero(Value));
}
-TEST_P(olGetDeviceInfoTest, SuccessName) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_NAME, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> Name;
- Name.resize(Size);
- ASSERT_SUCCESS(
- olGetDeviceInfo(Device, OL_DEVICE_INFO_NAME, Size, Name.data()));
- ASSERT_EQ(std::strlen(Name.data()), Size - 1);
-}
-
-TEST_P(olGetDeviceInfoTest, HostName) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_NAME, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> Name;
- Name.resize(Size);
- ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_NAME, Size, Name.data()));
- ASSERT_EQ(std::strlen(Name.data()), Size - 1);
-}
-
-TEST_P(olGetDeviceInfoTest, SuccessProductName) {
- size_t Size = 0;
- ASSERT_SUCCESS(
- olGetDeviceInfoSize(Device, OL_DEVICE_INFO_PRODUCT_NAME, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> Name;
- Name.resize(Size);
- ASSERT_SUCCESS(
- olGetDeviceInfo(Device, OL_DEVICE_INFO_PRODUCT_NAME, Size, Name.data()));
- ASSERT_EQ(std::strlen(Name.data()), Size - 1);
-}
+using olGetDeviceHostInfoNamesTest = olGetHostDeviceInfoPropertyTest;
-TEST_P(olGetDeviceInfoTest, SuccessUID) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_UID, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> UID;
- UID.resize(Size);
- ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_UID, Size, UID.data()));
- ASSERT_EQ(std::strlen(UID.data()), Size - 1);
-}
+OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE_WITH_PARAM(
+ olGetDeviceHostInfoNamesTest, NamesProperties,
+ defaultPropertyTestPrinter<ol_device_info_t>);
-TEST_P(olGetDeviceInfoTest, HostProductName) {
+TEST_P(olGetDeviceHostInfoNamesTest, SuccessNames) {
size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_PRODUCT_NAME, &Size));
+ ASSERT_SUCCESS(olGetDeviceInfoSize(Device, Property, &Size));
ASSERT_GT(Size, 0ul);
std::vector<char> Name;
Name.resize(Size);
- ASSERT_SUCCESS(
- olGetDeviceInfo(Host, OL_DEVICE_INFO_PRODUCT_NAME, Size, Name.data()));
+ ASSERT_SUCCESS(olGetDeviceInfo(Device, Property, Size, Name.data()));
ASSERT_EQ(std::strlen(Name.data()), Size - 1);
}
-TEST_P(olGetDeviceInfoTest, HostUID) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_UID, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> UID;
- UID.resize(Size);
- ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_UID, Size, UID.data()));
- ASSERT_EQ(std::strlen(UID.data()), Size - 1);
-}
-
-TEST_P(olGetDeviceInfoTest, SuccessVendor) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_VENDOR, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> Vendor;
- Vendor.resize(Size);
- ASSERT_SUCCESS(
- olGetDeviceInfo(Device, OL_DEVICE_INFO_VENDOR, Size, Vendor.data()));
- ASSERT_EQ(std::strlen(Vendor.data()), Size - 1);
-}
+using olGetHostDeviceInfoDimensionsTest = olGetHostDeviceInfoPropertyTest;
-TEST_P(olGetDeviceInfoTest, SuccessDriverVersion) {
- size_t Size = 0;
- ASSERT_SUCCESS(
- olGetDeviceInfoSize(Device, OL_DEVICE_INFO_DRIVER_VERSION, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> DriverVersion;
- DriverVersion.resize(Size);
- ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_DRIVER_VERSION, Size,
- DriverVersion.data()));
- ASSERT_EQ(std::strlen(DriverVersion.data()), Size - 1);
-}
+OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE_WITH_PARAM(
+ olGetHostDeviceInfoDimensionsTest, DimensionsProperties,
+ defaultPropertyTestPrinter<ol_device_info_t>);
-OL_DEVICE_INFO_TEST_VALUE_GT(MaxWorkGroupSize, uint32_t,
- OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE, 0);
-
-TEST_P(olGetDeviceInfoTest, SuccessMaxWorkGroupSizePerDimension) {
+TEST_P(olGetHostDeviceInfoDimensionsTest, Success) {
ol_dimensions_t Value{0, 0, 0};
- ASSERT_SUCCESS(
- olGetDeviceInfo(Device, OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE_PER_DIMENSION,
- sizeof(Value), &Value));
+ ASSERT_SUCCESS(olGetDeviceInfo(Device, Property, sizeof(Value), &Value));
ASSERT_GT(Value.x, 0u);
ASSERT_GT(Value.y, 0u);
ASSERT_GT(Value.z, 0u);
}
-OL_DEVICE_INFO_TEST_VALUE_GT(MaxWorkSize, uint32_t,
- OL_DEVICE_INFO_MAX_WORK_SIZE, 0);
+OFFLOAD_TESTS_INSTANTIATE_HOST_DEVICE_FIXTURE(olGetHostDeviceInfoTest);
-TEST_P(olGetDeviceInfoTest, SuccessMaxWorkSizePerDimension) {
- ol_dimensions_t Value{0, 0, 0};
- ASSERT_SUCCESS(olGetDeviceInfo(Device,
- OL_DEVICE_INFO_MAX_WORK_SIZE_PER_DIMENSION,
- sizeof(Value), &Value));
- ASSERT_GT(Value.x, 0u);
- ASSERT_GT(Value.y, 0u);
- ASSERT_GT(Value.z, 0u);
+TEST_P(olGetHostDeviceInfoTest, HostSuccessType) {
+ ol_device_type_t DeviceType;
+ ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE,
+ sizeof(ol_device_type_t), &DeviceType));
+
+ if (isHost()) {
+ ASSERT_EQ(DeviceType, OL_DEVICE_TYPE_HOST);
+ }
}
-OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(VendorId, uint32_t,
- OL_DEVICE_INFO_VENDOR_ID, 0);
-OL_DEVICE_INFO_TEST_HOST_SUCCESS(VendorId, uint32_t, OL_DEVICE_INFO_VENDOR_ID);
-OL_DEVICE_INFO_TEST_VALUE_GT(NumComputeUnits, uint32_t,
- OL_DEVICE_INFO_NUM_COMPUTE_UNITS, 0);
-OL_DEVICE_INFO_TEST_VALUE_GT(SingleFPConfig, ol_device_fp_capability_flags_t,
- OL_DEVICE_INFO_SINGLE_FP_CONFIG, 0);
-OL_DEVICE_INFO_TEST_SUCCESS(HalfFPConfig, ol_device_fp_capability_flags_t,
- OL_DEVICE_INFO_HALF_FP_CONFIG);
-OL_DEVICE_INFO_TEST_VALUE_GT(DoubleFPConfig, ol_device_fp_capability_flags_t,
- OL_DEVICE_INFO_DOUBLE_FP_CONFIG, 0);
-OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthChar, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR, 0);
-OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthShort, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT, 0);
-OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthInt, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT, 0);
-OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthLong, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG, 0);
-OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthFloat, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT, 0);
-OL_DEVICE_INFO_TEST_VALUE_GT(NativeVectorWidthDouble, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE, 0);
-OL_DEVICE_INFO_TEST_SUCCESS(SingleFPSupport, bool,
- OL_DEVICE_INFO_SINGLE_FP_SUPPORT);
-OL_DEVICE_INFO_TEST_SUCCESS(DoubleFPSupport, bool,
- OL_DEVICE_INFO_DOUBLE_FP_SUPPORT);
-OL_DEVICE_INFO_TEST_SUCCESS(HalfFPSupport, bool,
- OL_DEVICE_INFO_HALF_FP_SUPPORT);
-OL_DEVICE_INFO_TEST_SUCCESS(NativeVectorWidthHalf, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF);
-OL_DEVICE_INFO_TEST_VALUE_GT(MaxClockFrequency, uint32_t,
- OL_DEVICE_INFO_MAX_CLOCK_FREQUENCY, 0);
-OL_DEVICE_INFO_TEST_VALUE_GT(MemoryClockRate, uint32_t,
- OL_DEVICE_INFO_MEMORY_CLOCK_RATE, 0);
-OL_DEVICE_INFO_TEST_VALUE_GT(AddressBits, uint32_t, OL_DEVICE_INFO_ADDRESS_BITS,
- 0);
-OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(MaxMemAllocSize, uint64_t,
- OL_DEVICE_INFO_MAX_MEM_ALLOC_SIZE, 0);
-OL_DEVICE_INFO_TEST_HOST_SUCCESS(MaxMemAllocSize, uint64_t,
- OL_DEVICE_INFO_MAX_MEM_ALLOC_SIZE);
-OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(GlobalMemSize, uint64_t,
- OL_DEVICE_INFO_GLOBAL_MEM_SIZE, 0);
-OL_DEVICE_INFO_TEST_HOST_SUCCESS(GlobalMemSize, uint64_t,
- OL_DEVICE_INFO_GLOBAL_MEM_SIZE);
-OL_DEVICE_INFO_TEST_DEVICE_VALUE_GT(SharedMemSize, uint64_t,
- OL_DEVICE_INFO_WORK_GROUP_LOCAL_MEM_SIZE,
- 0);
-OL_DEVICE_INFO_TEST_HOST_SUCCESS(SharedMemSize, uint64_t,
- OL_DEVICE_INFO_WORK_GROUP_LOCAL_MEM_SIZE);
+TEST_P(olGetHostDeviceInfoTest, SuccessPlatform) {
+ ol_platform_handle_t Platform = nullptr;
+ ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_PLATFORM,
+ sizeof(ol_platform_handle_t), &Platform));
+ ASSERT_NE(Platform, nullptr);
+}
-TEST_P(olGetDeviceInfoTest, InvalidNullHandleDevice) {
+TEST_P(olGetHostDeviceInfoTest, InvalidNullHandleDevice) {
ol_device_type_t DeviceType;
ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
olGetDeviceInfo(nullptr, OL_DEVICE_INFO_TYPE,
sizeof(ol_device_type_t), &DeviceType));
}
-TEST_P(olGetDeviceInfoTest, InvalidEnumerationInfoType) {
+TEST_P(olGetHostDeviceInfoTest, InvalidEnumerationInfoType) {
ol_device_type_t DeviceType;
ASSERT_ERROR(OL_ERRC_INVALID_ENUMERATION,
olGetDeviceInfo(Device, OL_DEVICE_INFO_FORCE_UINT32,
sizeof(ol_device_type_t), &DeviceType));
}
-TEST_P(olGetDeviceInfoTest, InvalidSizePropSize) {
+TEST_P(olGetHostDeviceInfoTest, InvalidPropSize) {
ol_device_type_t DeviceType;
ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE, 0, &DeviceType));
}
-TEST_P(olGetDeviceInfoTest, InvalidSizePropSizeSmall) {
+TEST_P(olGetHostDeviceInfoTest, InvalidPropSizeSmall) {
ol_device_type_t DeviceType;
ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE,
sizeof(DeviceType) - 1, &DeviceType));
}
-TEST_P(olGetDeviceInfoTest, InvalidNullPointerPropValue) {
+TEST_P(olGetHostDeviceInfoTest, InvalidNullPointerPropValue) {
ol_device_type_t DeviceType;
ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE, sizeof(DeviceType),
diff --git a/offload/unittests/OffloadAPI/device/olGetDeviceInfoSize.cpp b/offload/unittests/OffloadAPI/device/olGetDeviceInfoSize.cpp
index 2c375eb555a48..82e0d36f027d9 100644
--- a/offload/unittests/OffloadAPI/device/olGetDeviceInfoSize.cpp
+++ b/offload/unittests/OffloadAPI/device/olGetDeviceInfoSize.cpp
@@ -6,73 +6,38 @@
//
//===----------------------------------------------------------------------===//
+#include "../common/Properties.hpp"
#include <OffloadAPI.h>
-#include "../common/Fixtures.hpp"
-
using olGetDeviceInfoSizeTest = OffloadDeviceTest;
OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetDeviceInfoSizeTest);
-#define OL_DEVICE_INFO_SIZE_TEST(TestName, PropName, Expr) \
- TEST_P(olGetDeviceInfoSizeTest, Success##TestName) { \
- size_t Size = 0; \
- ASSERT_SUCCESS(olGetDeviceInfoSize(Device, PropName, &Size)); \
- Expr; \
- }
+using olGetDeviceInfoSizeEqualTest = olGetHostDeviceInfoPropertyTest;
+using olGetDeviceInfoSizeNonZeroTest = olGetHostDeviceInfoPropertyTest;
+
+DeviceInfoProperties answerSizeEqualToTypeSizeProperties = mergeProperties(
+ {Uint32Properties, Uint64Properties, CapabilitesFlagsProperties,
+ PlatformProperties, DeviceTypeProperties});
-#define OL_DEVICE_INFO_SIZE_TEST_EQ(TestName, PropType, PropName) \
- OL_DEVICE_INFO_SIZE_TEST(TestName, PropName, \
- ASSERT_EQ(Size, sizeof(PropType)));
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM(
+ olGetDeviceInfoSizeEqualTest, answerSizeEqualToTypeSizeProperties,
+ defaultPropertyTestPrinter<ol_device_info_t>);
-#define OL_DEVICE_INFO_SIZE_TEST_NONZERO(TestName, PropName) \
- OL_DEVICE_INFO_SIZE_TEST(TestName, PropName, ASSERT_NE(Size, 0ul));
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM(
+ olGetDeviceInfoSizeNonZeroTest, NamesProperties,
+ defaultPropertyTestPrinter<ol_device_info_t>);
-OL_DEVICE_INFO_SIZE_TEST_EQ(Type, ol_device_type_t, OL_DEVICE_INFO_TYPE);
-OL_DEVICE_INFO_SIZE_TEST_EQ(Platform, ol_platform_handle_t,
- OL_DEVICE_INFO_PLATFORM);
-OL_DEVICE_INFO_SIZE_TEST_NONZERO(Name, OL_DEVICE_INFO_NAME);
-OL_DEVICE_INFO_SIZE_TEST_NONZERO(ProductName, OL_DEVICE_INFO_PRODUCT_NAME);
-OL_DEVICE_INFO_SIZE_TEST_NONZERO(UID, OL_DEVICE_INFO_UID);
-OL_DEVICE_INFO_SIZE_TEST_NONZERO(Vendor, OL_DEVICE_INFO_VENDOR);
-OL_DEVICE_INFO_SIZE_TEST_NONZERO(DriverVersion, OL_DEVICE_INFO_DRIVER_VERSION);
-OL_DEVICE_INFO_SIZE_TEST_EQ(MaxWorkGroupSize, uint32_t,
- OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE);
-OL_DEVICE_INFO_SIZE_TEST_EQ(MaxWorkSize, uint32_t,
- OL_DEVICE_INFO_MAX_WORK_SIZE);
-OL_DEVICE_INFO_SIZE_TEST_EQ(VendorId, uint32_t, OL_DEVICE_INFO_VENDOR_ID);
-OL_DEVICE_INFO_SIZE_TEST_EQ(NumComputeUnits, uint32_t,
- OL_DEVICE_INFO_NUM_COMPUTE_UNITS);
-OL_DEVICE_INFO_SIZE_TEST_EQ(SingleFPConfig, ol_device_fp_capability_flags_t,
- OL_DEVICE_INFO_SINGLE_FP_CONFIG);
-OL_DEVICE_INFO_SIZE_TEST_EQ(HalfFPConfig, ol_device_fp_capability_flags_t,
- OL_DEVICE_INFO_HALF_FP_CONFIG);
-OL_DEVICE_INFO_SIZE_TEST_EQ(DoubleFPConfig, ol_device_fp_capability_flags_t,
- OL_DEVICE_INFO_DOUBLE_FP_CONFIG);
-OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthChar, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR);
-OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthShort, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT);
-OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthInt, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT);
-OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthLong, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG);
-OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthFloat, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT);
-OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthDouble, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE);
-OL_DEVICE_INFO_SIZE_TEST_EQ(NativeVectorWidthHalf, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF);
-OL_DEVICE_INFO_SIZE_TEST_EQ(MaxClockFrequency, uint32_t,
- OL_DEVICE_INFO_MAX_CLOCK_FREQUENCY);
-OL_DEVICE_INFO_SIZE_TEST_EQ(MemoryClockRate, uint32_t,
- OL_DEVICE_INFO_MEMORY_CLOCK_RATE);
-OL_DEVICE_INFO_SIZE_TEST_EQ(AddressBits, uint32_t, OL_DEVICE_INFO_ADDRESS_BITS);
-OL_DEVICE_INFO_SIZE_TEST_EQ(MaxMemAllocSize, uint64_t,
- OL_DEVICE_INFO_MAX_MEM_ALLOC_SIZE);
-OL_DEVICE_INFO_SIZE_TEST_EQ(GlobalMemSize, uint64_t,
- OL_DEVICE_INFO_GLOBAL_MEM_SIZE);
-OL_DEVICE_INFO_SIZE_TEST_EQ(SharedMemSize, uint64_t,
- OL_DEVICE_INFO_WORK_GROUP_LOCAL_MEM_SIZE);
+TEST_P(olGetDeviceInfoSizeEqualTest, Success) {
+ size_t Size = 0;
+ ASSERT_SUCCESS(olGetDeviceInfoSize(Device, Property, &Size));
+ ASSERT_EQ(PropertySize, Size);
+}
+
+TEST_P(olGetDeviceInfoSizeNonZeroTest, Success) {
+ size_t Size = 0;
+ ASSERT_SUCCESS(olGetDeviceInfoSize(Device, Property, &Size));
+ ASSERT_NE(Size, 0ul);
+}
TEST_P(olGetDeviceInfoSizeTest, SuccessMaxWorkGroupSizePerDimension) {
size_t Size = 0;
diff --git a/offload/unittests/OffloadAPI/device/olGetHostInfo.cpp b/offload/unittests/OffloadAPI/device/olGetHostInfo.cpp
deleted file mode 100644
index debd29e0bb190..0000000000000
--- a/offload/unittests/OffloadAPI/device/olGetHostInfo.cpp
+++ /dev/null
@@ -1,195 +0,0 @@
-//===------- Offload API tests - olGetHostInfo ---------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "../common/Fixtures.hpp"
-#include <OffloadAPI.h>
-#include <gtest/gtest.h>
-
-using olGetHostInfoTest = OffloadTest;
-
-#define OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Dev, \
- Expr) \
- TEST_F(olGetHostInfoTest, Test##Dev##TestName) { \
- PropType Value; \
- ASSERT_SUCCESS(olGetDeviceInfo(Dev, PropName, sizeof(Value), &Value)); \
- Expr; \
- }
-
-#define OL_DEVICE_INFO_TEST_HOST_SUCCESS(TestName, PropType, PropName) \
- OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Host, {})
-
-#define OL_DEVICE_INFO_TEST_HOST_VALUE_GT(TestName, PropType, PropName, \
- LowBound) \
- OL_DEVICE_INFO_TEST_SUCCESS_CHECK(TestName, PropType, PropName, Host, \
- ASSERT_GT(Value, LowBound))
-
-TEST_F(olGetHostInfoTest, HostSuccessType) {
- ol_device_type_t DeviceType;
- ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_TYPE,
- sizeof(ol_device_type_t), &DeviceType));
- ASSERT_EQ(DeviceType, OL_DEVICE_TYPE_HOST);
-}
-
-TEST_F(olGetHostInfoTest, SuccessHostPlatform) {
- ol_platform_handle_t Platform = nullptr;
- ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_PLATFORM,
- sizeof(ol_platform_handle_t), &Platform));
- ASSERT_NE(Platform, nullptr);
-}
-
-TEST_F(olGetHostInfoTest, HostName) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_NAME, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> Name;
- Name.resize(Size);
- ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_NAME, Size, Name.data()));
- ASSERT_EQ(std::strlen(Name.data()), Size - 1);
-}
-
-TEST_F(olGetHostInfoTest, HostProductName) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_PRODUCT_NAME, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> Name;
- Name.resize(Size);
- ASSERT_SUCCESS(
- olGetDeviceInfo(Host, OL_DEVICE_INFO_PRODUCT_NAME, Size, Name.data()));
- ASSERT_EQ(std::strlen(Name.data()), Size - 1);
-}
-
-TEST_F(olGetHostInfoTest, HostUID) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_UID, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> UID;
- UID.resize(Size);
- ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_UID, Size, UID.data()));
- ASSERT_EQ(std::strlen(UID.data()), Size - 1);
-}
-
-TEST_F(olGetHostInfoTest, SuccessHostVendor) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_VENDOR, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> Vendor;
- Vendor.resize(Size);
- ASSERT_SUCCESS(
- olGetDeviceInfo(Host, OL_DEVICE_INFO_VENDOR, Size, Vendor.data()));
- ASSERT_EQ(std::strlen(Vendor.data()), Size - 1);
-}
-
-TEST_F(olGetHostInfoTest, SuccessHostDriverVersion) {
- size_t Size = 0;
- ASSERT_SUCCESS(
- olGetDeviceInfoSize(Host, OL_DEVICE_INFO_DRIVER_VERSION, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> DriverVersion;
- DriverVersion.resize(Size);
- ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_DRIVER_VERSION, Size,
- DriverVersion.data()));
- ASSERT_EQ(std::strlen(DriverVersion.data()), Size - 1);
-}
-
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(MaxWorkGroupSize, uint32_t,
- OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE, 0);
-
-TEST_F(olGetHostInfoTest, SuccessHostMaxWorkGroupSizePerDimension) {
- ol_dimensions_t Value{0, 0, 0};
- ASSERT_SUCCESS(
- olGetDeviceInfo(Host, OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE_PER_DIMENSION,
- sizeof(Value), &Value));
- ASSERT_GT(Value.x, 0u);
- ASSERT_GT(Value.y, 0u);
- ASSERT_GT(Value.z, 0u);
-}
-
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(MaxWorkSize, uint32_t,
- OL_DEVICE_INFO_MAX_WORK_SIZE, 0);
-
-TEST_F(olGetHostInfoTest, SuccessHostMaxWorkSizePerDimension) {
- ol_dimensions_t Value{0, 0, 0};
- ASSERT_SUCCESS(olGetDeviceInfo(
- Host, OL_DEVICE_INFO_MAX_WORK_SIZE_PER_DIMENSION, sizeof(Value), &Value));
- ASSERT_GT(Value.x, 0u);
- ASSERT_GT(Value.y, 0u);
- ASSERT_GT(Value.z, 0u);
-}
-
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(VendorId, uint32_t, OL_DEVICE_INFO_VENDOR_ID,
- 0);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NumComputeUnits, uint32_t,
- OL_DEVICE_INFO_NUM_COMPUTE_UNITS, 0);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(SingleFPConfig,
- ol_device_fp_capability_flags_t,
- OL_DEVICE_INFO_SINGLE_FP_CONFIG, 0);
-OL_DEVICE_INFO_TEST_HOST_SUCCESS(HalfFPConfig, ol_device_fp_capability_flags_t,
- OL_DEVICE_INFO_HALF_FP_CONFIG);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(DoubleFPConfig,
- ol_device_fp_capability_flags_t,
- OL_DEVICE_INFO_DOUBLE_FP_CONFIG, 0);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NativeVectorWidthChar, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_CHAR, 0);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NativeVectorWidthShort, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_SHORT, 0);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NativeVectorWidthInt, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_INT, 0);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NativeVectorWidthLong, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_LONG, 0);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NativeVectorWidthFloat, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_FLOAT, 0);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(NativeVectorWidthDouble, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_DOUBLE, 0);
-OL_DEVICE_INFO_TEST_HOST_SUCCESS(NativeVectorWidthHalf, uint32_t,
- OL_DEVICE_INFO_NATIVE_VECTOR_WIDTH_HALF);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(MaxClockFrequency, uint32_t,
- OL_DEVICE_INFO_MAX_CLOCK_FREQUENCY, 0);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(MemoryClockRate, uint32_t,
- OL_DEVICE_INFO_MEMORY_CLOCK_RATE, 0);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(AddressBits, uint32_t,
- OL_DEVICE_INFO_ADDRESS_BITS, 0);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(MaxMemAllocSize, uint64_t,
- OL_DEVICE_INFO_MAX_MEM_ALLOC_SIZE, 0);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(GlobalMemSize, uint64_t,
- OL_DEVICE_INFO_GLOBAL_MEM_SIZE, 0);
-OL_DEVICE_INFO_TEST_HOST_VALUE_GT(SharedMemSize, uint64_t,
- OL_DEVICE_INFO_WORK_GROUP_LOCAL_MEM_SIZE, 0);
-
-TEST_F(olGetHostInfoTest, InvalidNullHandleDevice) {
- ol_device_type_t DeviceType;
- ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
- olGetDeviceInfo(nullptr, OL_DEVICE_INFO_TYPE,
- sizeof(ol_device_type_t), &DeviceType));
-}
-
-TEST_F(olGetHostInfoTest, InvalidEnumerationInfoType) {
- ol_device_type_t DeviceType;
- ASSERT_ERROR(OL_ERRC_INVALID_ENUMERATION,
- olGetDeviceInfo(Host, OL_DEVICE_INFO_FORCE_UINT32,
- sizeof(ol_device_type_t), &DeviceType));
-}
-
-TEST_F(olGetHostInfoTest, InvalidSizePropSize) {
- ol_device_type_t DeviceType;
- ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
- olGetDeviceInfo(Host, OL_DEVICE_INFO_TYPE, 0, &DeviceType));
-}
-
-TEST_F(olGetHostInfoTest, InvalidSizePropSizeSmall) {
- ol_device_type_t DeviceType;
- ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
- olGetDeviceInfo(Host, OL_DEVICE_INFO_TYPE,
- sizeof(DeviceType) - 1, &DeviceType));
-}
-
-TEST_F(olGetHostInfoTest, InvalidNullPointerPropValue) {
- ol_device_type_t DeviceType;
- ASSERT_ERROR(
- OL_ERRC_INVALID_NULL_POINTER,
- olGetDeviceInfo(Host, OL_DEVICE_INFO_TYPE, sizeof(DeviceType), nullptr));
-}
diff --git a/offload/unittests/OffloadAPI/memory/olGetMemInfo.cpp b/offload/unittests/OffloadAPI/memory/olGetMemInfo.cpp
index a4b382ff298ad..ba1d52cdc7edd 100644
--- a/offload/unittests/OffloadAPI/memory/olGetMemInfo.cpp
+++ b/offload/unittests/OffloadAPI/memory/olGetMemInfo.cpp
@@ -6,94 +6,76 @@
//
//===----------------------------------------------------------------------===//
-#include "../common/Fixtures.hpp"
+#include "../common/Properties.hpp"
#include <OffloadAPI.h>
#include <gtest/gtest.h>
constexpr size_t SIZE = 1024;
-struct olGetMemInfoBaseTest : OffloadDeviceTest {
- void *OffsetPtr() { return &reinterpret_cast<char *>(Ptr)[123]; }
+struct olGetMemInfoAllocTypeTest : OffloadDeviceTestWithParam<ol_alloc_type_t> {
+ void SetUp() override {
+ RETURN_ON_FATAL_FAILURE(
+ OffloadDeviceTestWithParam<ol_alloc_type_t>::SetUp());
+ ASSERT_SUCCESS(olMemAlloc(Device, getTestParam(), SIZE, &Ptr));
+ }
+
+ void TearDown() override {
+ ASSERT_SUCCESS(olMemFree(Ptr));
+ RETURN_ON_FATAL_FAILURE(
+ OffloadDeviceTestWithParam<ol_alloc_type_t>::TearDown());
+ }
void *Ptr;
};
-template <ol_alloc_type_t AllocType>
-struct olGetMemInfoTest : olGetMemInfoBaseTest {
+struct olGetMemInfoTest : OffloadDeviceTest {
void SetUp() override {
RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::SetUp());
- ASSERT_SUCCESS(olMemAlloc(Device, AllocType, SIZE, &Ptr));
+ ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, SIZE, &Ptr));
}
void TearDown() override {
ASSERT_SUCCESS(olMemFree(Ptr));
RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::TearDown());
}
+
+ void *Ptr;
};
-using olGetMemInfoDeviceTest = olGetMemInfoTest<OL_ALLOC_TYPE_DEVICE>;
-OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoDeviceTest);
-using olGetMemInfoManagedTest = olGetMemInfoTest<OL_ALLOC_TYPE_MANAGED>;
-OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoManagedTest);
-using olGetMemInfoHostTest = olGetMemInfoTest<OL_ALLOC_TYPE_HOST>;
-OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoHostTest);
-
-#define PER_ALLOC_TEST(FUNCTION) \
- TEST_P(olGetMemInfoDeviceTest, FUNCTION) { \
- FUNCTION(this, Ptr, OL_ALLOC_TYPE_DEVICE); \
- } \
- TEST_P(olGetMemInfoManagedTest, FUNCTION) { \
- FUNCTION(this, Ptr, OL_ALLOC_TYPE_MANAGED); \
- } \
- TEST_P(olGetMemInfoHostTest, FUNCTION) { \
- FUNCTION(this, OffsetPtr(), OL_ALLOC_TYPE_HOST); \
- } \
- TEST_P(olGetMemInfoDeviceTest, FUNCTION##Offset) { \
- FUNCTION(this, Ptr, OL_ALLOC_TYPE_DEVICE); \
- } \
- TEST_P(olGetMemInfoManagedTest, FUNCTION##Offset) { \
- FUNCTION(this, OffsetPtr(), OL_ALLOC_TYPE_MANAGED); \
- } \
- TEST_P(olGetMemInfoHostTest, FUNCTION##Offset) { \
- FUNCTION(this, OffsetPtr(), OL_ALLOC_TYPE_HOST); \
- }
-void SuccessDevice(olGetMemInfoBaseTest *Fixture, void *Ptr,
- ol_alloc_type_t Type) {
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM(
+ olGetMemInfoAllocTypeTest, AllocTypes,
+ defaultPrinterWithParam<ol_alloc_type_t>);
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoTest);
+
+TEST_P(olGetMemInfoAllocTypeTest, SuccessDevice) {
ol_device_handle_t RetrievedDevice;
- ASSERT_SUCCESS(olGetMemInfo(Fixture->Ptr, OL_MEM_INFO_DEVICE,
- sizeof(RetrievedDevice), &RetrievedDevice));
- ASSERT_EQ(RetrievedDevice, Fixture->Device);
+ ASSERT_SUCCESS(olGetMemInfo(Ptr, OL_MEM_INFO_DEVICE, sizeof(RetrievedDevice),
+ &RetrievedDevice));
+ ASSERT_EQ(RetrievedDevice, Device);
}
-PER_ALLOC_TEST(SuccessDevice);
-void SuccessBase(olGetMemInfoBaseTest *Fixture, void *Ptr,
- ol_alloc_type_t Type) {
+TEST_P(olGetMemInfoAllocTypeTest, SuccessBase) {
void *RetrievedBase;
- ASSERT_SUCCESS(olGetMemInfo(Fixture->Ptr, OL_MEM_INFO_BASE,
- sizeof(RetrievedBase), &RetrievedBase));
- ASSERT_EQ(RetrievedBase, Fixture->Ptr);
+ ASSERT_SUCCESS(olGetMemInfo(Ptr, OL_MEM_INFO_BASE, sizeof(RetrievedBase),
+ &RetrievedBase));
+ ASSERT_EQ(RetrievedBase, Ptr);
}
-PER_ALLOC_TEST(SuccessBase);
-void SuccessSize(olGetMemInfoBaseTest *Fixture, void *Ptr,
- ol_alloc_type_t Type) {
+TEST_P(olGetMemInfoAllocTypeTest, SuccessSize) {
size_t RetrievedSize;
- ASSERT_SUCCESS(olGetMemInfo(Fixture->Ptr, OL_MEM_INFO_SIZE,
- sizeof(RetrievedSize), &RetrievedSize));
+ ASSERT_SUCCESS(olGetMemInfo(Ptr, OL_MEM_INFO_SIZE, sizeof(RetrievedSize),
+ &RetrievedSize));
ASSERT_EQ(RetrievedSize, SIZE);
}
-PER_ALLOC_TEST(SuccessSize);
-void SuccessType(olGetMemInfoBaseTest *Fixture, void *Ptr,
- ol_alloc_type_t Type) {
+TEST_P(olGetMemInfoAllocTypeTest, SuccessType) {
ol_alloc_type_t RetrievedType;
- ASSERT_SUCCESS(olGetMemInfo(Fixture->Ptr, OL_MEM_INFO_TYPE,
- sizeof(RetrievedType), &RetrievedType));
- ASSERT_EQ(RetrievedType, Type);
+ ASSERT_SUCCESS(olGetMemInfo(Ptr, OL_MEM_INFO_TYPE, sizeof(RetrievedType),
+ &RetrievedType));
+ ASSERT_EQ(RetrievedType, getTestParam());
}
-PER_ALLOC_TEST(SuccessType);
-TEST_P(olGetMemInfoDeviceTest, InvalidNotFound) {
+TEST_P(olGetMemInfoTest, InvalidNotFound) {
// Assuming that we aren't unlucky and happen to get 0x1234 as a random
// pointer
void *RetrievedBase;
@@ -102,27 +84,27 @@ TEST_P(olGetMemInfoDeviceTest, InvalidNotFound) {
sizeof(RetrievedBase), &RetrievedBase));
}
-TEST_P(olGetMemInfoDeviceTest, InvalidNullPtr) {
+TEST_P(olGetMemInfoTest, InvalidNullPtr) {
ol_device_handle_t RetrievedDevice;
ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
olGetMemInfo(nullptr, OL_MEM_INFO_DEVICE,
sizeof(RetrievedDevice), &RetrievedDevice));
}
-TEST_P(olGetMemInfoDeviceTest, InvalidSizeZero) {
+TEST_P(olGetMemInfoTest, InvalidSizeZero) {
ol_device_handle_t RetrievedDevice;
ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
olGetMemInfo(Ptr, OL_MEM_INFO_DEVICE, 0, &RetrievedDevice));
}
-TEST_P(olGetMemInfoDeviceTest, InvalidSizeSmall) {
+TEST_P(olGetMemInfoTest, InvalidSizeSmall) {
ol_device_handle_t RetrievedDevice;
ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
olGetMemInfo(Ptr, OL_MEM_INFO_DEVICE,
sizeof(RetrievedDevice) - 1, &RetrievedDevice));
}
-TEST_P(olGetMemInfoDeviceTest, InvalidNullPointerPropValue) {
+TEST_P(olGetMemInfoTest, InvalidNullPointerPropValue) {
ol_device_handle_t RetrievedDevice;
ASSERT_ERROR(
OL_ERRC_INVALID_NULL_POINTER,
diff --git a/offload/unittests/OffloadAPI/memory/olGetMemInfoSize.cpp b/offload/unittests/OffloadAPI/memory/olGetMemInfoSize.cpp
index f1a1e790fb22f..7e0ffaacea19d 100644
--- a/offload/unittests/OffloadAPI/memory/olGetMemInfoSize.cpp
+++ b/offload/unittests/OffloadAPI/memory/olGetMemInfoSize.cpp
@@ -8,7 +8,27 @@
#include <OffloadAPI.h>
-#include "../common/Fixtures.hpp"
+#include "../common/Properties.hpp"
+
+struct olGetMemInfoSizeTypesTest : olPropertyTest<ol_mem_info_t> {
+ void *OffsetPtr() { return &reinterpret_cast<char *>(Ptr)[123]; }
+
+ void SetUp() override {
+ RETURN_ON_FATAL_FAILURE(olPropertyTest<ol_mem_info_t>::SetUp());
+ ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, 0x1024, &Ptr));
+ }
+
+ void TearDown() override {
+ ASSERT_SUCCESS(olMemFree(Ptr));
+ RETURN_ON_FATAL_FAILURE(olPropertyTest<ol_mem_info_t>::TearDown());
+ }
+
+ void *Ptr;
+};
+
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM(
+ olGetMemInfoSizeTypesTest, MemInfoSizeProperties,
+ defaultPropertyTestPrinter<ol_mem_info_t>);
struct olGetMemInfoSizeTest : OffloadDeviceTest {
void *OffsetPtr() { return &reinterpret_cast<char *>(Ptr)[123]; }
@@ -25,30 +45,13 @@ struct olGetMemInfoSizeTest : OffloadDeviceTest {
void *Ptr;
};
-OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoSizeTest);
-
-TEST_P(olGetMemInfoSizeTest, SuccessDevice) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetMemInfoSize(Ptr, OL_MEM_INFO_DEVICE, &Size));
- ASSERT_EQ(Size, sizeof(ol_device_handle_t));
-}
-TEST_P(olGetMemInfoSizeTest, SuccessBase) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetMemInfoSize(Ptr, OL_MEM_INFO_BASE, &Size));
- ASSERT_EQ(Size, sizeof(void *));
-}
-
-TEST_P(olGetMemInfoSizeTest, SuccessSize) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetMemInfoSize(Ptr, OL_MEM_INFO_SIZE, &Size));
- ASSERT_EQ(Size, sizeof(size_t));
-}
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetMemInfoSizeTest);
-TEST_P(olGetMemInfoSizeTest, SuccessType) {
+TEST_P(olGetMemInfoSizeTypesTest, Success) {
size_t Size = 0;
- ASSERT_SUCCESS(olGetMemInfoSize(Ptr, OL_MEM_INFO_TYPE, &Size));
- ASSERT_EQ(Size, sizeof(ol_alloc_type_t));
+ ASSERT_SUCCESS(olGetMemInfoSize(Ptr, Property, &Size));
+ ASSERT_EQ(Size, PropertySize);
}
TEST_P(olGetMemInfoSizeTest, InvalidSymbolInfoEnumeration) {
diff --git a/offload/unittests/OffloadAPI/memory/olMemAlloc.cpp b/offload/unittests/OffloadAPI/memory/olMemAlloc.cpp
index 445262aa0c583..08e95b6dfe7c8 100644
--- a/offload/unittests/OffloadAPI/memory/olMemAlloc.cpp
+++ b/offload/unittests/OffloadAPI/memory/olMemAlloc.cpp
@@ -6,44 +6,32 @@
//
//===----------------------------------------------------------------------===//
-#include "../common/Fixtures.hpp"
+#include "../common/Properties.hpp"
#include <OffloadAPI.h>
#include <gtest/gtest.h>
using olMemAllocTest = OffloadDeviceTest;
OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olMemAllocTest);
-TEST_P(olMemAllocTest, SuccessAllocManaged) {
- void *Alloc = nullptr;
- ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED, 1024, &Alloc));
- ASSERT_NE(Alloc, nullptr);
- olMemFree(Alloc);
-}
-
-TEST_P(olMemAllocTest, SuccessAllocHost) {
- void *Alloc = nullptr;
- ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_HOST, 1024, &Alloc));
- ASSERT_NE(Alloc, nullptr);
- olMemFree(Alloc);
-}
+using olMemAllocAllocTypesTest = OffloadDeviceTestWithParam<ol_alloc_type_t>;
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM(
+ olMemAllocAllocTypesTest, AllocTypes,
+ defaultPrinterWithParam<ol_alloc_type_t>); // printerMine);
-TEST_P(olMemAllocTest, SuccessAllocDevice) {
+TEST_P(olMemAllocAllocTypesTest, Success) {
void *Alloc = nullptr;
- ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, 1024, &Alloc));
+ ASSERT_SUCCESS(olMemAlloc(Device, getTestParam(), 1024, &Alloc));
ASSERT_NE(Alloc, nullptr);
olMemFree(Alloc);
}
TEST_P(olMemAllocTest, SuccessAllocMany) {
std::vector<void *> Allocs;
- Allocs.reserve(1000);
-
- constexpr ol_alloc_type_t TYPES[3] = {
- OL_ALLOC_TYPE_DEVICE, OL_ALLOC_TYPE_MANAGED, OL_ALLOC_TYPE_HOST};
+ Allocs.reserve(TestAllocsNum);
- for (size_t I = 1; I < 1000; I++) {
+ for (size_t I = 1; I < TestAllocsNum; I++) {
void *Alloc = nullptr;
- ASSERT_SUCCESS(olMemAlloc(Device, TYPES[I % 3], 1024 * I, &Alloc));
+ ASSERT_SUCCESS(olMemAlloc(Device, AllocTypes[I % 3], 1024 * I, &Alloc));
ASSERT_NE(Alloc, nullptr);
Allocs.push_back(Alloc);
diff --git a/offload/unittests/OffloadAPI/memory/olMemAllocAligned.cpp b/offload/unittests/OffloadAPI/memory/olMemAllocAligned.cpp
index 18feafbf2b325..40d198747fb94 100644
--- a/offload/unittests/OffloadAPI/memory/olMemAllocAligned.cpp
+++ b/offload/unittests/OffloadAPI/memory/olMemAllocAligned.cpp
@@ -6,27 +6,27 @@
//
//===----------------------------------------------------------------------===//
-#include "../common/Fixtures.hpp"
+#include "../common/Properties.hpp"
#include <OffloadAPI.h>
#include <gtest/gtest.h>
using olMemAllocAlignedTest = OffloadDeviceTest;
-
OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olMemAllocAlignedTest);
+using olMemAllocAlignedTypesTest = OffloadDeviceTestWithParam<ol_alloc_type_t>;
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM(
+ olMemAllocAlignedTypesTest, AllocTypes,
+ defaultPrinterWithParam<ol_alloc_type_t>);
+
constexpr size_t DefaultAlignment = 16;
-constexpr size_t TestAllocsNum = 1000;
TEST_P(olMemAllocAlignedTest, SuccessAllocMany) {
std::vector<void *> Allocs;
- Allocs.reserve(1000);
-
- constexpr ol_alloc_type_t TYPES[3] = {
- OL_ALLOC_TYPE_DEVICE, OL_ALLOC_TYPE_MANAGED, OL_ALLOC_TYPE_HOST};
+ Allocs.reserve(TestAllocsNum);
for (size_t I = 1; I < TestAllocsNum; I++) {
void *Alloc = nullptr;
- ASSERT_SUCCESS(olMemAllocAligned(Device, TYPES[I % 3], 1024 * I,
+ ASSERT_SUCCESS(olMemAllocAligned(Device, AllocTypes[I % 3], 1024 * I,
DefaultAlignment, &Alloc));
ASSERT_NE(Alloc, nullptr);
@@ -80,110 +80,23 @@ TEST_P(olMemAllocAlignedTest, CudaExceedDefaultAlignment) {
ASSERT_EQ(Alloc, nullptr);
}
-TEST_P(olMemAllocAlignedTest, SuccessAllocManagedDifferentAlignments) {
- void *Alloc = nullptr;
- size_t NumAlignments = 6;
- size_t Alignments[] = {8, 16, 32, 64, 128, 256};
- size_t Alignment;
-
- for (size_t i = 0; i < NumAlignments; i++) {
- Alignment = Alignments[i];
- SCOPED_TRACE("alignment: " + std::to_string(Alignment));
- ASSERT_SUCCESS(olMemAllocAligned(Device, OL_ALLOC_TYPE_MANAGED, 1024,
- Alignment, &Alloc));
- ASSERT_NE(Alloc, nullptr);
- olMemFree(Alloc);
- }
-}
-
-TEST_P(olMemAllocAlignedTest, SuccessAllocHostDifferentAlignments) {
+TEST_P(olMemAllocAlignedTypesTest, SuccessAllocDifferentAlignments) {
void *Alloc = nullptr;
- size_t NumAlignments = 6;
size_t Alignments[] = {8, 16, 32, 64, 128, 256};
+ size_t NumAlignments = sizeof(Alignments) / sizeof(Alignments[0]);
size_t Alignment;
for (size_t i = 0; i < NumAlignments; i++) {
Alignment = Alignments[i];
SCOPED_TRACE("alignment: " + std::to_string(Alignment));
ASSERT_SUCCESS(
- olMemAllocAligned(Device, OL_ALLOC_TYPE_HOST, 1024, Alignment, &Alloc));
- ASSERT_NE(Alloc, nullptr);
- olMemFree(Alloc);
- }
-}
-
-TEST_P(olMemAllocAlignedTest, SuccessAllocDeviceDifferentAlignments) {
- void *Alloc = nullptr;
- size_t NumAlignments = 6;
- size_t Alignments[] = {8, 16, 32, 64, 128, 256};
- size_t Alignment;
-
- for (size_t i = 0; i < NumAlignments; i++) {
- Alignment = Alignments[i];
- SCOPED_TRACE("alignment: " + std::to_string(Alignment));
- ASSERT_SUCCESS(olMemAllocAligned(Device, OL_ALLOC_TYPE_DEVICE, 1024,
- Alignment, &Alloc));
+ olMemAllocAligned(Device, getTestParam(), 1024, Alignment, &Alloc));
ASSERT_NE(Alloc, nullptr);
-
olMemFree(Alloc);
}
}
-TEST_P(olMemAllocAlignedTest, SuccessMemcpyManagedDiferentAlignments) {
- constexpr size_t Size = 1024;
- void *Alloc;
- std::vector<uint8_t> Input(Size, 42);
- std::vector<uint8_t> Output(Size, 0);
-
- size_t NumAlignments = 6;
- size_t Alignments[] = {8, 16, 32, 64, 128, 256};
- size_t Alignment;
- for (size_t i = 0; i < NumAlignments; i++) {
- Alignment = Alignments[i];
- SCOPED_TRACE("alignment: " + std::to_string(Alignment));
-
- ASSERT_SUCCESS(olMemAllocAligned(Device, OL_ALLOC_TYPE_MANAGED, Size,
- Alignment, &Alloc));
- // memcpy is synchronous when queue is unspecified.
- ASSERT_SUCCESS(olMemcpy(nullptr, Alloc, Device, Input.data(), Host, Size));
- ASSERT_SUCCESS(olMemcpy(nullptr, Output.data(), Host, Alloc, Device, Size));
-
- for (uint8_t Val : Output) {
- ASSERT_EQ(Val, 42);
- }
-
- ASSERT_SUCCESS(olMemFree(Alloc));
- }
-}
-
-TEST_P(olMemAllocAlignedTest, SuccessMemcpyDeviceDiferentAlignments) {
- constexpr size_t Size = 1024;
- void *Alloc;
- std::vector<uint8_t> Input(Size, 42);
- std::vector<uint8_t> Output(Size, 0);
-
- size_t NumAlignments = 6;
- size_t Alignments[] = {8, 16, 32, 64, 128, 256};
- size_t Alignment;
- for (size_t i = 0; i < NumAlignments; i++) {
- Alignment = Alignments[i];
- SCOPED_TRACE("alignment: " + std::to_string(Alignment));
-
- ASSERT_SUCCESS(olMemAllocAligned(Device, OL_ALLOC_TYPE_DEVICE, Size,
- Alignment, &Alloc));
- // memcpy is synchronous when queue is unspecified.
- ASSERT_SUCCESS(olMemcpy(nullptr, Alloc, Device, Input.data(), Host, Size));
- ASSERT_SUCCESS(olMemcpy(nullptr, Output.data(), Host, Alloc, Device, Size));
-
- for (uint8_t Val : Output) {
- ASSERT_EQ(Val, 42);
- }
-
- ASSERT_SUCCESS(olMemFree(Alloc));
- }
-}
-
-TEST_P(olMemAllocAlignedTest, SuccessMemcpyHostDiferentAlignments) {
+TEST_P(olMemAllocAlignedTypesTest, SuccessMemcpyDiferentAlignments) {
constexpr size_t Size = 1024;
void *Alloc;
std::vector<uint8_t> Input(Size, 42);
@@ -197,7 +110,7 @@ TEST_P(olMemAllocAlignedTest, SuccessMemcpyHostDiferentAlignments) {
SCOPED_TRACE("alignment: " + std::to_string(Alignment));
ASSERT_SUCCESS(
- olMemAllocAligned(Device, OL_ALLOC_TYPE_HOST, Size, Alignment, &Alloc));
+ olMemAllocAligned(Device, getTestParam(), Size, Alignment, &Alloc));
// memcpy is synchronous when queue is unspecified.
ASSERT_SUCCESS(olMemcpy(nullptr, Alloc, Device, Input.data(), Host, Size));
ASSERT_SUCCESS(olMemcpy(nullptr, Output.data(), Host, Alloc, Device, Size));
diff --git a/offload/unittests/OffloadAPI/memory/olMemFree.cpp b/offload/unittests/OffloadAPI/memory/olMemFree.cpp
index dfaf9bdef3189..54782396008ed 100644
--- a/offload/unittests/OffloadAPI/memory/olMemFree.cpp
+++ b/offload/unittests/OffloadAPI/memory/olMemFree.cpp
@@ -6,28 +6,21 @@
//
//===----------------------------------------------------------------------===//
-#include "../common/Fixtures.hpp"
+#include "../common/Properties.hpp"
#include <OffloadAPI.h>
#include <gtest/gtest.h>
using olMemFreeTest = OffloadDeviceTest;
OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olMemFreeTest);
-TEST_P(olMemFreeTest, SuccessFreeManaged) {
- void *Alloc = nullptr;
- ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_MANAGED, 1024, &Alloc));
- ASSERT_SUCCESS(olMemFree(Alloc));
-}
-
-TEST_P(olMemFreeTest, SuccessFreeHost) {
- void *Alloc = nullptr;
- ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_HOST, 1024, &Alloc));
- ASSERT_SUCCESS(olMemFree(Alloc));
-}
+using olMemFreeAllocTypesTest = OffloadDeviceTestWithParam<ol_alloc_type_t>;
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM(
+ olMemFreeAllocTypesTest, AllocTypes,
+ defaultPrinterWithParam<ol_alloc_type_t>);
-TEST_P(olMemFreeTest, SuccessFreeDevice) {
+TEST_P(olMemFreeAllocTypesTest, Success) {
void *Alloc = nullptr;
- ASSERT_SUCCESS(olMemAlloc(Device, OL_ALLOC_TYPE_DEVICE, 1024, &Alloc));
+ ASSERT_SUCCESS(olMemAlloc(Device, getTestParam(), 1024, &Alloc));
ASSERT_SUCCESS(olMemFree(Alloc));
}
diff --git a/offload/unittests/OffloadAPI/platform/olGetPlatformInfo.cpp b/offload/unittests/OffloadAPI/platform/olGetPlatformInfo.cpp
index 862b008fb9e85..f95ecd21e1232 100644
--- a/offload/unittests/OffloadAPI/platform/olGetPlatformInfo.cpp
+++ b/offload/unittests/OffloadAPI/platform/olGetPlatformInfo.cpp
@@ -8,46 +8,28 @@
#include <OffloadAPI.h>
-#include "../common/Fixtures.hpp"
+#include "../common/Properties.hpp"
using olGetPlatformInfoTest = OffloadPlatformTest;
OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetPlatformInfoTest);
-TEST_P(olGetPlatformInfoTest, SuccessName) {
+using olGetPlatformInfoNamesTest =
+ OffloadPlatformTestWithParam<ol_platform_info_t>;
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM(
+ olGetPlatformInfoNamesTest, PlatformInfoNames,
+ defaultPrinterWithParam<ol_platform_info_t>);
+
+TEST_P(olGetPlatformInfoNamesTest, SuccessName) {
size_t Size = 0;
- ASSERT_SUCCESS(olGetPlatformInfoSize(Platform, OL_PLATFORM_INFO_NAME, &Size));
+ ASSERT_SUCCESS(olGetPlatformInfoSize(Platform, getTestParam(), &Size));
ASSERT_GT(Size, 0ul);
std::vector<char> Name;
Name.resize(Size);
ASSERT_SUCCESS(
- olGetPlatformInfo(Platform, OL_PLATFORM_INFO_NAME, Size, Name.data()));
+ olGetPlatformInfo(Platform, getTestParam(), Size, Name.data()));
ASSERT_EQ(std::strlen(Name.data()), Size - 1);
}
-TEST_P(olGetPlatformInfoTest, SuccessVendorName) {
- size_t Size = 0;
- ASSERT_SUCCESS(
- olGetPlatformInfoSize(Platform, OL_PLATFORM_INFO_VENDOR_NAME, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> VendorName;
- VendorName.resize(Size);
- ASSERT_SUCCESS(olGetPlatformInfo(Platform, OL_PLATFORM_INFO_VENDOR_NAME, Size,
- VendorName.data()));
- ASSERT_EQ(std::strlen(VendorName.data()), Size - 1);
-}
-
-TEST_P(olGetPlatformInfoTest, SuccessVersion) {
- size_t Size = 0;
- ASSERT_SUCCESS(
- olGetPlatformInfoSize(Platform, OL_PLATFORM_INFO_VERSION, &Size));
- ASSERT_GT(Size, 0ul);
- std::vector<char> Version;
- Version.resize(Size);
- ASSERT_SUCCESS(olGetPlatformInfo(Platform, OL_PLATFORM_INFO_VERSION, Size,
- Version.data()));
- ASSERT_EQ(std::strlen(Version.data()), Size - 1);
-}
-
TEST_P(olGetPlatformInfoTest, SuccessBackend) {
ol_platform_backend_t Backend;
ASSERT_SUCCESS(olGetPlatformInfo(Platform, OL_PLATFORM_INFO_BACKEND,
diff --git a/offload/unittests/OffloadAPI/platform/olGetPlatformInfoSize.cpp b/offload/unittests/OffloadAPI/platform/olGetPlatformInfoSize.cpp
index 9ed9835ff945e..b7478bc64d2cb 100644
--- a/offload/unittests/OffloadAPI/platform/olGetPlatformInfoSize.cpp
+++ b/offload/unittests/OffloadAPI/platform/olGetPlatformInfoSize.cpp
@@ -8,28 +8,20 @@
#include <OffloadAPI.h>
-#include "../common/Fixtures.hpp"
+#include "../common/Properties.hpp"
using olGetPlatformInfoSizeTest = OffloadPlatformTest;
OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetPlatformInfoSizeTest);
-TEST_P(olGetPlatformInfoSizeTest, SuccessName) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetPlatformInfoSize(Platform, OL_PLATFORM_INFO_NAME, &Size));
- ASSERT_NE(Size, 0ul);
-}
+using olGetPlatformInfoSizeNameTest =
+ OffloadPlatformTestWithParam<ol_platform_info_t>;
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM(
+ olGetPlatformInfoSizeNameTest, PlatformInfoNames,
+ defaultPrinterWithParam<ol_platform_info_t>);
-TEST_P(olGetPlatformInfoSizeTest, SuccessVendorName) {
+TEST_P(olGetPlatformInfoSizeNameTest, Success) {
size_t Size = 0;
- ASSERT_SUCCESS(
- olGetPlatformInfoSize(Platform, OL_PLATFORM_INFO_VENDOR_NAME, &Size));
- ASSERT_NE(Size, 0ul);
-}
-
-TEST_P(olGetPlatformInfoSizeTest, SuccessVersion) {
- size_t Size = 0;
- ASSERT_SUCCESS(
- olGetPlatformInfoSize(Platform, OL_PLATFORM_INFO_VERSION, &Size));
+ ASSERT_SUCCESS(olGetPlatformInfoSize(Platform, getTestParam(), &Size));
ASSERT_NE(Size, 0ul);
}
diff --git a/offload/unittests/OffloadAPI/symbol/olGetSymbolInfoSize.cpp b/offload/unittests/OffloadAPI/symbol/olGetSymbolInfoSize.cpp
index ec011865cc6ad..60c1a6767b13b 100644
--- a/offload/unittests/OffloadAPI/symbol/olGetSymbolInfoSize.cpp
+++ b/offload/unittests/OffloadAPI/symbol/olGetSymbolInfoSize.cpp
@@ -8,38 +8,25 @@
#include <OffloadAPI.h>
-#include "../common/Fixtures.hpp"
+#include "../common/Properties.hpp"
using olGetSymbolInfoSizeKernelTest = OffloadKernelTest;
OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetSymbolInfoSizeKernelTest);
-using olGetSymbolInfoSizeGlobalTest = OffloadGlobalTest;
-OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetSymbolInfoSizeGlobalTest);
+OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE_WITH_PARAM(
+ olGetSymbolInfoSizeGlobalTest, SymbolGlobalProperties,
+ defaultPropertyTestPrinter<ol_symbol_info_t>);
-TEST_P(olGetSymbolInfoSizeKernelTest, SuccessKind) {
+TEST_P(olGetSymbolInfoSizeKernelTest, SuccessPropertySize) {
size_t Size = 0;
ASSERT_SUCCESS(olGetSymbolInfoSize(Kernel, OL_SYMBOL_INFO_KIND, &Size));
ASSERT_EQ(Size, sizeof(ol_symbol_kind_t));
}
-TEST_P(olGetSymbolInfoSizeGlobalTest, SuccessKind) {
+TEST_P(olGetSymbolInfoSizeGlobalTest, SuccessPropertySize) {
size_t Size = 0;
- ASSERT_SUCCESS(olGetSymbolInfoSize(Global, OL_SYMBOL_INFO_KIND, &Size));
- ASSERT_EQ(Size, sizeof(ol_symbol_kind_t));
-}
-
-TEST_P(olGetSymbolInfoSizeGlobalTest, SuccessAddress) {
- size_t Size = 0;
- ASSERT_SUCCESS(olGetSymbolInfoSize(
- Global, OL_SYMBOL_INFO_GLOBAL_VARIABLE_ADDRESS, &Size));
- ASSERT_EQ(Size, sizeof(void *));
-}
-
-TEST_P(olGetSymbolInfoSizeGlobalTest, SuccessSize) {
- size_t Size = 0;
- ASSERT_SUCCESS(
- olGetSymbolInfoSize(Global, OL_SYMBOL_INFO_GLOBAL_VARIABLE_SIZE, &Size));
- ASSERT_EQ(Size, sizeof(size_t));
+ ASSERT_SUCCESS(olGetSymbolInfoSize(Global, Property, &Size));
+ ASSERT_EQ(Size, PropertySize);
}
TEST_P(olGetSymbolInfoSizeKernelTest, InvalidNullHandle) {
More information about the llvm-commits
mailing list