[Offload] In unit tests, use EXPECT_ rather than ASSERT_ #153407
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
`EXPECT_` allows the test to continue after reaching a failure. Switch many cases of `ASSERT_` over to `EXPECT_` to be consistent with other LLVM code. Some uses of `ASSERT_` remain for calls whose failure would result in crashes if the test were to continue. This is mostly the various handle creation functions to prevent accessing invalid pointers. Strings returned from GetInfo are also capped so that a misbehaving GetInfo call does not allocate too much memory.
|
@llvm/pr-subscribers-offload Author: Ross Brunton (RossBrunton) Changes
Some uses of Patch is 69.92 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/153407.diff 27 Files Affected:
diff --git a/offload/unittests/OffloadAPI/common/Fixtures.hpp b/offload/unittests/OffloadAPI/common/Fixtures.hpp
index 43240fa3c4a08..b82a65c62f1fa 100644
--- a/offload/unittests/OffloadAPI/common/Fixtures.hpp
+++ b/offload/unittests/OffloadAPI/common/Fixtures.hpp
@@ -15,6 +15,17 @@
#pragma once
+#ifndef EXPECT_SUCCESS
+#define EXPECT_SUCCESS(ACTUAL) \
+ do { \
+ ol_result_t Res = ACTUAL; \
+ if (Res && Res->Code != OL_ERRC_SUCCESS) { \
+ ADD_FAILURE() << #ACTUAL " returned " << Res->Code << ": " \
+ << Res->Details; \
+ } \
+ } while (0)
+#endif
+
#ifndef ASSERT_SUCCESS
#define ASSERT_SUCCESS(ACTUAL) \
do { \
@@ -27,19 +38,19 @@
#endif
// TODO: rework this so the EXPECTED/ACTUAL results are readable
-#ifndef ASSERT_ERROR
-#define ASSERT_ERROR(EXPECTED, ACTUAL) \
+#ifndef EXPECT_ERROR
+#define EXPECT_ERROR(EXPECTED, ACTUAL) \
do { \
ol_result_t Res = ACTUAL; \
- ASSERT_TRUE(Res && (Res->Code == EXPECTED)); \
+ EXPECT_TRUE(Res && (Res->Code == EXPECTED)); \
} while (0)
#endif
-#ifndef ASSERT_ANY_ERROR
-#define ASSERT_ANY_ERROR(ACTUAL) \
+#ifndef EXPECT_ANY_ERROR
+#define EXPECT_ANY_ERROR(ACTUAL) \
do { \
ol_result_t Res = ACTUAL; \
- ASSERT_TRUE(Res); \
+ EXPECT_TRUE(Res); \
} while (0)
#endif
@@ -127,14 +138,14 @@ struct OffloadProgramTest : OffloadDeviceTest {
RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::SetUp());
ASSERT_TRUE(
TestEnvironment::loadDeviceBinary(ProgramName, Device, DeviceBin));
- ASSERT_GE(DeviceBin->getBufferSize(), 0lu);
+ EXPECT_GE(DeviceBin->getBufferSize(), 0lu);
ASSERT_SUCCESS(olCreateProgram(Device, DeviceBin->getBufferStart(),
DeviceBin->getBufferSize(), &Program));
}
void TearDown() override {
if (Program) {
- olDestroyProgram(Program);
+ EXPECT_SUCCESS(olDestroyProgram(Program));
}
RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::TearDown());
}
@@ -178,7 +189,7 @@ struct OffloadQueueTest : OffloadDeviceTest {
void TearDown() override {
if (Queue) {
- olDestroyQueue(Queue);
+ EXPECT_SUCCESS(olDestroyQueue(Queue));
}
RETURN_ON_FATAL_FAILURE(OffloadDeviceTest::TearDown());
}
@@ -190,12 +201,12 @@ struct OffloadEventTest : OffloadQueueTest {
void SetUp() override {
RETURN_ON_FATAL_FAILURE(OffloadQueueTest::SetUp());
ASSERT_SUCCESS(olCreateEvent(Queue, &Event));
- ASSERT_SUCCESS(olSyncQueue(Queue));
+ EXPECT_SUCCESS(olSyncQueue(Queue));
}
void TearDown() override {
if (Event)
- olDestroyEvent(Event);
+ EXPECT_SUCCESS(olDestroyEvent(Event));
RETURN_ON_FATAL_FAILURE(OffloadQueueTest::TearDown());
}
diff --git a/offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp b/offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp
index 5657320a33a29..fe5f3624917a2 100644
--- a/offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp
+++ b/offload/unittests/OffloadAPI/device/olGetDeviceInfo.cpp
@@ -15,115 +15,119 @@ OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetDeviceInfoTest);
TEST_P(olGetDeviceInfoTest, SuccessType) {
ol_device_type_t DeviceType;
- ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE,
+ EXPECT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE,
sizeof(ol_device_type_t), &DeviceType));
}
TEST_P(olGetDeviceInfoTest, HostSuccessType) {
ol_device_type_t DeviceType;
- ASSERT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_TYPE,
+ EXPECT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_TYPE,
sizeof(ol_device_type_t), &DeviceType));
- ASSERT_EQ(DeviceType, OL_DEVICE_TYPE_HOST);
+ EXPECT_EQ(DeviceType, OL_DEVICE_TYPE_HOST);
}
TEST_P(olGetDeviceInfoTest, SuccessPlatform) {
ol_platform_handle_t Platform = nullptr;
- ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_PLATFORM,
+ EXPECT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_PLATFORM,
sizeof(ol_platform_handle_t), &Platform));
- ASSERT_NE(Platform, nullptr);
+ EXPECT_NE(Platform, nullptr);
}
TEST_P(olGetDeviceInfoTest, SuccessName) {
size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_NAME, &Size));
- ASSERT_GT(Size, 0ul);
+ EXPECT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_NAME, &Size));
+ EXPECT_GT(Size, 0ul);
+ ASSERT_LT(Size, 0x1000);
std::vector<char> Name;
Name.resize(Size);
- ASSERT_SUCCESS(
+ EXPECT_SUCCESS(
olGetDeviceInfo(Device, OL_DEVICE_INFO_NAME, Size, Name.data()));
- ASSERT_EQ(std::strlen(Name.data()), Size - 1);
+ EXPECT_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);
+ EXPECT_SUCCESS(olGetDeviceInfoSize(Host, OL_DEVICE_INFO_NAME, &Size));
+ EXPECT_GT(Size, 0ul);
+ ASSERT_LT(Size, 0x1000);
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);
+ EXPECT_SUCCESS(olGetDeviceInfo(Host, OL_DEVICE_INFO_NAME, Size, Name.data()));
+ EXPECT_EQ(std::strlen(Name.data()), Size - 1);
}
TEST_P(olGetDeviceInfoTest, SuccessVendor) {
size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_VENDOR, &Size));
- ASSERT_GT(Size, 0ul);
+ EXPECT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_VENDOR, &Size));
+ EXPECT_GT(Size, 0ul);
+ ASSERT_LT(Size, 0x1000);
std::vector<char> Vendor;
Vendor.resize(Size);
- ASSERT_SUCCESS(
+ EXPECT_SUCCESS(
olGetDeviceInfo(Device, OL_DEVICE_INFO_VENDOR, Size, Vendor.data()));
- ASSERT_EQ(std::strlen(Vendor.data()), Size - 1);
+ EXPECT_EQ(std::strlen(Vendor.data()), Size - 1);
}
TEST_P(olGetDeviceInfoTest, SuccessDriverVersion) {
size_t Size = 0;
- ASSERT_SUCCESS(
+ EXPECT_SUCCESS(
olGetDeviceInfoSize(Device, OL_DEVICE_INFO_DRIVER_VERSION, &Size));
- ASSERT_GT(Size, 0ul);
+ EXPECT_GT(Size, 0ul);
+ ASSERT_LT(Size, 0x1000);
std::vector<char> DriverVersion;
DriverVersion.resize(Size);
- ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_DRIVER_VERSION, Size,
+ EXPECT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_DRIVER_VERSION, Size,
DriverVersion.data()));
- ASSERT_EQ(std::strlen(DriverVersion.data()), Size - 1);
+ EXPECT_EQ(std::strlen(DriverVersion.data()), Size - 1);
}
TEST_P(olGetDeviceInfoTest, SuccessMaxWorkGroupSize) {
uint32_t Value;
- ASSERT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE,
+ EXPECT_SUCCESS(olGetDeviceInfo(Device, OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE,
sizeof(Value), &Value));
- ASSERT_GT(Value, 0u);
+ EXPECT_GT(Value, 0u);
}
TEST_P(olGetDeviceInfoTest, SuccessMaxWorkGroupSizePerDimension) {
ol_dimensions_t Value{0, 0, 0};
- ASSERT_SUCCESS(
+ EXPECT_SUCCESS(
olGetDeviceInfo(Device, 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);
+ EXPECT_GT(Value.x, 0u);
+ EXPECT_GT(Value.y, 0u);
+ EXPECT_GT(Value.z, 0u);
}
TEST_P(olGetDeviceInfoTest, InvalidNullHandleDevice) {
ol_device_type_t DeviceType;
- ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
+ EXPECT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
olGetDeviceInfo(nullptr, OL_DEVICE_INFO_TYPE,
sizeof(ol_device_type_t), &DeviceType));
}
TEST_P(olGetDeviceInfoTest, InvalidEnumerationInfoType) {
ol_device_type_t DeviceType;
- ASSERT_ERROR(OL_ERRC_INVALID_ENUMERATION,
+ EXPECT_ERROR(OL_ERRC_INVALID_ENUMERATION,
olGetDeviceInfo(Device, OL_DEVICE_INFO_FORCE_UINT32,
sizeof(ol_device_type_t), &DeviceType));
}
TEST_P(olGetDeviceInfoTest, InvalidSizePropSize) {
ol_device_type_t DeviceType;
- ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
+ EXPECT_ERROR(OL_ERRC_INVALID_SIZE,
olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE, 0, &DeviceType));
}
TEST_P(olGetDeviceInfoTest, InvalidSizePropSizeSmall) {
ol_device_type_t DeviceType;
- ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
+ EXPECT_ERROR(OL_ERRC_INVALID_SIZE,
olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE,
sizeof(DeviceType) - 1, &DeviceType));
}
TEST_P(olGetDeviceInfoTest, InvalidNullPointerPropValue) {
ol_device_type_t DeviceType;
- ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
+ EXPECT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
olGetDeviceInfo(Device, OL_DEVICE_INFO_TYPE, sizeof(DeviceType),
nullptr));
}
diff --git a/offload/unittests/OffloadAPI/device/olGetDeviceInfoSize.cpp b/offload/unittests/OffloadAPI/device/olGetDeviceInfoSize.cpp
index 4e29978fc20f0..2d47be7be8ced 100644
--- a/offload/unittests/OffloadAPI/device/olGetDeviceInfoSize.cpp
+++ b/offload/unittests/OffloadAPI/device/olGetDeviceInfoSize.cpp
@@ -15,63 +15,63 @@ OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetDeviceInfoSizeTest);
TEST_P(olGetDeviceInfoSizeTest, SuccessType) {
size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_TYPE, &Size));
- ASSERT_EQ(Size, sizeof(ol_device_type_t));
+ EXPECT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_TYPE, &Size));
+ EXPECT_EQ(Size, sizeof(ol_device_type_t));
}
TEST_P(olGetDeviceInfoSizeTest, SuccessPlatform) {
size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_PLATFORM, &Size));
- ASSERT_EQ(Size, sizeof(ol_platform_handle_t));
+ EXPECT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_PLATFORM, &Size));
+ EXPECT_EQ(Size, sizeof(ol_platform_handle_t));
}
TEST_P(olGetDeviceInfoSizeTest, SuccessName) {
size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_NAME, &Size));
- ASSERT_NE(Size, 0ul);
+ EXPECT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_NAME, &Size));
+ EXPECT_NE(Size, 0ul);
}
TEST_P(olGetDeviceInfoSizeTest, SuccessVendor) {
size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_VENDOR, &Size));
- ASSERT_NE(Size, 0ul);
+ EXPECT_SUCCESS(olGetDeviceInfoSize(Device, OL_DEVICE_INFO_VENDOR, &Size));
+ EXPECT_NE(Size, 0ul);
}
TEST_P(olGetDeviceInfoSizeTest, SuccessDriverVersion) {
size_t Size = 0;
- ASSERT_SUCCESS(
+ EXPECT_SUCCESS(
olGetDeviceInfoSize(Device, OL_DEVICE_INFO_DRIVER_VERSION, &Size));
- ASSERT_NE(Size, 0ul);
+ EXPECT_NE(Size, 0ul);
}
TEST_P(olGetDeviceInfoSizeTest, SuccessMaxWorkGroupSize) {
size_t Size = 0;
- ASSERT_SUCCESS(
+ EXPECT_SUCCESS(
olGetDeviceInfoSize(Device, OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE, &Size));
- ASSERT_EQ(Size, sizeof(uint32_t));
+ EXPECT_EQ(Size, sizeof(uint32_t));
}
TEST_P(olGetDeviceInfoSizeTest, SuccessMaxWorkGroupSizePerDimension) {
size_t Size = 0;
- ASSERT_SUCCESS(olGetDeviceInfoSize(
+ EXPECT_SUCCESS(olGetDeviceInfoSize(
Device, OL_DEVICE_INFO_MAX_WORK_GROUP_SIZE_PER_DIMENSION, &Size));
- ASSERT_EQ(Size, sizeof(ol_dimensions_t));
- ASSERT_EQ(Size, sizeof(uint32_t) * 3);
+ EXPECT_EQ(Size, sizeof(ol_dimensions_t));
+ EXPECT_EQ(Size, sizeof(uint32_t) * 3);
}
TEST_P(olGetDeviceInfoSizeTest, InvalidNullHandle) {
size_t Size = 0;
- ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
+ EXPECT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
olGetDeviceInfoSize(nullptr, OL_DEVICE_INFO_TYPE, &Size));
}
TEST_P(olGetDeviceInfoSizeTest, InvalidDeviceInfoEnumeration) {
size_t Size = 0;
- ASSERT_ERROR(OL_ERRC_INVALID_ENUMERATION,
+ EXPECT_ERROR(OL_ERRC_INVALID_ENUMERATION,
olGetDeviceInfoSize(Device, OL_DEVICE_INFO_FORCE_UINT32, &Size));
}
TEST_P(olGetDeviceInfoSizeTest, InvalidNullPointer) {
- ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
+ EXPECT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
olGetDeviceInfoSize(Device, OL_DEVICE_INFO_TYPE, nullptr));
}
diff --git a/offload/unittests/OffloadAPI/device/olIterateDevices.cpp b/offload/unittests/OffloadAPI/device/olIterateDevices.cpp
index 5bdbd17e9e972..b1623beb2c46f 100644
--- a/offload/unittests/OffloadAPI/device/olIterateDevices.cpp
+++ b/offload/unittests/OffloadAPI/device/olIterateDevices.cpp
@@ -13,7 +13,7 @@
using olIterateDevicesTest = OffloadTest;
TEST_F(olIterateDevicesTest, SuccessEmptyCallback) {
- ASSERT_SUCCESS(olIterateDevices(
+ EXPECT_SUCCESS(olIterateDevices(
[](ol_device_handle_t, void *) { return false; }, nullptr));
}
@@ -21,7 +21,7 @@ TEST_F(olIterateDevicesTest, SuccessGetDevice) {
uint32_t DeviceCount = 0;
ol_device_handle_t Device = nullptr;
- ASSERT_SUCCESS(olIterateDevices(
+ EXPECT_SUCCESS(olIterateDevices(
[](ol_device_handle_t, void *Data) {
auto Count = static_cast<uint32_t *>(Data);
*Count += 1;
@@ -33,7 +33,7 @@ TEST_F(olIterateDevicesTest, SuccessGetDevice) {
GTEST_SKIP() << "No available devices.";
}
- ASSERT_SUCCESS(olIterateDevices(
+ EXPECT_SUCCESS(olIterateDevices(
[](ol_device_handle_t D, void *Data) {
auto DevicePtr = static_cast<ol_device_handle_t *>(Data);
*DevicePtr = D;
@@ -41,5 +41,5 @@ TEST_F(olIterateDevicesTest, SuccessGetDevice) {
},
&Device));
- ASSERT_NE(Device, nullptr);
+ EXPECT_NE(Device, nullptr);
}
diff --git a/offload/unittests/OffloadAPI/event/olCreateEvent.cpp b/offload/unittests/OffloadAPI/event/olCreateEvent.cpp
index 957e9d52215ab..d13387dcc0f58 100644
--- a/offload/unittests/OffloadAPI/event/olCreateEvent.cpp
+++ b/offload/unittests/OffloadAPI/event/olCreateEvent.cpp
@@ -15,15 +15,15 @@ OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olCreateEventTest);
TEST_P(olCreateEventTest, Success) {
ol_event_handle_t Event = nullptr;
- ASSERT_SUCCESS(olCreateEvent(Queue, &Event));
- ASSERT_NE(Event, nullptr);
+ EXPECT_SUCCESS(olCreateEvent(Queue, &Event));
+ EXPECT_NE(Event, nullptr);
}
TEST_P(olCreateEventTest, InvalidNullQueue) {
ol_event_handle_t Event;
- ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE, olCreateEvent(nullptr, &Event));
+ EXPECT_ERROR(OL_ERRC_INVALID_NULL_HANDLE, olCreateEvent(nullptr, &Event));
}
TEST_P(olCreateEventTest, InvalidNullDest) {
- ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER, olCreateEvent(Queue, nullptr));
+ EXPECT_ERROR(OL_ERRC_INVALID_NULL_POINTER, olCreateEvent(Queue, nullptr));
}
diff --git a/offload/unittests/OffloadAPI/event/olDestroyEvent.cpp b/offload/unittests/OffloadAPI/event/olDestroyEvent.cpp
index 8cee535c2258f..9da9c3104c73f 100644
--- a/offload/unittests/OffloadAPI/event/olDestroyEvent.cpp
+++ b/offload/unittests/OffloadAPI/event/olDestroyEvent.cpp
@@ -16,11 +16,11 @@ OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olDestroyEventTest);
TEST_P(olDestroyEventTest, Success) {
ol_event_handle_t Event = nullptr;
ASSERT_SUCCESS(olCreateEvent(Queue, &Event));
- ASSERT_NE(Event, nullptr);
- ASSERT_SUCCESS(olSyncQueue(Queue));
- ASSERT_SUCCESS(olDestroyEvent(Event));
+ EXPECT_NE(Event, nullptr);
+ EXPECT_SUCCESS(olSyncQueue(Queue));
+ EXPECT_SUCCESS(olDestroyEvent(Event));
}
TEST_P(olDestroyEventTest, InvalidNullEvent) {
- ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE, olDestroyEvent(nullptr));
+ EXPECT_ERROR(OL_ERRC_INVALID_NULL_HANDLE, olDestroyEvent(nullptr));
}
diff --git a/offload/unittests/OffloadAPI/event/olGetEventInfo.cpp b/offload/unittests/OffloadAPI/event/olGetEventInfo.cpp
index 908d2dcb6df5d..4a7aa2612d614 100644
--- a/offload/unittests/OffloadAPI/event/olGetEventInfo.cpp
+++ b/offload/unittests/OffloadAPI/event/olGetEventInfo.cpp
@@ -15,41 +15,41 @@ OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetEventInfoTest);
TEST_P(olGetEventInfoTest, SuccessDevice) {
ol_queue_handle_t RetrievedQueue;
- ASSERT_SUCCESS(olGetEventInfo(Event, OL_EVENT_INFO_QUEUE,
+ EXPECT_SUCCESS(olGetEventInfo(Event, OL_EVENT_INFO_QUEUE,
sizeof(ol_queue_handle_t), &RetrievedQueue));
- ASSERT_EQ(Queue, RetrievedQueue);
+ EXPECT_EQ(Queue, RetrievedQueue);
}
TEST_P(olGetEventInfoTest, InvalidNullHandle) {
ol_queue_handle_t RetrievedQueue;
- ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
+ EXPECT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
olGetEventInfo(nullptr, OL_EVENT_INFO_QUEUE,
sizeof(RetrievedQueue), &RetrievedQueue));
}
TEST_P(olGetEventInfoTest, InvalidEventInfoEnumeration) {
ol_queue_handle_t RetrievedQueue;
- ASSERT_ERROR(OL_ERRC_INVALID_ENUMERATION,
+ EXPECT_ERROR(OL_ERRC_INVALID_ENUMERATION,
olGetEventInfo(Event, OL_EVENT_INFO_FORCE_UINT32,
sizeof(RetrievedQueue), &RetrievedQueue));
}
TEST_P(olGetEventInfoTest, InvalidSizeZero) {
ol_queue_handle_t RetrievedQueue;
- ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
+ EXPECT_ERROR(OL_ERRC_INVALID_SIZE,
olGetEventInfo(Event, OL_EVENT_INFO_QUEUE, 0, &RetrievedQueue));
}
TEST_P(olGetEventInfoTest, InvalidSizeSmall) {
ol_queue_handle_t RetrievedQueue;
- ASSERT_ERROR(OL_ERRC_INVALID_SIZE,
+ EXPECT_ERROR(OL_ERRC_INVALID_SIZE,
olGetEventInfo(Event, OL_EVENT_INFO_QUEUE,
sizeof(RetrievedQueue) - 1, &RetrievedQueue));
}
TEST_P(olGetEventInfoTest, InvalidNullPointerPropValue) {
ol_queue_handle_t RetrievedQueue;
- ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
+ EXPECT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
olGetEventInfo(Event, OL_EVENT_INFO_QUEUE,
sizeof(RetrievedQueue), nullptr));
}
diff --git a/offload/unittests/OffloadAPI/event/olGetEventInfoSize.cpp b/offload/unittests/OffloadAPI/event/olGetEventInfoSize.cpp
index d7dee58e35e8d..8bcca4fca33d4 100644
--- a/offload/unittests/OffloadAPI/event/olGetEventInfoSize.cpp
+++ b/offload/unittests/OffloadAPI/event/olGetEventInfoSize.cpp
@@ -15,23 +15,23 @@ OFFLOAD_TESTS_INSTANTIATE_DEVICE_FIXTURE(olGetEventInfoSizeTest);
TEST_P(olGetEventInfoSizeTest, SuccessQueue) {
size_t Size = 0;
- ASSERT_SUCCESS(olGetEventInfoSize(Event, OL_EVENT_INFO_QUEUE, &Size));
- ASSERT_EQ(Size, sizeof(ol_queue_handle_t));
+ EXPECT_SUCCESS(olGetEventInfoSize(Event, OL_EVENT_INFO_QUEUE, &Size));
+ EXPECT_EQ(Size, sizeof(ol_queue_handle_t));
}
TEST_P(olGetEventInfoSizeTest, InvalidNullHandle) {
size_t Size = 0;
- ASSERT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
+ EXPECT_ERROR(OL_ERRC_INVALID_NULL_HANDLE,
olGetEventInfoSize(nullptr, OL_EVENT_INFO_QUEUE, &Size));
}
TEST_P(olGetEventInfoSizeTest, InvalidEventInfoEnumeration) {
size_t Size = 0;
- ASSERT_ERROR(OL_ERRC_INVALID_ENUMERATION,
+ EXPECT_ERROR(OL_ERRC_INVALID_ENUMERATION,
olGetEventInfoSize(Event, OL_EVENT_INFO_FORCE_UINT32, &Size));
}
TEST_P(olGetEventInfoSizeTest, InvalidNullPointer) {
- ASSERT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
+ EXPECT_ERROR(OL_ERRC_INVALID_NULL_POINTER,
olGetEventInfoSize(Event, OL_EVENT_INFO_QUEUE, nullptr));
}
diff --git a/offload/unittests/OffloadAPI/event/olSyncEvent.cpp b/offload/unittests/OffloadAPI/event/olSyncEvent.cpp
index 22ecb96dd9ee5..66c977aaa8508 100644
--- a/offload/unittests/OffloadAPI/event/olSyncEvent.cpp
+++ b/offload/unittests/OffloadAPI/event/olSyncEvent.cpp
@@ -16,22 +16,22 @@ OFFLOAD_TESTS_INST...
[truncated]
|
jhuber6
approved these changes
Aug 13, 2025
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
EXPECT_allows the test to continue after reaching a failure. Switchmany cases of
ASSERT_over toEXPECT_to be consistent with otherLLVM code.
Some uses of
ASSERT_remain for calls whose failure would result incrashes if the test were to continue. This is mostly the various
handle creation functions to prevent accessing invalid pointers. Strings
returned from GetInfo are also capped so that a misbehaving GetInfo call
does not allocate too much memory.