From fb301782d628df66d52c00defe932d93435b047a Mon Sep 17 00:00:00 2001 From: Martin Morrison-Grant Date: Fri, 24 Jan 2025 16:24:55 +0000 Subject: [PATCH] Reorganised urEventGetProfilingInfo test into separate tests instead of a switch. Also done a housekeeping pass across all urXGetInfo tests, renaming and adding consts where appropriate, and adding extra checks to tests with vectors. --- test/conformance/adapter/urAdapterGetInfo.cpp | 28 +-- test/conformance/context/urContextGetInfo.cpp | 68 +++--- test/conformance/event/urEventGetInfo.cpp | 47 ++-- .../event/urEventGetProfilingInfo.cpp | 226 ++++++++++-------- .../kernel/urKernelGetGroupInfo.cpp | 24 +- test/conformance/kernel/urKernelGetInfo.cpp | 124 +++++----- .../kernel/urKernelGetSubGroupInfo.cpp | 76 +++--- test/conformance/memory/urMemGetInfo.cpp | 76 +++--- .../platform/urPlatformGetInfo.cpp | 93 +++---- .../program/urProgramGetBuildInfo.cpp | 79 +++--- test/conformance/program/urProgramGetInfo.cpp | 126 +++++----- test/conformance/queue/urQueueGetInfo.cpp | 1 - test/conformance/sampler/urSamplerGetInfo.cpp | 56 ++--- test/conformance/usm/urUSMGetMemAllocInfo.cpp | 60 ++--- test/conformance/usm/urUSMPoolGetInfo.cpp | 42 ++-- .../virtual_memory/urPhysicalMemGetInfo.cpp | 55 +++-- .../virtual_memory/urVirtualMemGetInfo.cpp | 21 +- 17 files changed, 639 insertions(+), 563 deletions(-) diff --git a/test/conformance/adapter/urAdapterGetInfo.cpp b/test/conformance/adapter/urAdapterGetInfo.cpp index 7c967cb0c4..616314f42b 100644 --- a/test/conformance/adapter/urAdapterGetInfo.cpp +++ b/test/conformance/adapter/urAdapterGetInfo.cpp @@ -13,7 +13,7 @@ using urAdapterGetInfoTest = uur::urAdapterTest; UUR_INSTANTIATE_ADAPTER_TEST_SUITE_P(urAdapterGetInfoTest); TEST_P(urAdapterGetInfoTest, SuccessBackend) { - ur_adapter_info_t property_name = UR_ADAPTER_INFO_BACKEND; + const ur_adapter_info_t property_name = UR_ADAPTER_INFO_BACKEND; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -21,16 +21,16 @@ TEST_P(urAdapterGetInfoTest, SuccessBackend) { property_name); ASSERT_EQ(property_size, sizeof(ur_adapter_backend_t)); - ur_adapter_backend_t backend = UR_ADAPTER_BACKEND_UNKNOWN; + ur_adapter_backend_t property_value = UR_ADAPTER_BACKEND_UNKNOWN; ASSERT_SUCCESS(urAdapterGetInfo(adapter, property_name, property_size, - &backend, nullptr)); + &property_value, nullptr)); - ASSERT_TRUE(backend >= UR_ADAPTER_BACKEND_LEVEL_ZERO && - backend <= UR_ADAPTER_BACKEND_NATIVE_CPU); + ASSERT_TRUE(property_value >= UR_ADAPTER_BACKEND_LEVEL_ZERO && + property_value <= UR_ADAPTER_BACKEND_NATIVE_CPU); } TEST_P(urAdapterGetInfoTest, SuccessReferenceCount) { - ur_adapter_info_t property_name = UR_ADAPTER_INFO_REFERENCE_COUNT; + const ur_adapter_info_t property_name = UR_ADAPTER_INFO_REFERENCE_COUNT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -38,14 +38,14 @@ TEST_P(urAdapterGetInfoTest, SuccessReferenceCount) { property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - uint32_t reference_count = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urAdapterGetInfo(adapter, property_name, property_size, - &reference_count, nullptr)); - ASSERT_GE(reference_count, 0); + &property_value, nullptr)); + ASSERT_GE(property_value, 0); } TEST_P(urAdapterGetInfoTest, SuccessVersion) { - ur_adapter_info_t property_name = UR_ADAPTER_INFO_VERSION; + const ur_adapter_info_t property_name = UR_ADAPTER_INFO_VERSION; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -53,10 +53,10 @@ TEST_P(urAdapterGetInfoTest, SuccessVersion) { property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - uint32_t returned_version = 46; + uint32_t property_value = 46; ASSERT_SUCCESS(urAdapterGetInfo(adapter, property_name, property_size, - &returned_version, nullptr)); - ASSERT_NE(42, returned_version); + &property_value, nullptr)); + ASSERT_NE(42, property_value); } TEST_P(urAdapterGetInfoTest, InvalidNullHandleAdapter) { @@ -89,7 +89,7 @@ TEST_P(urAdapterGetInfoTest, InvalidSizeSmall) { } TEST_P(urAdapterGetInfoTest, InvalidNullPointerPropValue) { - ur_adapter_backend_t backend = UR_ADAPTER_BACKEND_UNKNOWN; + const ur_adapter_backend_t backend = UR_ADAPTER_BACKEND_UNKNOWN; ASSERT_EQ_RESULT(urAdapterGetInfo(adapter, UR_ADAPTER_INFO_BACKEND, sizeof(backend), nullptr, nullptr), UR_RESULT_ERROR_INVALID_NULL_POINTER); diff --git a/test/conformance/context/urContextGetInfo.cpp b/test/conformance/context/urContextGetInfo.cpp index 13348c7eb0..cd915d0b99 100644 --- a/test/conformance/context/urContextGetInfo.cpp +++ b/test/conformance/context/urContextGetInfo.cpp @@ -9,7 +9,7 @@ using urContextGetInfoTest = uur::urContextTest; UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urContextGetInfoTest); TEST_P(urContextGetInfoTest, SuccessNumDevices) { - ur_context_info_t property_name = UR_CONTEXT_INFO_NUM_DEVICES; + const ur_context_info_t property_name = UR_CONTEXT_INFO_NUM_DEVICES; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -17,15 +17,15 @@ TEST_P(urContextGetInfoTest, SuccessNumDevices) { property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - uint32_t nDevices = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urContextGetInfo(context, property_name, property_size, - &nDevices, nullptr)); + &property_value, nullptr)); - ASSERT_EQ(nDevices, 1); + ASSERT_EQ(property_value, 1); } TEST_P(urContextGetInfoTest, SuccessDevices) { - ur_context_info_t property_name = UR_CONTEXT_INFO_DEVICES; + const ur_context_info_t property_name = UR_CONTEXT_INFO_DEVICES; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -33,17 +33,17 @@ TEST_P(urContextGetInfoTest, SuccessDevices) { property_name); ASSERT_NE(property_size, 0); - ur_device_handle_t queried_device = nullptr; + ur_device_handle_t property_value = nullptr; ASSERT_SUCCESS(urContextGetInfo(context, property_name, property_size, - &queried_device, nullptr)); + &property_value, nullptr)); size_t devices_count = property_size / sizeof(ur_device_handle_t); ASSERT_EQ(devices_count, 1); - ASSERT_EQ(queried_device, device); + ASSERT_EQ(property_value, device); } TEST_P(urContextGetInfoTest, SuccessUSMMemCpy2DSupport) { - ur_context_info_t property_name = UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT; + const ur_context_info_t property_name = UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -53,7 +53,7 @@ TEST_P(urContextGetInfoTest, SuccessUSMMemCpy2DSupport) { } TEST_P(urContextGetInfoTest, SuccessUSMFill2DSupport) { - ur_context_info_t property_name = UR_CONTEXT_INFO_USM_FILL2D_SUPPORT; + const ur_context_info_t property_name = UR_CONTEXT_INFO_USM_FILL2D_SUPPORT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -63,7 +63,7 @@ TEST_P(urContextGetInfoTest, SuccessUSMFill2DSupport) { } TEST_P(urContextGetInfoTest, SuccessReferenceCount) { - ur_context_info_t property_name = UR_CONTEXT_INFO_REFERENCE_COUNT; + const ur_context_info_t property_name = UR_CONTEXT_INFO_REFERENCE_COUNT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -71,14 +71,14 @@ TEST_P(urContextGetInfoTest, SuccessReferenceCount) { property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - uint32_t reference_count = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urContextGetInfo(context, property_name, property_size, - &reference_count, nullptr)); - ASSERT_GT(reference_count, 0U); + &property_value, nullptr)); + ASSERT_GT(property_value, 0U); } TEST_P(urContextGetInfoTest, SuccessAtomicMemoryOrderCapabilities) { - ur_context_info_t property_name = + const ur_context_info_t property_name = UR_CONTEXT_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES; size_t property_size = 0; @@ -87,15 +87,15 @@ TEST_P(urContextGetInfoTest, SuccessAtomicMemoryOrderCapabilities) { property_name); ASSERT_EQ(property_size, sizeof(ur_memory_order_capability_flags_t)); - ur_memory_order_capability_flags_t flags = 0; - ASSERT_SUCCESS( - urContextGetInfo(context, property_name, property_size, &flags, nullptr)); + ur_memory_order_capability_flags_t property_value = 0; + ASSERT_SUCCESS(urContextGetInfo(context, property_name, property_size, + &property_value, nullptr)); - ASSERT_EQ(flags & UR_MEMORY_ORDER_CAPABILITY_FLAGS_MASK, 0); + ASSERT_EQ(property_value & UR_MEMORY_ORDER_CAPABILITY_FLAGS_MASK, 0); } TEST_P(urContextGetInfoTest, SuccessAtomicMemoryScopeCapabilities) { - ur_context_info_t property_name = + const ur_context_info_t property_name = UR_CONTEXT_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES; size_t property_size = 0; @@ -104,15 +104,15 @@ TEST_P(urContextGetInfoTest, SuccessAtomicMemoryScopeCapabilities) { property_name); ASSERT_EQ(property_size, sizeof(ur_memory_scope_capability_flags_t)); - ur_memory_scope_capability_flags_t flags = 0; - ASSERT_SUCCESS( - urContextGetInfo(context, property_name, property_size, &flags, nullptr)); + ur_memory_scope_capability_flags_t property_value = 0; + ASSERT_SUCCESS(urContextGetInfo(context, property_name, property_size, + &property_value, nullptr)); - ASSERT_EQ(flags & UR_MEMORY_SCOPE_CAPABILITY_FLAGS_MASK, 0); + ASSERT_EQ(property_value & UR_MEMORY_SCOPE_CAPABILITY_FLAGS_MASK, 0); } TEST_P(urContextGetInfoTest, SuccessAtomicFenceOrderCapabilities) { - ur_context_info_t property_name = + const ur_context_info_t property_name = UR_CONTEXT_INFO_ATOMIC_FENCE_ORDER_CAPABILITIES; size_t property_size = 0; @@ -121,15 +121,15 @@ TEST_P(urContextGetInfoTest, SuccessAtomicFenceOrderCapabilities) { property_name); ASSERT_EQ(property_size, sizeof(ur_memory_order_capability_flags_t)); - ur_memory_order_capability_flags_t flags = 0; - ASSERT_SUCCESS( - urContextGetInfo(context, property_name, property_size, &flags, nullptr)); + ur_memory_order_capability_flags_t property_value = 0; + ASSERT_SUCCESS(urContextGetInfo(context, property_name, property_size, + &property_value, nullptr)); - ASSERT_EQ(flags & UR_MEMORY_ORDER_CAPABILITY_FLAGS_MASK, 0); + ASSERT_EQ(property_value & UR_MEMORY_ORDER_CAPABILITY_FLAGS_MASK, 0); } TEST_P(urContextGetInfoTest, SuccessAtomicFenceScopeCapabilities) { - ur_context_info_t property_name = + const ur_context_info_t property_name = UR_CONTEXT_INFO_ATOMIC_FENCE_SCOPE_CAPABILITIES; size_t property_size = 0; @@ -138,11 +138,11 @@ TEST_P(urContextGetInfoTest, SuccessAtomicFenceScopeCapabilities) { property_name); ASSERT_EQ(property_size, sizeof(ur_memory_scope_capability_flags_t)); - ur_memory_scope_capability_flags_t flags = 0; - ASSERT_SUCCESS( - urContextGetInfo(context, property_name, property_size, &flags, nullptr)); + ur_memory_scope_capability_flags_t property_value = 0; + ASSERT_SUCCESS(urContextGetInfo(context, property_name, property_size, + &property_value, nullptr)); - ASSERT_EQ(flags & UR_MEMORY_SCOPE_CAPABILITY_FLAGS_MASK, 0); + ASSERT_EQ(property_value & UR_MEMORY_SCOPE_CAPABILITY_FLAGS_MASK, 0); } TEST_P(urContextGetInfoTest, InvalidNullHandleContext) { diff --git a/test/conformance/event/urEventGetInfo.cpp b/test/conformance/event/urEventGetInfo.cpp index dbec83fdfa..d6010e6ec1 100644 --- a/test/conformance/event/urEventGetInfo.cpp +++ b/test/conformance/event/urEventGetInfo.cpp @@ -10,7 +10,7 @@ using urEventGetInfoTest = uur::event::urEventTest; TEST_P(urEventGetInfoTest, SuccessCommandQueue) { - ur_event_info_t property_name = UR_EVENT_INFO_COMMAND_QUEUE; + const ur_event_info_t property_name = UR_EVENT_INFO_COMMAND_QUEUE; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -18,15 +18,15 @@ TEST_P(urEventGetInfoTest, SuccessCommandQueue) { property_name); ASSERT_EQ(property_size, sizeof(ur_queue_handle_t)); - ur_queue_handle_t returned_queue = nullptr; + ur_queue_handle_t property_value = nullptr; ASSERT_SUCCESS(urEventGetInfo(event, property_name, property_size, - &returned_queue, nullptr)); + &property_value, nullptr)); - ASSERT_EQ(queue, returned_queue); + ASSERT_EQ(queue, property_value); } TEST_P(urEventGetInfoTest, SuccessContext) { - ur_event_info_t property_name = UR_EVENT_INFO_CONTEXT; + const ur_event_info_t property_name = UR_EVENT_INFO_CONTEXT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -34,17 +34,17 @@ TEST_P(urEventGetInfoTest, SuccessContext) { property_name); ASSERT_EQ(property_size, sizeof(ur_context_handle_t)); - ur_context_handle_t returned_context = nullptr; + ur_context_handle_t property_value = nullptr; ASSERT_SUCCESS(urEventGetInfo(event, property_name, property_size, - &returned_context, nullptr)); + &property_value, nullptr)); - ASSERT_EQ(context, returned_context); + ASSERT_EQ(context, property_value); } TEST_P(urEventGetInfoTest, SuccessCommandType) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); - ur_event_info_t property_name = UR_EVENT_INFO_COMMAND_TYPE; + const ur_event_info_t property_name = UR_EVENT_INFO_COMMAND_TYPE; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -52,15 +52,15 @@ TEST_P(urEventGetInfoTest, SuccessCommandType) { property_name); ASSERT_EQ(property_size, sizeof(ur_command_t)); - ur_command_t returned_command_type = UR_COMMAND_FORCE_UINT32; + ur_command_t property_value = UR_COMMAND_FORCE_UINT32; ASSERT_SUCCESS(urEventGetInfo(event, property_name, property_size, - &returned_command_type, nullptr)); + &property_value, nullptr)); - ASSERT_EQ(UR_COMMAND_MEM_BUFFER_WRITE, returned_command_type); + ASSERT_EQ(UR_COMMAND_MEM_BUFFER_WRITE, property_value); } TEST_P(urEventGetInfoTest, SuccessCommandExecutionStatus) { - ur_event_info_t property_name = UR_EVENT_INFO_COMMAND_EXECUTION_STATUS; + const ur_event_info_t property_name = UR_EVENT_INFO_COMMAND_EXECUTION_STATUS; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -68,15 +68,15 @@ TEST_P(urEventGetInfoTest, SuccessCommandExecutionStatus) { property_name); ASSERT_EQ(property_size, sizeof(ur_event_status_t)); - ur_event_status_t returned_status = UR_EVENT_STATUS_FORCE_UINT32; + ur_event_status_t property_value = UR_EVENT_STATUS_FORCE_UINT32; ASSERT_SUCCESS(urEventGetInfo(event, property_name, property_size, - &returned_status, nullptr)); + &property_value, nullptr)); - ASSERT_EQ(UR_EVENT_STATUS_COMPLETE, returned_status); + ASSERT_EQ(UR_EVENT_STATUS_COMPLETE, property_value); } TEST_P(urEventGetInfoTest, SuccessReferenceCount) { - ur_event_info_t property_name = UR_EVENT_INFO_REFERENCE_COUNT; + const ur_event_info_t property_name = UR_EVENT_INFO_REFERENCE_COUNT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -84,23 +84,21 @@ TEST_P(urEventGetInfoTest, SuccessReferenceCount) { property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - uint32_t returned_reference_count = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urEventGetInfo(event, property_name, property_size, - &returned_reference_count, nullptr)); + &property_value, nullptr)); - ASSERT_GT(returned_reference_count, 0U); + ASSERT_GT(property_value, 0U); } TEST_P(urEventGetInfoTest, InvalidNullHandle) { - ur_event_info_t property_name = UR_EVENT_INFO_COMMAND_QUEUE; + const ur_event_info_t property_name = UR_EVENT_INFO_COMMAND_QUEUE; size_t property_size; ASSERT_SUCCESS( urEventGetInfo(event, property_name, 0, nullptr, &property_size)); ASSERT_NE(property_size, 0); - std::vector data(property_size); - /* Invalid hEvent */ ASSERT_EQ_RESULT(urEventGetInfo(nullptr, UR_EVENT_INFO_COMMAND_QUEUE, 0, nullptr, &property_size), UR_RESULT_ERROR_INVALID_NULL_HANDLE); @@ -115,7 +113,7 @@ TEST_P(urEventGetInfoTest, InvalidEnumeration) { } TEST_P(urEventGetInfoTest, InvalidSizePropSize) { - ur_event_info_t property_name = UR_EVENT_INFO_COMMAND_QUEUE; + const ur_event_info_t property_name = UR_EVENT_INFO_COMMAND_QUEUE; size_t property_size = 0; ASSERT_SUCCESS( @@ -123,7 +121,6 @@ TEST_P(urEventGetInfoTest, InvalidSizePropSize) { ASSERT_NE(property_size, 0); std::vector data(property_size); - /* Invalid propSize */ ASSERT_EQ_RESULT(urEventGetInfo(event, UR_EVENT_INFO_COMMAND_QUEUE, 0, data.data(), nullptr), UR_RESULT_ERROR_INVALID_SIZE); diff --git a/test/conformance/event/urEventGetProfilingInfo.cpp b/test/conformance/event/urEventGetProfilingInfo.cpp index e4f3acd0a9..cdcd380a30 100644 --- a/test/conformance/event/urEventGetProfilingInfo.cpp +++ b/test/conformance/event/urEventGetProfilingInfo.cpp @@ -7,143 +7,165 @@ #include "fixtures.h" #include "uur/known_failure.h" -using urEventGetProfilingInfoTest = - uur::event::urEventTestWithParam; +using urEventGetProfilingInfoTest = uur::event::urEventTest; -TEST_P(urEventGetProfilingInfoTest, Success) { +TEST_P(urEventGetProfilingInfoTest, SuccessCommandQueued) { + UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::LevelZeroV2{}, uur::NativeCPU{}); - ur_profiling_info_t info_type = getParam(); + const ur_profiling_info_t property_name = UR_PROFILING_INFO_COMMAND_QUEUED; + size_t property_size = 0; - if (info_type == UR_PROFILING_INFO_COMMAND_COMPLETE) { - UUR_KNOWN_FAILURE_ON(uur::CUDA{}, uur::HIP{}, uur::LevelZero{}, - uur::NativeCPU{}); - } + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( + urEventGetProfilingInfo(event, property_name, 0, nullptr, &property_size), + property_name); + ASSERT_EQ(property_size, sizeof(uint64_t)); + + uint64_t property_value = 0; + ASSERT_SUCCESS(urEventGetProfilingInfo(event, property_name, property_size, + &property_value, nullptr)); + ASSERT_NE(property_value, 0); +} - if (info_type == UR_PROFILING_INFO_COMMAND_QUEUED) { - UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::LevelZeroV2{}, - uur::NativeCPU{}); - } +TEST_P(urEventGetProfilingInfoTest, SuccessCommandSubmit) { + UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::LevelZeroV2{}, uur::NativeCPU{}); - if (info_type == UR_PROFILING_INFO_COMMAND_SUBMIT) { - UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::LevelZeroV2{}, - uur::NativeCPU{}); - } + const ur_profiling_info_t property_name = UR_PROFILING_INFO_COMMAND_SUBMIT; + size_t property_size = 0; - size_t size; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( - urEventGetProfilingInfo(event, info_type, 0, nullptr, &size), info_type); - ASSERT_EQ(size, 8); + urEventGetProfilingInfo(event, property_name, 0, nullptr, &property_size), + property_name); + ASSERT_EQ(property_size, sizeof(uint64_t)); + + uint64_t property_value = 0; + ASSERT_SUCCESS(urEventGetProfilingInfo(event, property_name, property_size, + &property_value, nullptr)); + ASSERT_NE(property_value, 0); +} - std::vector data(size); - ASSERT_SUCCESS( - urEventGetProfilingInfo(event, info_type, size, data.data(), nullptr)); +TEST_P(urEventGetProfilingInfoTest, SuccessCommandStart) { + const ur_profiling_info_t property_name = UR_PROFILING_INFO_COMMAND_START; + size_t property_size = 0; - if (sizeof(size_t) == size) { - auto returned_value = reinterpret_cast(data.data()); - ASSERT_NE(*returned_value, 0); - } + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( + urEventGetProfilingInfo(event, property_name, 0, nullptr, &property_size), + property_name); + ASSERT_EQ(property_size, sizeof(uint64_t)); + + uint64_t property_value = 0; + ASSERT_SUCCESS(urEventGetProfilingInfo(event, property_name, property_size, + &property_value, nullptr)); + ASSERT_NE(property_value, 0); +} + +TEST_P(urEventGetProfilingInfoTest, SuccessCommandEnd) { + const ur_profiling_info_t property_name = UR_PROFILING_INFO_COMMAND_END; + size_t property_size = 0; + + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( + urEventGetProfilingInfo(event, property_name, 0, nullptr, &property_size), + property_name); + ASSERT_EQ(property_size, sizeof(uint64_t)); + + uint64_t property_value = 0; + ASSERT_SUCCESS(urEventGetProfilingInfo(event, property_name, property_size, + &property_value, nullptr)); + ASSERT_NE(property_value, 0); } -UUR_DEVICE_TEST_SUITE_P(urEventGetProfilingInfoTest, - ::testing::Values(UR_PROFILING_INFO_COMMAND_QUEUED, - UR_PROFILING_INFO_COMMAND_SUBMIT, - UR_PROFILING_INFO_COMMAND_START, - UR_PROFILING_INFO_COMMAND_END, - UR_PROFILING_INFO_COMMAND_COMPLETE), - uur::deviceTestWithParamPrinter); +TEST_P(urEventGetProfilingInfoTest, SuccessCommandComplete) { + UUR_KNOWN_FAILURE_ON(uur::CUDA{}, uur::HIP{}, uur::LevelZero{}, + uur::NativeCPU{}); + + const ur_profiling_info_t property_name = UR_PROFILING_INFO_COMMAND_COMPLETE; + size_t property_size = 0; -using urEventGetProfilingInfoWithTimingComparisonTest = uur::event::urEventTest; + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( + urEventGetProfilingInfo(event, property_name, 0, nullptr, &property_size), + property_name); + ASSERT_EQ(property_size, sizeof(uint64_t)); + + uint64_t property_value = 0; + ASSERT_SUCCESS(urEventGetProfilingInfo(event, property_name, property_size, + &property_value, nullptr)); + ASSERT_NE(property_value, 0); +} -TEST_P(urEventGetProfilingInfoWithTimingComparisonTest, Success) { +TEST_P(urEventGetProfilingInfoTest, Success) { UUR_KNOWN_FAILURE_ON(uur::CUDA{}, uur::HIP{}, uur::LevelZero{}, uur::LevelZeroV2{}, uur::NativeCPU{}); uint8_t size = 8; - std::vector queued_data(size); - ASSERT_SUCCESS(urEventGetProfilingInfo(event, - UR_PROFILING_INFO_COMMAND_QUEUED, size, - queued_data.data(), nullptr)); - auto queued_timing = reinterpret_cast(queued_data.data()); - ASSERT_NE(*queued_timing, 0); + uint64_t queued_value = 0; + ASSERT_SUCCESS(urEventGetProfilingInfo( + event, UR_PROFILING_INFO_COMMAND_QUEUED, size, &queued_value, nullptr)); + ASSERT_NE(queued_value, 0); - std::vector submit_data(size); - ASSERT_SUCCESS(urEventGetProfilingInfo(event, - UR_PROFILING_INFO_COMMAND_SUBMIT, size, - submit_data.data(), nullptr)); - auto submit_timing = reinterpret_cast(submit_data.data()); - ASSERT_NE(*submit_timing, 0); + uint64_t submit_value = 0; + ASSERT_SUCCESS(urEventGetProfilingInfo( + event, UR_PROFILING_INFO_COMMAND_SUBMIT, size, &submit_value, nullptr)); + ASSERT_NE(submit_value, 0); - std::vector start_data(size); + uint64_t start_value = 0; ASSERT_SUCCESS(urEventGetProfilingInfo(event, UR_PROFILING_INFO_COMMAND_START, - size, start_data.data(), nullptr)); - auto start_timing = reinterpret_cast(start_data.data()); - ASSERT_NE(*start_timing, 0); + size, &start_value, nullptr)); + ASSERT_NE(start_value, 0); - std::vector end_data(size); + uint64_t end_value = 0; ASSERT_SUCCESS(urEventGetProfilingInfo(event, UR_PROFILING_INFO_COMMAND_END, - size, end_data.data(), nullptr)); - auto end_timing = reinterpret_cast(end_data.data()); - ASSERT_NE(*end_timing, 0); + size, &end_value, nullptr)); + ASSERT_NE(end_value, 0); - std::vector complete_data(size); + uint64_t complete_value = 0; ASSERT_SUCCESS(urEventGetProfilingInfo(event, UR_PROFILING_INFO_COMMAND_COMPLETE, - size, complete_data.data(), nullptr)); - auto complete_timing = reinterpret_cast(complete_data.data()); - ASSERT_NE(*complete_timing, 0); - - ASSERT_LE(*queued_timing, *submit_timing); - ASSERT_LT(*submit_timing, *start_timing); - ASSERT_LT(*start_timing, *end_timing); - ASSERT_LE(*end_timing, *complete_timing); -} + size, &complete_value, nullptr)); + ASSERT_NE(complete_value, 0); -UUR_INSTANTIATE_DEVICE_TEST_SUITE_P( - urEventGetProfilingInfoWithTimingComparisonTest); - -using urEventGetProfilingInfoNegativeTest = uur::event::urEventTest; + ASSERT_LE(queued_value, submit_value); + ASSERT_LT(submit_value, start_value); + ASSERT_LT(start_value, end_value); + ASSERT_LE(end_value, complete_value); +} -TEST_P(urEventGetProfilingInfoNegativeTest, InvalidNullHandle) { +TEST_P(urEventGetProfilingInfoTest, InvalidNullHandle) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); - ur_profiling_info_t info_type = UR_PROFILING_INFO_COMMAND_QUEUED; - size_t size; - ASSERT_SUCCESS(urEventGetProfilingInfo(event, info_type, 0, nullptr, &size)); - ASSERT_NE(size, 0); - std::vector data(size); + const ur_profiling_info_t property_name = UR_PROFILING_INFO_COMMAND_QUEUED; + size_t property_size; + ASSERT_SUCCESS(urEventGetProfilingInfo(event, property_name, 0, nullptr, + &property_size)); + ASSERT_NE(property_size, 0); - /* Invalid hEvent */ - ASSERT_EQ_RESULT( - urEventGetProfilingInfo(nullptr, info_type, 0, nullptr, &size), - UR_RESULT_ERROR_INVALID_NULL_HANDLE); + ASSERT_EQ_RESULT(urEventGetProfilingInfo(nullptr, property_name, 0, nullptr, + &property_size), + UR_RESULT_ERROR_INVALID_NULL_HANDLE); } -TEST_P(urEventGetProfilingInfoNegativeTest, InvalidEnumeration) { - size_t size; +TEST_P(urEventGetProfilingInfoTest, InvalidEnumeration) { + size_t property_size; ASSERT_EQ_RESULT(urEventGetProfilingInfo(event, UR_PROFILING_INFO_FORCE_UINT32, 0, - nullptr, &size), + nullptr, &property_size), UR_RESULT_ERROR_INVALID_ENUMERATION); } -TEST_P(urEventGetProfilingInfoNegativeTest, InvalidValue) { +TEST_P(urEventGetProfilingInfoTest, InvalidValue) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); - ur_profiling_info_t info_type = UR_PROFILING_INFO_COMMAND_QUEUED; - size_t size; - ASSERT_SUCCESS(urEventGetProfilingInfo(event, info_type, 0, nullptr, &size)); - ASSERT_NE(size, 0); - std::vector data(size); + const ur_profiling_info_t property_name = UR_PROFILING_INFO_COMMAND_QUEUED; + size_t property_size = 0; + ASSERT_SUCCESS(urEventGetProfilingInfo(event, property_name, 0, nullptr, + &property_size)); + ASSERT_NE(property_size, 0); - /* Invalid propSize */ - ASSERT_EQ_RESULT( - urEventGetProfilingInfo(event, info_type, 0, data.data(), nullptr), - UR_RESULT_ERROR_INVALID_VALUE); + uint64_t property_value = 0; + ASSERT_EQ_RESULT(urEventGetProfilingInfo(event, property_name, 0, + &property_value, nullptr), + UR_RESULT_ERROR_INVALID_VALUE); } -UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEventGetProfilingInfoNegativeTest); - struct urEventGetProfilingInfoForWaitWithBarrier : uur::urProfilingQueueTest { void SetUp() override { UUR_RETURN_ON_FATAL_FAILURE(urProfilingQueueTest::SetUp()); @@ -175,17 +197,15 @@ struct urEventGetProfilingInfoForWaitWithBarrier : uur::urProfilingQueueTest { UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urEventGetProfilingInfoForWaitWithBarrier); TEST_P(urEventGetProfilingInfoForWaitWithBarrier, Success) { - std::vector submit_data(size); + uint64_t submit_value = 0; ASSERT_SUCCESS(urEventGetProfilingInfo(event, UR_PROFILING_INFO_COMMAND_START, - size, submit_data.data(), nullptr)); - auto start_timing = reinterpret_cast(submit_data.data()); - ASSERT_NE(*start_timing, 0); + size, &submit_value, nullptr)); + ASSERT_NE(submit_value, 0); - std::vector complete_data(size); + uint64_t complete_value = 0; ASSERT_SUCCESS(urEventGetProfilingInfo(event, UR_PROFILING_INFO_COMMAND_END, - size, complete_data.data(), nullptr)); - auto end_timing = reinterpret_cast(complete_data.data()); - ASSERT_NE(*end_timing, 0); + size, &complete_value, nullptr)); + ASSERT_NE(complete_value, 0); - ASSERT_GE(*end_timing, *start_timing); + ASSERT_GE(complete_value, submit_value); } diff --git a/test/conformance/kernel/urKernelGetGroupInfo.cpp b/test/conformance/kernel/urKernelGetGroupInfo.cpp index 9bf7309c0a..1bff70ee1c 100644 --- a/test/conformance/kernel/urKernelGetGroupInfo.cpp +++ b/test/conformance/kernel/urKernelGetGroupInfo.cpp @@ -26,7 +26,7 @@ TEST_P(urKernelGetGroupInfoFixedWorkGroupSizeTest, SuccessCompileWorkGroupSize) { UUR_KNOWN_FAILURE_ON(uur::CUDA{}, uur::HIP{}); - ur_kernel_group_info_t property_name = + const ur_kernel_group_info_t property_name = UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE; size_t property_size = 0; @@ -63,7 +63,7 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urKernelGetGroupInfoMaxWorkGroupSizeTest); TEST_P(urKernelGetGroupInfoMaxWorkGroupSizeTest, SuccessCompileMaxWorkGroupSize) { - ur_kernel_group_info_t property_name = + const ur_kernel_group_info_t property_name = UR_KERNEL_GROUP_INFO_COMPILE_MAX_WORK_GROUP_SIZE; size_t property_size = 0; @@ -83,7 +83,7 @@ TEST_P(urKernelGetGroupInfoMaxWorkGroupSizeTest, TEST_P(urKernelGetGroupInfoMaxWorkGroupSizeTest, SuccessCompileMaxLinearWorkGroupSize) { - ur_kernel_group_info_t property_name = + const ur_kernel_group_info_t property_name = UR_KERNEL_GROUP_INFO_COMPILE_MAX_LINEAR_WORK_GROUP_SIZE; size_t property_size = 0; @@ -104,7 +104,8 @@ using urKernelGetGroupInfoTest = uur::urKernelTest; UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urKernelGetGroupInfoTest); TEST_P(urKernelGetGroupInfoTest, SuccessGlobalWorkSize) { - ur_kernel_group_info_t property_name = UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE; + const ur_kernel_group_info_t property_name = + UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -120,7 +121,8 @@ TEST_P(urKernelGetGroupInfoTest, SuccessGlobalWorkSize) { } TEST_P(urKernelGetGroupInfoTest, SuccessWorkGroupSize) { - ur_kernel_group_info_t property_name = UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE; + const ur_kernel_group_info_t property_name = + UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -136,7 +138,8 @@ TEST_P(urKernelGetGroupInfoTest, SuccessWorkGroupSize) { } TEST_P(urKernelGetGroupInfoTest, SuccessLocalMemSize) { - ur_kernel_group_info_t property_name = UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE; + const ur_kernel_group_info_t property_name = + UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -152,7 +155,7 @@ TEST_P(urKernelGetGroupInfoTest, SuccessLocalMemSize) { } TEST_P(urKernelGetGroupInfoTest, SuccessPreferredWorkGroupSizeMultiple) { - ur_kernel_group_info_t property_name = + const ur_kernel_group_info_t property_name = UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE; size_t property_size = 0; @@ -169,7 +172,8 @@ TEST_P(urKernelGetGroupInfoTest, SuccessPreferredWorkGroupSizeMultiple) { } TEST_P(urKernelGetGroupInfoTest, SuccessPrivateMemSize) { - ur_kernel_group_info_t property_name = UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE; + const ur_kernel_group_info_t property_name = + UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -187,7 +191,7 @@ TEST_P(urKernelGetGroupInfoTest, SuccessPrivateMemSize) { TEST_P(urKernelGetGroupInfoTest, SuccessCompileWorkGroupSizeEmpty) { // Returns 0 by default when there is no specific information std::array read_dims{1, 1, 1}; - std::array zero{0, 0, 0}; + const std::array zero{0, 0, 0}; ASSERT_SUCCESS(urKernelGetGroupInfo( kernel, device, UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE, @@ -199,7 +203,7 @@ TEST_P(urKernelGetGroupInfoTest, SuccessCompileWorkGroupSizeEmpty) { TEST_P(urKernelGetGroupInfoTest, SuccessCompileMaxWorkGroupSizeEmpty) { // Returns 0 by default when there is no specific information std::array read_dims{1, 1, 1}; - std::array zero{0, 0, 0}; + const std::array zero{0, 0, 0}; auto result = urKernelGetGroupInfo( kernel, device, UR_KERNEL_GROUP_INFO_COMPILE_MAX_WORK_GROUP_SIZE, diff --git a/test/conformance/kernel/urKernelGetInfo.cpp b/test/conformance/kernel/urKernelGetInfo.cpp index 65694b5bdd..29c48f91a7 100644 --- a/test/conformance/kernel/urKernelGetInfo.cpp +++ b/test/conformance/kernel/urKernelGetInfo.cpp @@ -12,20 +12,25 @@ using urKernelGetInfoTest = uur::urKernelTest; UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urKernelGetInfoTest); TEST_P(urKernelGetInfoTest, SuccessFunctionName) { - ur_kernel_info_t property_name = UR_KERNEL_INFO_FUNCTION_NAME; + const ur_kernel_info_t property_name = UR_KERNEL_INFO_FUNCTION_NAME; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urKernelGetInfo(kernel, property_name, 0, nullptr, &property_size), property_name); + ASSERT_GT(property_size, 0); - std::vector property_value(property_size); + std::vector property_value(property_size, 'x'); ASSERT_SUCCESS(urKernelGetInfo(kernel, property_name, property_size, property_value.data(), nullptr)); + + ASSERT_EQ(property_size, property_value.size()); + EXPECT_NE(property_value[0], 'x'); + EXPECT_EQ(property_value[property_size - 1], '\0'); } TEST_P(urKernelGetInfoTest, SuccessNumArgs) { - ur_kernel_info_t property_name = UR_KERNEL_INFO_NUM_ARGS; + const ur_kernel_info_t property_name = UR_KERNEL_INFO_NUM_ARGS; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -33,13 +38,15 @@ TEST_P(urKernelGetInfoTest, SuccessNumArgs) { property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - std::vector property_value(property_size); + uint32_t property_value = 999; ASSERT_SUCCESS(urKernelGetInfo(kernel, property_name, property_size, - property_value.data(), nullptr)); + &property_value, nullptr)); + + ASSERT_NE(property_value, 999); } TEST_P(urKernelGetInfoTest, SuccessReferenceCount) { - ur_kernel_info_t property_name = UR_KERNEL_INFO_REFERENCE_COUNT; + const ur_kernel_info_t property_name = UR_KERNEL_INFO_REFERENCE_COUNT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -47,17 +54,15 @@ TEST_P(urKernelGetInfoTest, SuccessReferenceCount) { property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - std::vector property_value(property_size); + uint32_t property_value = 999; ASSERT_SUCCESS(urKernelGetInfo(kernel, property_name, property_size, - property_value.data(), nullptr)); + &property_value, nullptr)); - auto returned_reference_count = - reinterpret_cast(property_value.data()); - ASSERT_GT(*returned_reference_count, 0U); + ASSERT_GT(property_value, 0U); } TEST_P(urKernelGetInfoTest, SuccessContext) { - ur_kernel_info_t property_name = UR_KERNEL_INFO_CONTEXT; + const ur_kernel_info_t property_name = UR_KERNEL_INFO_CONTEXT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -65,17 +70,15 @@ TEST_P(urKernelGetInfoTest, SuccessContext) { property_name); ASSERT_EQ(property_size, sizeof(ur_context_handle_t)); - std::vector property_value(property_size); + ur_context_handle_t property_value = nullptr; ASSERT_SUCCESS(urKernelGetInfo(kernel, property_name, property_size, - property_value.data(), nullptr)); + &property_value, nullptr)); - auto returned_context = - reinterpret_cast(property_value.data()); - ASSERT_EQ(context, *returned_context); + ASSERT_EQ(context, property_value); } TEST_P(urKernelGetInfoTest, SuccessProgram) { - ur_kernel_info_t property_name = UR_KERNEL_INFO_PROGRAM; + const ur_kernel_info_t property_name = UR_KERNEL_INFO_PROGRAM; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -83,29 +86,32 @@ TEST_P(urKernelGetInfoTest, SuccessProgram) { property_name); ASSERT_EQ(property_size, sizeof(ur_program_handle_t)); - std::vector property_value(property_size); + ur_program_handle_t property_value = nullptr; ASSERT_SUCCESS(urKernelGetInfo(kernel, property_name, property_size, - property_value.data(), nullptr)); + &property_value, nullptr)); - auto returned_program = - reinterpret_cast(property_value.data()); - ASSERT_EQ(program, *returned_program); + ASSERT_EQ(program, property_value); } TEST_P(urKernelGetInfoTest, SuccessAttributes) { - ur_kernel_info_t property_name = UR_KERNEL_INFO_ATTRIBUTES; + const ur_kernel_info_t property_name = UR_KERNEL_INFO_ATTRIBUTES; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urKernelGetInfo(kernel, property_name, 0, nullptr, &property_size), property_name); + ASSERT_GT(property_size, 0); - std::vector property_value(property_size); + std::vector property_value(property_size, 'x'); ASSERT_SUCCESS(urKernelGetInfo(kernel, property_name, property_size, property_value.data(), nullptr)); - auto returned_attributes = std::string(property_value.data()); - ur_platform_backend_t backend; + ASSERT_EQ(property_size, property_value.size()); + EXPECT_NE(property_value[0], 'x'); + EXPECT_EQ(property_value[property_size - 1], '\0'); + + const std::string returned_attributes = std::string(property_value.data()); + ur_platform_backend_t backend = UR_PLATFORM_BACKEND_FORCE_UINT32; ASSERT_SUCCESS(urPlatformGetInfo(platform, UR_PLATFORM_INFO_BACKEND, sizeof(backend), &backend, nullptr)); if (backend == UR_PLATFORM_BACKEND_OPENCL || @@ -123,7 +129,7 @@ TEST_P(urKernelGetInfoTest, SuccessAttributes) { TEST_P(urKernelGetInfoTest, SuccessNumRegs) { UUR_KNOWN_FAILURE_ON(uur::HIP{}); - ur_kernel_info_t property_name = UR_KERNEL_INFO_NUM_REGS; + const ur_kernel_info_t property_name = UR_KERNEL_INFO_NUM_REGS; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -131,52 +137,56 @@ TEST_P(urKernelGetInfoTest, SuccessNumRegs) { property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - std::vector property_value(property_size); + uint32_t property_value = 999; ASSERT_SUCCESS(urKernelGetInfo(kernel, property_name, property_size, - property_value.data(), nullptr)); + &property_value, nullptr)); + + ASSERT_NE(property_value, 999); } TEST_P(urKernelGetInfoTest, InvalidNullHandleKernel) { - size_t kernel_name_length = 0; + size_t property_size = 0; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, urKernelGetInfo(nullptr, UR_KERNEL_INFO_FUNCTION_NAME, 0, - nullptr, &kernel_name_length)); + nullptr, &property_size)); } TEST_P(urKernelGetInfoTest, InvalidEnumeration) { - size_t bad_enum_length = 0; + size_t property_size = 0; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION, urKernelGetInfo(kernel, UR_KERNEL_INFO_FORCE_UINT32, 0, - nullptr, &bad_enum_length)); + nullptr, &property_size)); } TEST_P(urKernelGetInfoTest, InvalidSizeZero) { - size_t query_size = 0; + size_t property_size = 0; ASSERT_SUCCESS(urKernelGetInfo(kernel, UR_KERNEL_INFO_NUM_ARGS, 0, nullptr, - &query_size)); - std::vector query_data(query_size); + &property_size)); + + std::vector property_value(property_size); ASSERT_EQ_RESULT(urKernelGetInfo(kernel, UR_KERNEL_INFO_NUM_ARGS, 0, - query_data.data(), nullptr), + property_value.data(), nullptr), UR_RESULT_ERROR_INVALID_SIZE); } TEST_P(urKernelGetInfoTest, InvalidSizeSmall) { - size_t query_size = 0; + size_t property_size = 0; ASSERT_SUCCESS(urKernelGetInfo(kernel, UR_KERNEL_INFO_NUM_ARGS, 0, nullptr, - &query_size)); - std::vector query_data(query_size); + &property_size)); + + std::vector property_value(property_size); ASSERT_EQ_RESULT(urKernelGetInfo(kernel, UR_KERNEL_INFO_NUM_ARGS, - query_data.size() - 1, query_data.data(), - nullptr), + property_value.size() - 1, + property_value.data(), nullptr), UR_RESULT_ERROR_INVALID_SIZE); } TEST_P(urKernelGetInfoTest, InvalidNullPointerPropValue) { - size_t query_size = 0; + size_t property_size = 0; ASSERT_SUCCESS(urKernelGetInfo(kernel, UR_KERNEL_INFO_NUM_ARGS, 0, nullptr, - &query_size)); - ASSERT_EQ_RESULT(urKernelGetInfo(kernel, UR_KERNEL_INFO_NUM_ARGS, query_size, - nullptr, nullptr), + &property_size)); + ASSERT_EQ_RESULT(urKernelGetInfo(kernel, UR_KERNEL_INFO_NUM_ARGS, + property_size, nullptr, nullptr), UR_RESULT_ERROR_INVALID_NULL_POINTER); } @@ -187,15 +197,21 @@ TEST_P(urKernelGetInfoTest, InvalidNullPointerPropSizeRet) { } TEST_P(urKernelGetInfoTest, KernelNameCorrect) { - size_t name_size = 0; - std::vector name_data; + size_t property_size = 0; + ASSERT_SUCCESS(urKernelGetInfo(kernel, UR_KERNEL_INFO_FUNCTION_NAME, 0, - nullptr, &name_size)); - name_data.resize(name_size); + nullptr, &property_size)); + ASSERT_GT(property_size, 0); + + std::vector property_value(property_size, 'x'); ASSERT_SUCCESS(urKernelGetInfo(kernel, UR_KERNEL_INFO_FUNCTION_NAME, - name_size, name_data.data(), nullptr)); - ASSERT_EQ(name_data[name_size - 1], '\0'); - ASSERT_STREQ(kernel_name.c_str(), name_data.data()); + property_size, property_value.data(), + nullptr)); + + ASSERT_EQ(property_size, property_value.size()); + EXPECT_NE(property_value[0], 'x'); + EXPECT_EQ(property_value[property_size - 1], '\0'); + ASSERT_STREQ(kernel_name.c_str(), property_value.data()); } TEST_P(urKernelGetInfoTest, KernelContextCorrect) { diff --git a/test/conformance/kernel/urKernelGetSubGroupInfo.cpp b/test/conformance/kernel/urKernelGetSubGroupInfo.cpp index 10eb9fcfe8..b7859eda07 100644 --- a/test/conformance/kernel/urKernelGetSubGroupInfo.cpp +++ b/test/conformance/kernel/urKernelGetSubGroupInfo.cpp @@ -24,7 +24,7 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P( TEST_P(urKernelGetSubGroupInfoFixedSubGroupSizeTest, SuccessCompileNumSubGroups) { - ur_kernel_sub_group_info_t property_name = + const ur_kernel_sub_group_info_t property_name = UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS; size_t property_size = 0; @@ -34,7 +34,7 @@ TEST_P(urKernelGetSubGroupInfoFixedSubGroupSizeTest, property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - uint32_t property_value; + uint32_t property_value = 999; ASSERT_SUCCESS(urKernelGetSubGroupInfo( kernel, device, property_name, property_size, &property_value, nullptr)); ASSERT_EQ(property_value, num_sub_groups); @@ -46,7 +46,7 @@ struct urKernelGetSubGroupInfoTest : uur::urKernelTest { UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urKernelGetSubGroupInfoTest); TEST_P(urKernelGetSubGroupInfoTest, SuccessMaxSubGroupSize) { - ur_kernel_sub_group_info_t property_name = + const ur_kernel_sub_group_info_t property_name = UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE; size_t property_size = 0; @@ -56,14 +56,15 @@ TEST_P(urKernelGetSubGroupInfoTest, SuccessMaxSubGroupSize) { property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - std::vector property_value(property_size); - ASSERT_SUCCESS(urKernelGetSubGroupInfo(kernel, device, property_name, - property_size, property_value.data(), - nullptr)); + uint32_t property_value = 999; + ASSERT_SUCCESS(urKernelGetSubGroupInfo( + kernel, device, property_name, property_size, &property_value, nullptr)); + + ASSERT_NE(property_value, 999); } TEST_P(urKernelGetSubGroupInfoTest, SuccessMaxNumSubGroups) { - ur_kernel_sub_group_info_t property_name = + const ur_kernel_sub_group_info_t property_name = UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS; size_t property_size = 0; @@ -73,14 +74,15 @@ TEST_P(urKernelGetSubGroupInfoTest, SuccessMaxNumSubGroups) { property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - std::vector property_value(property_size); - ASSERT_SUCCESS(urKernelGetSubGroupInfo(kernel, device, property_name, - property_size, property_value.data(), - nullptr)); + uint32_t property_value = 999; + ASSERT_SUCCESS(urKernelGetSubGroupInfo( + kernel, device, property_name, property_size, &property_value, nullptr)); + + ASSERT_NE(property_value, 999); } TEST_P(urKernelGetSubGroupInfoTest, SuccessSubGroupSizeIntel) { - ur_kernel_sub_group_info_t property_name = + const ur_kernel_sub_group_info_t property_name = UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL; size_t property_size = 0; @@ -90,43 +92,49 @@ TEST_P(urKernelGetSubGroupInfoTest, SuccessSubGroupSizeIntel) { property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - std::vector property_value(property_size); - ASSERT_SUCCESS(urKernelGetSubGroupInfo(kernel, device, property_name, - property_size, property_value.data(), - nullptr)); + uint32_t property_value = 999; + ASSERT_SUCCESS(urKernelGetSubGroupInfo( + kernel, device, property_name, property_size, &property_value, nullptr)); + + ASSERT_NE(property_value, 999); } TEST_P(urKernelGetSubGroupInfoTest, SuccessCompileNumSubgroupsIsZero) { // Returns 0 by default when there is no specific information - size_t subgroups = 1; + size_t sub_groups = 1; + ASSERT_SUCCESS(urKernelGetSubGroupInfo( kernel, device, UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS, - sizeof(subgroups), &subgroups, nullptr)); - ASSERT_EQ(subgroups, 0); + sizeof(sub_groups), &sub_groups, nullptr)); + + ASSERT_EQ(sub_groups, 0); } TEST_P(urKernelGetSubGroupInfoTest, InvalidNullHandleKernel) { - uint32_t max_num_sub_groups = 0; - ASSERT_EQ_RESULT( - UR_RESULT_ERROR_INVALID_NULL_HANDLE, - urKernelGetSubGroupInfo( - nullptr, device, UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS, - sizeof(max_num_sub_groups), &max_num_sub_groups, nullptr)); + uint32_t property_value = 0; + + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, + urKernelGetSubGroupInfo( + nullptr, device, + UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS, + sizeof(property_value), &property_value, nullptr)); } TEST_P(urKernelGetSubGroupInfoTest, InvalidNullHandleDevice) { - uint32_t max_num_sub_groups = 0; - ASSERT_EQ_RESULT( - UR_RESULT_ERROR_INVALID_NULL_HANDLE, - urKernelGetSubGroupInfo( - kernel, nullptr, UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS, - sizeof(max_num_sub_groups), &max_num_sub_groups, nullptr)); + uint32_t property_value = 0; + + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, + urKernelGetSubGroupInfo( + kernel, nullptr, + UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS, + sizeof(property_value), &property_value, nullptr)); } TEST_P(urKernelGetSubGroupInfoTest, InvalidEnumeration) { - size_t bad_enum_length = 0; + size_t property_size = 0; + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION, urKernelGetSubGroupInfo( kernel, device, UR_KERNEL_SUB_GROUP_INFO_FORCE_UINT32, 0, - nullptr, &bad_enum_length)); + nullptr, &property_size)); } diff --git a/test/conformance/memory/urMemGetInfo.cpp b/test/conformance/memory/urMemGetInfo.cpp index d307a34fc0..18f8f3c55a 100644 --- a/test/conformance/memory/urMemGetInfo.cpp +++ b/test/conformance/memory/urMemGetInfo.cpp @@ -14,7 +14,7 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urMemGetInfoTest); TEST_P(urMemGetInfoTest, SuccessSize) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); - ur_mem_info_t property_name = UR_MEM_INFO_SIZE; + const ur_mem_info_t property_name = UR_MEM_INFO_SIZE; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -22,17 +22,17 @@ TEST_P(urMemGetInfoTest, SuccessSize) { property_name); ASSERT_EQ(property_size, sizeof(size_t)); - size_t returned_size = 0; + size_t property_value = 0; ASSERT_SUCCESS(urMemGetInfo(buffer, property_name, property_size, - &returned_size, nullptr)); + &property_value, nullptr)); - ASSERT_GE(returned_size, allocation_size); + ASSERT_GE(property_value, allocation_size); } TEST_P(urMemGetInfoTest, SuccessContext) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); - ur_mem_info_t property_name = UR_MEM_INFO_CONTEXT; + const ur_mem_info_t property_name = UR_MEM_INFO_CONTEXT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -40,17 +40,17 @@ TEST_P(urMemGetInfoTest, SuccessContext) { property_name); ASSERT_EQ(property_size, sizeof(ur_context_handle_t)); - ur_context_handle_t returned_context = nullptr; + ur_context_handle_t property_value = nullptr; ASSERT_SUCCESS(urMemGetInfo(buffer, property_name, property_size, - &returned_context, nullptr)); + &property_value, nullptr)); - ASSERT_EQ(context, returned_context); + ASSERT_EQ(context, property_value); } TEST_P(urMemGetInfoTest, SuccessReferenceCount) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); - ur_mem_info_t property_name = UR_MEM_INFO_REFERENCE_COUNT; + const ur_mem_info_t property_name = UR_MEM_INFO_REFERENCE_COUNT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -58,46 +58,49 @@ TEST_P(urMemGetInfoTest, SuccessReferenceCount) { property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - uint32_t returned_reference_count = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urMemGetInfo(buffer, property_name, property_size, - &returned_reference_count, nullptr)); + &property_value, nullptr)); - ASSERT_GT(returned_reference_count, 0); + ASSERT_GT(property_value, 0); } TEST_P(urMemGetInfoTest, InvalidNullHandleMemory) { - size_t mem_size = 0; + size_t property_size = 0; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, - urMemGetInfo(nullptr, UR_MEM_INFO_SIZE, sizeof(size_t), - &mem_size, nullptr)); + urMemGetInfo(nullptr, UR_MEM_INFO_SIZE, + sizeof(property_size), &property_size, + nullptr)); } TEST_P(urMemGetInfoTest, InvalidEnumerationMemInfoType) { - size_t mem_size = 0; + size_t property_size = 0; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION, urMemGetInfo(buffer, UR_MEM_INFO_FORCE_UINT32, - sizeof(size_t), &mem_size, nullptr)); + sizeof(property_size), &property_size, + nullptr)); } TEST_P(urMemGetInfoTest, InvalidSizeZero) { - size_t mem_size = 0; + size_t property_size = 0; ASSERT_EQ_RESULT( - urMemGetInfo(buffer, UR_MEM_INFO_SIZE, 0, &mem_size, nullptr), + urMemGetInfo(buffer, UR_MEM_INFO_SIZE, 0, &property_size, nullptr), UR_RESULT_ERROR_INVALID_SIZE); } TEST_P(urMemGetInfoTest, InvalidSizeSmall) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); - size_t mem_size = 0; - ASSERT_EQ_RESULT(urMemGetInfo(buffer, UR_MEM_INFO_SIZE, sizeof(mem_size) - 1, - &mem_size, nullptr), + size_t property_size = 0; + ASSERT_EQ_RESULT(urMemGetInfo(buffer, UR_MEM_INFO_SIZE, + sizeof(property_size) - 1, &property_size, + nullptr), UR_RESULT_ERROR_INVALID_SIZE); } TEST_P(urMemGetInfoTest, InvalidNullPointerParamValue) { - size_t mem_size = 0; - ASSERT_EQ_RESULT(urMemGetInfo(buffer, UR_MEM_INFO_SIZE, sizeof(mem_size), + size_t property_size = 0; + ASSERT_EQ_RESULT(urMemGetInfo(buffer, UR_MEM_INFO_SIZE, sizeof(property_size), nullptr, nullptr), UR_RESULT_ERROR_INVALID_NULL_POINTER); } @@ -113,12 +116,13 @@ struct urMemGetInfoImageTest : uur::urMemImageTest { uur::urMemImageTest::SetUp(); } }; + UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urMemGetInfoImageTest); TEST_P(urMemGetInfoImageTest, SuccessSize) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::OpenCL{"UHD Graphics"}); - ur_mem_info_t property_name = UR_MEM_INFO_SIZE; + const ur_mem_info_t property_name = UR_MEM_INFO_SIZE; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -126,20 +130,20 @@ TEST_P(urMemGetInfoImageTest, SuccessSize) { property_name); ASSERT_EQ(property_size, sizeof(size_t)); - size_t image_size_bytes = 0; + size_t property_value = 0; ASSERT_SUCCESS(urMemGetInfo(image, property_name, property_size, - &image_size_bytes, nullptr)); + &property_value, nullptr)); const size_t expected_pixel_size = sizeof(uint8_t) * 4; const size_t expected_image_size = expected_pixel_size * image_desc.arraySize * image_desc.width * image_desc.height * image_desc.depth; - ASSERT_EQ(image_size_bytes, expected_image_size); + ASSERT_EQ(property_value, expected_image_size); } TEST_P(urMemGetInfoImageTest, SuccessContext) { - ur_mem_info_t property_name = UR_MEM_INFO_CONTEXT; + const ur_mem_info_t property_name = UR_MEM_INFO_CONTEXT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -147,15 +151,15 @@ TEST_P(urMemGetInfoImageTest, SuccessContext) { property_name); ASSERT_EQ(property_size, sizeof(ur_context_handle_t)); - ur_context_handle_t returned_context = nullptr; + ur_context_handle_t property_value = nullptr; ASSERT_SUCCESS(urMemGetInfo(image, property_name, property_size, - &returned_context, nullptr)); + &property_value, nullptr)); - ASSERT_EQ(context, returned_context); + ASSERT_EQ(context, property_value); } TEST_P(urMemGetInfoImageTest, SuccessReferenceCount) { - ur_mem_info_t property_name = UR_MEM_INFO_REFERENCE_COUNT; + const ur_mem_info_t property_name = UR_MEM_INFO_REFERENCE_COUNT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -163,9 +167,9 @@ TEST_P(urMemGetInfoImageTest, SuccessReferenceCount) { property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - uint32_t returned_reference_count = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urMemGetInfo(image, property_name, property_size, - &returned_reference_count, nullptr)); + &property_value, nullptr)); - ASSERT_GT(returned_reference_count, 0); + ASSERT_GT(property_value, 0); } diff --git a/test/conformance/platform/urPlatformGetInfo.cpp b/test/conformance/platform/urPlatformGetInfo.cpp index 3fa8333af0..95c4236b46 100644 --- a/test/conformance/platform/urPlatformGetInfo.cpp +++ b/test/conformance/platform/urPlatformGetInfo.cpp @@ -13,7 +13,7 @@ using urPlatformGetInfoTest = uur::urPlatformTest; UUR_INSTANTIATE_PLATFORM_TEST_SUITE_P(urPlatformGetInfoTest); TEST_P(urPlatformGetInfoTest, SuccessName) { - ur_platform_info_t property_name = UR_PLATFORM_INFO_NAME; + const ur_platform_info_t property_name = UR_PLATFORM_INFO_NAME; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -21,15 +21,17 @@ TEST_P(urPlatformGetInfoTest, SuccessName) { property_name); ASSERT_GT(property_size, 0); - std::vector returned_name(property_size); + std::vector property_value(property_size, 'x'); ASSERT_SUCCESS(urPlatformGetInfo(platform, property_name, property_size, - returned_name.data(), nullptr)); + property_value.data(), nullptr)); - ASSERT_EQ(property_size, returned_name.size()); + ASSERT_EQ(property_size, property_value.size()); + EXPECT_NE(property_value[0], 'x'); + EXPECT_EQ(property_value[property_size - 1], '\0'); } TEST_P(urPlatformGetInfoTest, SuccessVendorName) { - ur_platform_info_t property_name = UR_PLATFORM_INFO_VENDOR_NAME; + const ur_platform_info_t property_name = UR_PLATFORM_INFO_VENDOR_NAME; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -37,15 +39,17 @@ TEST_P(urPlatformGetInfoTest, SuccessVendorName) { property_name); ASSERT_GT(property_size, 0); - std::vector returned_vendor_name(property_size); + std::vector property_value(property_size, 'x'); ASSERT_SUCCESS(urPlatformGetInfo(platform, property_name, property_size, - returned_vendor_name.data(), nullptr)); + property_value.data(), nullptr)); - ASSERT_EQ(property_size, returned_vendor_name.size()); + ASSERT_EQ(property_size, property_value.size()); + EXPECT_NE(property_value[0], 'x'); + EXPECT_EQ(property_value[property_size - 1], '\0'); } TEST_P(urPlatformGetInfoTest, SuccessVersion) { - ur_platform_info_t property_name = UR_PLATFORM_INFO_VERSION; + const ur_platform_info_t property_name = UR_PLATFORM_INFO_VERSION; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -53,15 +57,17 @@ TEST_P(urPlatformGetInfoTest, SuccessVersion) { property_name); ASSERT_GT(property_size, 0); - std::vector returned_version(property_size); + std::vector property_value(property_size, 'x'); ASSERT_SUCCESS(urPlatformGetInfo(platform, property_name, property_size, - returned_version.data(), nullptr)); + property_value.data(), nullptr)); - ASSERT_EQ(property_size, returned_version.size()); + ASSERT_EQ(property_size, property_value.size()); + EXPECT_NE(property_value[0], 'x'); + EXPECT_EQ(property_value[property_size - 1], '\0'); } TEST_P(urPlatformGetInfoTest, SuccessExtensions) { - ur_platform_info_t property_name = UR_PLATFORM_INFO_EXTENSIONS; + const ur_platform_info_t property_name = UR_PLATFORM_INFO_EXTENSIONS; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -69,15 +75,17 @@ TEST_P(urPlatformGetInfoTest, SuccessExtensions) { property_name); ASSERT_GT(property_size, 0); - std::vector returned_extensions(property_size); + std::vector property_value(property_size, 'x'); ASSERT_SUCCESS(urPlatformGetInfo(platform, property_name, property_size, - returned_extensions.data(), nullptr)); + property_value.data(), nullptr)); - ASSERT_EQ(property_size, returned_extensions.size()); + ASSERT_EQ(property_size, property_value.size()); + EXPECT_NE(property_value[0], 'x'); + EXPECT_EQ(property_value[property_size - 1], '\0'); } TEST_P(urPlatformGetInfoTest, SuccessProfile) { - ur_platform_info_t property_name = UR_PLATFORM_INFO_PROFILE; + const ur_platform_info_t property_name = UR_PLATFORM_INFO_PROFILE; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -85,15 +93,17 @@ TEST_P(urPlatformGetInfoTest, SuccessProfile) { property_name); ASSERT_GT(property_size, 0); - std::vector returned_profile(property_size); + std::vector property_value(property_size, 'x'); ASSERT_SUCCESS(urPlatformGetInfo(platform, property_name, property_size, - returned_profile.data(), nullptr)); + property_value.data(), nullptr)); - ASSERT_EQ(property_size, returned_profile.size()); + ASSERT_EQ(property_size, property_value.size()); + EXPECT_NE(property_value[0], 'x'); + EXPECT_EQ(property_value[property_size - 1], '\0'); } TEST_P(urPlatformGetInfoTest, SuccessBackend) { - ur_platform_info_t property_name = UR_PLATFORM_INFO_BACKEND; + const ur_platform_info_t property_name = UR_PLATFORM_INFO_BACKEND; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -101,16 +111,16 @@ TEST_P(urPlatformGetInfoTest, SuccessBackend) { property_name); ASSERT_EQ(property_size, sizeof(ur_platform_backend_t)); - ur_platform_backend_t returned_backend = UR_PLATFORM_BACKEND_UNKNOWN; + ur_platform_backend_t property_value = UR_PLATFORM_BACKEND_UNKNOWN; ASSERT_SUCCESS(urPlatformGetInfo(platform, property_name, property_size, - &returned_backend, nullptr)); + &property_value, nullptr)); - ASSERT_TRUE(returned_backend >= UR_PLATFORM_BACKEND_LEVEL_ZERO && - returned_backend <= UR_PLATFORM_BACKEND_NATIVE_CPU); + ASSERT_TRUE(property_value >= UR_PLATFORM_BACKEND_LEVEL_ZERO && + property_value <= UR_PLATFORM_BACKEND_NATIVE_CPU); } TEST_P(urPlatformGetInfoTest, SuccessAdapter) { - ur_platform_info_t property_name = UR_PLATFORM_INFO_ADAPTER; + const ur_platform_info_t property_name = UR_PLATFORM_INFO_ADAPTER; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -118,48 +128,49 @@ TEST_P(urPlatformGetInfoTest, SuccessAdapter) { property_name); ASSERT_EQ(property_size, sizeof(ur_adapter_handle_t)); - ur_adapter_handle_t returned_adapter = nullptr; + ur_adapter_handle_t property_value = nullptr; ASSERT_SUCCESS(urPlatformGetInfo(platform, property_name, property_size, - &returned_adapter, nullptr)); + &property_value, nullptr)); auto adapter_found = std::find( uur::PlatformEnvironment::instance->adapters.begin(), - uur::PlatformEnvironment::instance->adapters.end(), returned_adapter); + uur::PlatformEnvironment::instance->adapters.end(), property_value); ASSERT_NE(adapter_found, uur::AdapterEnvironment::instance->adapters.end()); } TEST_P(urPlatformGetInfoTest, InvalidNullHandlePlatform) { - size_t size = 0; - ASSERT_EQ_RESULT( - UR_RESULT_ERROR_INVALID_NULL_HANDLE, - urPlatformGetInfo(nullptr, UR_PLATFORM_INFO_NAME, 0, nullptr, &size)); + size_t property_size = 0; + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, + urPlatformGetInfo(nullptr, UR_PLATFORM_INFO_NAME, 0, nullptr, + &property_size)); } TEST_P(urPlatformGetInfoTest, InvalidEnumerationPlatformInfoType) { - size_t size = 0; + size_t property_size = 0; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION, urPlatformGetInfo(platform, UR_PLATFORM_INFO_FORCE_UINT32, 0, - nullptr, &size)); + nullptr, &property_size)); } TEST_P(urPlatformGetInfoTest, InvalidSizeZero) { - ur_platform_backend_t backend = UR_PLATFORM_BACKEND_UNKNOWN; + ur_platform_backend_t property_value = UR_PLATFORM_BACKEND_UNKNOWN; ASSERT_EQ_RESULT(urPlatformGetInfo(platform, UR_PLATFORM_INFO_BACKEND, 0, - &backend, nullptr), + &property_value, nullptr), UR_RESULT_ERROR_INVALID_SIZE); } TEST_P(urPlatformGetInfoTest, InvalidSizeSmall) { - ur_platform_backend_t backend = UR_PLATFORM_BACKEND_UNKNOWN; + ur_platform_backend_t property_value = UR_PLATFORM_BACKEND_UNKNOWN; ASSERT_EQ_RESULT(urPlatformGetInfo(platform, UR_PLATFORM_INFO_BACKEND, - sizeof(backend) - 1, &backend, nullptr), + sizeof(property_value) - 1, + &property_value, nullptr), UR_RESULT_ERROR_INVALID_SIZE); } TEST_P(urPlatformGetInfoTest, InvalidNullPointerPropValue) { - ur_platform_backend_t backend = UR_PLATFORM_BACKEND_UNKNOWN; + ur_platform_backend_t property_value = UR_PLATFORM_BACKEND_UNKNOWN; ASSERT_EQ_RESULT(urPlatformGetInfo(platform, UR_PLATFORM_INFO_BACKEND, - sizeof(backend), nullptr, nullptr), + sizeof(property_value), nullptr, nullptr), UR_RESULT_ERROR_INVALID_NULL_POINTER); } diff --git a/test/conformance/program/urProgramGetBuildInfo.cpp b/test/conformance/program/urProgramGetBuildInfo.cpp index 2a3e295cda..5efbb6935b 100644 --- a/test/conformance/program/urProgramGetBuildInfo.cpp +++ b/test/conformance/program/urProgramGetBuildInfo.cpp @@ -13,13 +13,14 @@ struct urProgramGetBuildInfoTest : uur::urProgramTest { ASSERT_SUCCESS(urProgramBuild(this->context, program, nullptr)); } }; + UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urProgramGetBuildInfoTest); TEST_P(urProgramGetBuildInfoTest, SuccessStatus) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::LevelZeroV2{}); size_t property_size = 0; - ur_program_build_info_t property_name = UR_PROGRAM_BUILD_INFO_STATUS; + const ur_program_build_info_t property_name = UR_PROGRAM_BUILD_INFO_STATUS; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetBuildInfo(program, device, property_name, 0, nullptr, @@ -27,19 +28,18 @@ TEST_P(urProgramGetBuildInfoTest, SuccessStatus) { property_name); ASSERT_EQ(sizeof(ur_program_build_status_t), property_size); - ur_program_build_status_t returned_status = + ur_program_build_status_t property_value = UR_PROGRAM_BUILD_STATUS_FORCE_UINT32; - ASSERT_SUCCESS(urProgramGetBuildInfo(program, device, property_name, - property_size, &returned_status, - nullptr)); + ASSERT_SUCCESS(urProgramGetBuildInfo( + program, device, property_name, property_size, &property_value, nullptr)); - ASSERT_GE(returned_status, UR_PROGRAM_BUILD_STATUS_NONE); - ASSERT_LE(returned_status, UR_PROGRAM_BUILD_STATUS_IN_PROGRESS); + ASSERT_GE(property_value, UR_PROGRAM_BUILD_STATUS_NONE); + ASSERT_LE(property_value, UR_PROGRAM_BUILD_STATUS_IN_PROGRESS); } TEST_P(urProgramGetBuildInfoTest, SuccessOptions) { size_t property_size = 0; - ur_program_build_info_t property_name = UR_PROGRAM_BUILD_INFO_OPTIONS; + const ur_program_build_info_t property_name = UR_PROGRAM_BUILD_INFO_OPTIONS; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetBuildInfo(program, device, property_name, 0, nullptr, @@ -47,21 +47,21 @@ TEST_P(urProgramGetBuildInfoTest, SuccessOptions) { property_name); ASSERT_GT(property_size, 0); - std::vector returned_options(property_size); - returned_options[property_size - 1] = 'x'; + std::vector property_value(property_size, 'x'); ASSERT_SUCCESS(urProgramGetBuildInfo(program, device, property_name, - property_size, returned_options.data(), + property_size, property_value.data(), nullptr)); - ASSERT_EQ(property_size, returned_options.size()); - ASSERT_EQ(returned_options[property_size - 1], '\0'); + ASSERT_EQ(property_size, property_value.size()); + EXPECT_NE(property_value[0], 'x'); + EXPECT_EQ(property_value[property_size - 1], '\0'); } TEST_P(urProgramGetBuildInfoTest, SuccessLog) { UUR_KNOWN_FAILURE_ON(uur::CUDA{}); size_t property_size = 0; - ur_program_build_info_t property_name = UR_PROGRAM_BUILD_INFO_LOG; + const ur_program_build_info_t property_name = UR_PROGRAM_BUILD_INFO_LOG; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetBuildInfo(program, device, property_name, 0, nullptr, @@ -69,19 +69,20 @@ TEST_P(urProgramGetBuildInfoTest, SuccessLog) { property_name); ASSERT_GT(property_size, 0); - std::vector returned_log(property_size); - returned_log[property_size - 1] = 'x'; + std::vector property_value(property_size, 'x'); ASSERT_SUCCESS(urProgramGetBuildInfo(program, device, property_name, - property_size, returned_log.data(), + property_size, property_value.data(), nullptr)); - ASSERT_EQ(property_size, returned_log.size()); - ASSERT_EQ(returned_log[property_size - 1], '\0'); + ASSERT_EQ(property_size, property_value.size()); + EXPECT_NE(property_value[0], 'x'); + EXPECT_EQ(property_value[property_size - 1], '\0'); } TEST_P(urProgramGetBuildInfoTest, SuccessBinaryType) { size_t property_size = 0; - ur_program_build_info_t property_name = UR_PROGRAM_BUILD_INFO_BINARY_TYPE; + const ur_program_build_info_t property_name = + UR_PROGRAM_BUILD_INFO_BINARY_TYPE; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetBuildInfo(program, device, property_name, 0, nullptr, @@ -89,38 +90,34 @@ TEST_P(urProgramGetBuildInfoTest, SuccessBinaryType) { property_name); ASSERT_EQ(sizeof(ur_program_binary_type_t), property_size); - ur_program_binary_type_t returned_binary_type = - UR_PROGRAM_BINARY_TYPE_FORCE_UINT32; - ASSERT_SUCCESS(urProgramGetBuildInfo(program, device, property_name, - property_size, &returned_binary_type, - nullptr)); + ur_program_binary_type_t property_value = UR_PROGRAM_BINARY_TYPE_FORCE_UINT32; + ASSERT_SUCCESS(urProgramGetBuildInfo( + program, device, property_name, property_size, &property_value, nullptr)); - ASSERT_GE(returned_binary_type, UR_PROGRAM_BINARY_TYPE_NONE); - ASSERT_LE(returned_binary_type, UR_PROGRAM_BINARY_TYPE_EXECUTABLE); + ASSERT_GE(property_value, UR_PROGRAM_BINARY_TYPE_NONE); + ASSERT_LE(property_value, UR_PROGRAM_BINARY_TYPE_EXECUTABLE); } TEST_P(urProgramGetBuildInfoTest, InvalidNullHandleProgram) { - ur_program_build_status_t programBuildStatus = UR_PROGRAM_BUILD_STATUS_ERROR; - ASSERT_EQ_RESULT(urProgramGetBuildInfo(nullptr, device, - UR_PROGRAM_BUILD_INFO_STATUS, - sizeof(programBuildStatus), - &programBuildStatus, nullptr), - UR_RESULT_ERROR_INVALID_NULL_HANDLE); + ur_program_build_status_t property_value = UR_PROGRAM_BUILD_STATUS_ERROR; + ASSERT_EQ_RESULT( + urProgramGetBuildInfo(nullptr, device, UR_PROGRAM_BUILD_INFO_STATUS, + sizeof(property_value), &property_value, nullptr), + UR_RESULT_ERROR_INVALID_NULL_HANDLE); } TEST_P(urProgramGetBuildInfoTest, InvalidNullHandleDevice) { - ur_program_build_status_t programBuildStatus = UR_PROGRAM_BUILD_STATUS_ERROR; - ASSERT_EQ_RESULT(urProgramGetBuildInfo(program, nullptr, - UR_PROGRAM_BUILD_INFO_STATUS, - sizeof(programBuildStatus), - &programBuildStatus, nullptr), - UR_RESULT_ERROR_INVALID_NULL_HANDLE); + ur_program_build_status_t property_value = UR_PROGRAM_BUILD_STATUS_ERROR; + ASSERT_EQ_RESULT( + urProgramGetBuildInfo(program, nullptr, UR_PROGRAM_BUILD_INFO_STATUS, + sizeof(property_value), &property_value, nullptr), + UR_RESULT_ERROR_INVALID_NULL_HANDLE); } TEST_P(urProgramGetBuildInfoTest, InvalidEnumeration) { - size_t propSizeOut = UR_PROGRAM_BUILD_STATUS_ERROR; + size_t property_size = UR_PROGRAM_BUILD_STATUS_ERROR; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION, urProgramGetBuildInfo(program, device, UR_PROGRAM_BUILD_INFO_FORCE_UINT32, 0, - nullptr, &propSizeOut)); + nullptr, &property_size)); } diff --git a/test/conformance/program/urProgramGetInfo.cpp b/test/conformance/program/urProgramGetInfo.cpp index 3aa380b86c..81db274fa5 100644 --- a/test/conformance/program/urProgramGetInfo.cpp +++ b/test/conformance/program/urProgramGetInfo.cpp @@ -19,114 +19,120 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urProgramGetInfoTest); TEST_P(urProgramGetInfoTest, SuccessReferenceCount) { size_t property_size = 0; - ur_program_info_t property_name = UR_PROGRAM_INFO_REFERENCE_COUNT; + const ur_program_info_t property_name = UR_PROGRAM_INFO_REFERENCE_COUNT; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetInfo(program, property_name, 0, nullptr, &property_size), property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - uint32_t returned_reference_count = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urProgramGetInfo(program, property_name, property_size, - &returned_reference_count, nullptr)); + &property_value, nullptr)); - ASSERT_GT(returned_reference_count, 0U); + ASSERT_GT(property_value, 0U); } TEST_P(urProgramGetInfoTest, SuccessContext) { size_t property_size = 0; - ur_program_info_t property_name = UR_PROGRAM_INFO_CONTEXT; + const ur_program_info_t property_name = UR_PROGRAM_INFO_CONTEXT; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetInfo(program, property_name, 0, nullptr, &property_size), property_name); ASSERT_EQ(property_size, sizeof(ur_context_handle_t)); - ur_context_handle_t returned_context = nullptr; + ur_context_handle_t property_value = nullptr; ASSERT_SUCCESS(urProgramGetInfo(program, property_name, property_size, - &returned_context, nullptr)); + &property_value, nullptr)); - ASSERT_EQ(returned_context, context); + ASSERT_EQ(property_value, context); } TEST_P(urProgramGetInfoTest, SuccessNumDevices) { size_t property_size = 0; - ur_program_info_t property_name = UR_PROGRAM_INFO_NUM_DEVICES; + const ur_program_info_t property_name = UR_PROGRAM_INFO_NUM_DEVICES; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetInfo(program, property_name, 0, nullptr, &property_size), property_name); ASSERT_EQ(property_size, sizeof(uint32_t)); - uint32_t returned_num_devices = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urProgramGetInfo(program, property_name, property_size, - &returned_num_devices, nullptr)); + &property_value, nullptr)); - ASSERT_GE(uur::DevicesEnvironment::instance->devices.size(), - returned_num_devices); + ASSERT_GE(uur::DevicesEnvironment::instance->devices.size(), property_value); } TEST_P(urProgramGetInfoTest, SuccessDevices) { size_t property_size = 0; - ur_program_info_t property_name = UR_PROGRAM_INFO_DEVICES; + const ur_program_info_t property_name = UR_PROGRAM_INFO_DEVICES; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetInfo(program, property_name, 0, nullptr, &property_size), property_name); ASSERT_EQ(property_size, sizeof(ur_context_handle_t)); - std::vector returned_devices(property_size); + std::vector property_value(property_size); ASSERT_SUCCESS(urProgramGetInfo(program, property_name, property_size, - returned_devices.data(), nullptr)); + property_value.data(), nullptr)); + ASSERT_EQ(property_size, property_value.size()); size_t devices_count = property_size / sizeof(ur_device_handle_t); ASSERT_EQ(devices_count, 1); - ASSERT_EQ(returned_devices[0], device); + ASSERT_EQ(property_value[0], device); } TEST_P(urProgramGetInfoTest, SuccessIL) { size_t property_size = 0; - ur_program_info_t property_name = UR_PROGRAM_INFO_IL; + const ur_program_info_t property_name = UR_PROGRAM_INFO_IL; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetInfo(program, property_name, 0, nullptr, &property_size), property_name); ASSERT_GE(property_size, 0); - std::vector returned_il(property_size); + std::vector property_value(property_size, 'x'); // Some adapters only support ProgramCreateWithBinary, in those cases we // expect a return size of 0 and an empty return value for INFO_IL. if (property_size > 0) { ASSERT_SUCCESS(urProgramGetInfo(program, UR_PROGRAM_INFO_IL, property_size, - returned_il.data(), nullptr)); - ASSERT_EQ(returned_il, *il_binary.get()); + property_value.data(), nullptr)); + ASSERT_EQ(property_size, property_value.size()); + EXPECT_NE(property_value[0], 'x'); + EXPECT_EQ(property_value[property_size - 1], '\0'); + ASSERT_EQ(property_value, *il_binary.get()); } else { - ASSERT_TRUE(returned_il.empty()); + ASSERT_TRUE(property_value.empty()); } } TEST_P(urProgramGetInfoTest, SuccessBinarySizes) { size_t property_size = 0; - ur_program_info_t property_name = UR_PROGRAM_INFO_BINARY_SIZES; + const ur_program_info_t property_name = UR_PROGRAM_INFO_BINARY_SIZES; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetInfo(program, property_name, 0, nullptr, &property_size), property_name); - ASSERT_NE(property_size, 0); + ASSERT_GT(property_size, 0); - std::vector binary_sizes(property_size / sizeof(size_t)); - ASSERT_SUCCESS(urProgramGetInfo(program, UR_PROGRAM_INFO_BINARY_SIZES, - property_size, binary_sizes.data(), nullptr)); + // set a default vector value and check its overwritten? - for (const auto &binary_size : binary_sizes) { + std::vector property_value(property_size / sizeof(size_t), 0); + ASSERT_SUCCESS(urProgramGetInfo(program, property_name, property_size, + property_value.data(), nullptr)); + ASSERT_EQ(property_size, property_value.size() * sizeof(size_t)); + + for (const auto &binary_size : property_value) { ASSERT_GT(binary_size, 0); } } TEST_P(urProgramGetInfoTest, SuccessBinaries) { size_t binary_sizes_len = 0; - std::vector property_value; + std::vector property_value(0); ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetInfo(program, UR_PROGRAM_INFO_BINARY_SIZES, 0, nullptr, @@ -139,8 +145,10 @@ TEST_P(urProgramGetInfoTest, SuccessBinaries) { size_t binary_sizes[1] = {binary_sizes_len}; ASSERT_SUCCESS(urProgramGetInfo(program, UR_PROGRAM_INFO_BINARY_SIZES, binary_sizes_len, binary_sizes, nullptr)); + property_value.resize(binary_sizes[0]); char *binaries[1] = {property_value.data()}; + ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetInfo(program, UR_PROGRAM_INFO_BINARIES, sizeof(binaries[0]), binaries, nullptr), @@ -151,63 +159,65 @@ TEST_P(urProgramGetInfoTest, SuccessNumKernels) { UUR_KNOWN_FAILURE_ON(uur::HIP{}); size_t property_size = 0; - ur_program_info_t property_name = UR_PROGRAM_INFO_NUM_KERNELS; + const ur_program_info_t property_name = UR_PROGRAM_INFO_NUM_KERNELS; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetInfo(program, property_name, 0, nullptr, &property_size), property_name); ASSERT_EQ(property_size, sizeof(size_t)); - size_t returned_num_kernels = 0; + size_t property_value = 0; ASSERT_SUCCESS(urProgramGetInfo(program, property_name, property_size, - &returned_num_kernels, nullptr)); + &property_value, nullptr)); - ASSERT_GT(returned_num_kernels, 0U); + ASSERT_GT(property_value, 0U); } TEST_P(urProgramGetInfoTest, SuccessKernelNames) { size_t property_size = 0; - ur_program_info_t property_name = UR_PROGRAM_INFO_KERNEL_NAMES; + const ur_program_info_t property_name = UR_PROGRAM_INFO_KERNEL_NAMES; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urProgramGetInfo(program, property_name, 0, nullptr, &property_size), property_name); ASSERT_GT(property_size, 0); - std::vector returned_kernel_names(property_size); - returned_kernel_names[property_size - 1] = 'x'; + std::vector property_value(property_size, 'x'); ASSERT_SUCCESS(urProgramGetInfo(program, property_name, property_size, - returned_kernel_names.data(), nullptr)); + property_value.data(), nullptr)); - ASSERT_EQ(property_size, returned_kernel_names.size()); - ASSERT_EQ(returned_kernel_names[property_size - 1], '\0'); + ASSERT_EQ(property_size, property_value.size()); + EXPECT_NE(property_value[0], 'x'); + EXPECT_EQ(property_value[property_size - 1], '\0'); } TEST_P(urProgramGetInfoTest, InvalidNullHandleProgram) { - uint32_t ref_count = 0; + uint32_t property_value = 0; ASSERT_EQ_RESULT(urProgramGetInfo(nullptr, UR_PROGRAM_INFO_REFERENCE_COUNT, - sizeof(ref_count), &ref_count, nullptr), + sizeof(property_value), &property_value, + nullptr), UR_RESULT_ERROR_INVALID_NULL_HANDLE); } TEST_P(urProgramGetInfoTest, InvalidEnumeration) { - size_t prop_size = 0; + size_t property_size = 0; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION, urProgramGetInfo(program, UR_PROGRAM_INFO_FORCE_UINT32, 0, - nullptr, &prop_size)); + nullptr, &property_size)); } TEST_P(urProgramGetInfoTest, InvalidSizeZero) { - uint32_t ref_count = 0; + uint32_t property_value = 0; ASSERT_EQ_RESULT(urProgramGetInfo(program, UR_PROGRAM_INFO_REFERENCE_COUNT, 0, - &ref_count, nullptr), + &property_value, nullptr), UR_RESULT_ERROR_INVALID_SIZE); } TEST_P(urProgramGetInfoTest, InvalidSizeSmall) { - uint32_t ref_count = 0; + uint32_t property_value = 0; ASSERT_EQ_RESULT(urProgramGetInfo(program, UR_PROGRAM_INFO_REFERENCE_COUNT, - sizeof(ref_count) - 1, &ref_count, nullptr), + sizeof(property_value) - 1, &property_value, + nullptr), UR_RESULT_ERROR_INVALID_SIZE); } @@ -224,27 +234,30 @@ TEST_P(urProgramGetInfoTest, InvalidNullPointerPropValueRet) { } TEST_P(urProgramGetInfoTest, NumDevicesIsNonzero) { - uint32_t count = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urProgramGetInfo(program, UR_PROGRAM_INFO_NUM_DEVICES, - sizeof(uint32_t), &count, nullptr)); - ASSERT_GE(count, 1); + sizeof(property_value), &property_value, + nullptr)); + ASSERT_GE(property_value, 1); } TEST_P(urProgramGetInfoTest, NumDevicesMatchesDeviceArray) { - uint32_t count = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urProgramGetInfo(program, UR_PROGRAM_INFO_NUM_DEVICES, - sizeof(uint32_t), &count, nullptr)); + sizeof(property_value), &property_value, + nullptr)); size_t info_devices_size = 0; ASSERT_SUCCESS(urProgramGetInfo(program, UR_PROGRAM_INFO_DEVICES, 0, nullptr, &info_devices_size)); - ASSERT_EQ(count, info_devices_size / sizeof(ur_device_handle_t)); + ASSERT_EQ(property_value, info_devices_size / sizeof(ur_device_handle_t)); } TEST_P(urProgramGetInfoTest, NumDevicesMatchesContextNumDevices) { - uint32_t count = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urProgramGetInfo(program, UR_PROGRAM_INFO_NUM_DEVICES, - sizeof(uint32_t), &count, nullptr)); + sizeof(property_value), &property_value, + nullptr)); // The device count either matches the number of devices in the context or // is 1, depending on how it was built @@ -252,5 +265,6 @@ TEST_P(urProgramGetInfoTest, NumDevicesMatchesContextNumDevices) { ASSERT_SUCCESS(urContextGetInfo(context, UR_CONTEXT_INFO_NUM_DEVICES, sizeof(uint32_t), &info_context_devices_count, nullptr)); - ASSERT_TRUE(count == 1 || count == info_context_devices_count); + ASSERT_TRUE(property_value == 1 || + property_value == info_context_devices_count); } diff --git a/test/conformance/queue/urQueueGetInfo.cpp b/test/conformance/queue/urQueueGetInfo.cpp index bde5fe7faf..6c3f57004e 100644 --- a/test/conformance/queue/urQueueGetInfo.cpp +++ b/test/conformance/queue/urQueueGetInfo.cpp @@ -90,7 +90,6 @@ TEST_P(urQueueGetInfoTest, SuccessEmptyQueue) { ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urQueueGetInfo(queue, property_name, 0, nullptr, &property_size), property_name); - ASSERT_EQ(sizeof(ur_bool_t), property_size); } diff --git a/test/conformance/sampler/urSamplerGetInfo.cpp b/test/conformance/sampler/urSamplerGetInfo.cpp index f4dc689b5f..ad022eea67 100644 --- a/test/conformance/sampler/urSamplerGetInfo.cpp +++ b/test/conformance/sampler/urSamplerGetInfo.cpp @@ -14,43 +14,43 @@ TEST_P(urSamplerGetInfoTest, SuccessReferenceCount) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::LevelZeroV2{}); size_t property_size = 0; - ur_sampler_info_t property_name = UR_SAMPLER_INFO_REFERENCE_COUNT; + const ur_sampler_info_t property_name = UR_SAMPLER_INFO_REFERENCE_COUNT; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urSamplerGetInfo(sampler, property_name, 0, nullptr, &property_size), property_name); ASSERT_EQ(sizeof(uint32_t), property_size); - uint32_t returned_reference_count = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urSamplerGetInfo(sampler, property_name, property_size, - &returned_reference_count, nullptr)); + &property_value, nullptr)); - ASSERT_GT(returned_reference_count, 0U); + ASSERT_GT(property_value, 0U); } TEST_P(urSamplerGetInfoTest, SuccessContext) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::LevelZeroV2{}); size_t property_size = 0; - ur_sampler_info_t property_name = UR_SAMPLER_INFO_CONTEXT; + const ur_sampler_info_t property_name = UR_SAMPLER_INFO_CONTEXT; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urSamplerGetInfo(sampler, property_name, 0, nullptr, &property_size), property_name); ASSERT_EQ(sizeof(ur_context_handle_t), property_size); - ur_context_handle_t returned_context = nullptr; + ur_context_handle_t property_value = nullptr; ASSERT_SUCCESS(urSamplerGetInfo(sampler, property_name, property_size, - &returned_context, nullptr)); + &property_value, nullptr)); - ASSERT_EQ(returned_context, context); + ASSERT_EQ(property_value, context); } TEST_P(urSamplerGetInfoTest, SuccessNormalizedCoords) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::LevelZeroV2{}); size_t property_size = 0; - ur_sampler_info_t property_name = UR_SAMPLER_INFO_NORMALIZED_COORDS; + const ur_sampler_info_t property_name = UR_SAMPLER_INFO_NORMALIZED_COORDS; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urSamplerGetInfo(sampler, property_name, 0, nullptr, &property_size), @@ -62,52 +62,53 @@ TEST_P(urSamplerGetInfoTest, SuccessAddressingMode) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::LevelZeroV2{}); size_t property_size = 0; - ur_sampler_info_t property_name = UR_SAMPLER_INFO_ADDRESSING_MODE; + const ur_sampler_info_t property_name = UR_SAMPLER_INFO_ADDRESSING_MODE; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urSamplerGetInfo(sampler, property_name, 0, nullptr, &property_size), property_name); ASSERT_EQ(sizeof(ur_sampler_addressing_mode_t), property_size); - ur_sampler_addressing_mode_t returned_mode = + ur_sampler_addressing_mode_t property_value = UR_SAMPLER_ADDRESSING_MODE_FORCE_UINT32; ASSERT_SUCCESS(urSamplerGetInfo(sampler, property_name, property_size, - &returned_mode, nullptr)); + &property_value, nullptr)); - ASSERT_GE(returned_mode, UR_SAMPLER_ADDRESSING_MODE_NONE); - ASSERT_LT(returned_mode, UR_SAMPLER_ADDRESSING_MODE_FORCE_UINT32); + ASSERT_GE(property_value, UR_SAMPLER_ADDRESSING_MODE_NONE); + ASSERT_LT(property_value, UR_SAMPLER_ADDRESSING_MODE_FORCE_UINT32); } TEST_P(urSamplerGetInfoTest, SuccessFilterMode) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::LevelZeroV2{}); size_t property_size = 0; - ur_sampler_info_t property_name = UR_SAMPLER_INFO_FILTER_MODE; + const ur_sampler_info_t property_name = UR_SAMPLER_INFO_FILTER_MODE; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urSamplerGetInfo(sampler, property_name, 0, nullptr, &property_size), property_name); ASSERT_EQ(sizeof(ur_sampler_filter_mode_t), property_size); - ur_sampler_filter_mode_t returned_mode = UR_SAMPLER_FILTER_MODE_FORCE_UINT32; + ur_sampler_filter_mode_t property_value = UR_SAMPLER_FILTER_MODE_FORCE_UINT32; ASSERT_SUCCESS(urSamplerGetInfo(sampler, property_name, property_size, - &returned_mode, nullptr)); + &property_value, nullptr)); - ASSERT_GE(returned_mode, UR_SAMPLER_FILTER_MODE_NEAREST); - ASSERT_LT(returned_mode, UR_SAMPLER_FILTER_MODE_FORCE_UINT32); + ASSERT_GE(property_value, UR_SAMPLER_FILTER_MODE_NEAREST); + ASSERT_LT(property_value, UR_SAMPLER_FILTER_MODE_FORCE_UINT32); } TEST_P(urSamplerGetInfoTest, InvalidNullHandleSampler) { - uint32_t refcount = 0; + uint32_t property_value = 0; ASSERT_EQ_RESULT(urSamplerGetInfo(nullptr, UR_SAMPLER_INFO_REFERENCE_COUNT, - sizeof(refcount), &refcount, nullptr), + sizeof(property_value), &property_value, + nullptr), UR_RESULT_ERROR_INVALID_NULL_HANDLE); } TEST_P(urSamplerGetInfoTest, InvalidEnumerationInfo) { - size_t size = 0; + size_t property_size = 0; ASSERT_EQ_RESULT(urSamplerGetInfo(sampler, UR_SAMPLER_INFO_FORCE_UINT32, 0, - nullptr, &size), + nullptr, &property_size), UR_RESULT_ERROR_INVALID_ENUMERATION); } @@ -125,17 +126,18 @@ TEST_P(urSamplerGetInfoTest, InvalidNullPointerPropValue) { } TEST_P(urSamplerGetInfoTest, InvalidSizePropSizeZero) { - ur_sampler_addressing_mode_t mode = UR_SAMPLER_ADDRESSING_MODE_NONE; + ur_sampler_addressing_mode_t property_value = UR_SAMPLER_ADDRESSING_MODE_NONE; ASSERT_EQ_RESULT(urSamplerGetInfo(sampler, UR_SAMPLER_INFO_ADDRESSING_MODE, 0, - &mode, nullptr), + &property_value, nullptr), UR_RESULT_ERROR_INVALID_SIZE); } TEST_P(urSamplerGetInfoTest, InvalidSizePropSizeSmall) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}, uur::LevelZeroV2{}); - ur_sampler_addressing_mode_t mode = UR_SAMPLER_ADDRESSING_MODE_NONE; + ur_sampler_addressing_mode_t property_value = UR_SAMPLER_ADDRESSING_MODE_NONE; ASSERT_EQ_RESULT(urSamplerGetInfo(sampler, UR_SAMPLER_INFO_ADDRESSING_MODE, - sizeof(mode) - 1, &mode, nullptr), + sizeof(property_value) - 1, &property_value, + nullptr), UR_RESULT_ERROR_INVALID_SIZE); } diff --git a/test/conformance/usm/urUSMGetMemAllocInfo.cpp b/test/conformance/usm/urUSMGetMemAllocInfo.cpp index a181e5ebfe..3962aca4b1 100644 --- a/test/conformance/usm/urUSMGetMemAllocInfo.cpp +++ b/test/conformance/usm/urUSMGetMemAllocInfo.cpp @@ -28,7 +28,7 @@ TEST_P(urUSMGetMemAllocInfoPoolTest, SuccessPool) { UUR_KNOWN_FAILURE_ON(uur::OpenCL{}, uur::LevelZeroV2{}); size_t property_size = 0; - ur_usm_alloc_info_t property_name = UR_USM_ALLOC_INFO_POOL; + const ur_usm_alloc_info_t property_name = UR_USM_ALLOC_INFO_POOL; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urUSMGetMemAllocInfo(context, ptr, property_name, 0, nullptr, @@ -36,11 +36,11 @@ TEST_P(urUSMGetMemAllocInfoPoolTest, SuccessPool) { property_name); ASSERT_EQ(sizeof(ur_usm_pool_handle_t), property_size); - ur_usm_pool_handle_t returned_pool = nullptr; + ur_usm_pool_handle_t property_value = nullptr; ASSERT_SUCCESS(urUSMGetMemAllocInfo(context, ptr, property_name, - property_size, &returned_pool, nullptr)); + property_size, &property_value, nullptr)); - ASSERT_EQ(returned_pool, pool); + ASSERT_EQ(property_value, pool); } using urUSMGetMemAllocInfoTest = uur::urUSMDeviceAllocTest; @@ -50,7 +50,7 @@ TEST_P(urUSMGetMemAllocInfoTest, SuccessType) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); size_t property_size = 0; - ur_usm_alloc_info_t property_name = UR_USM_ALLOC_INFO_TYPE; + const ur_usm_alloc_info_t property_name = UR_USM_ALLOC_INFO_TYPE; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urUSMGetMemAllocInfo(context, ptr, property_name, 0, nullptr, @@ -58,18 +58,18 @@ TEST_P(urUSMGetMemAllocInfoTest, SuccessType) { property_name); ASSERT_EQ(sizeof(ur_usm_type_t), property_size); - ur_usm_type_t returned_type = UR_USM_TYPE_FORCE_UINT32; + ur_usm_type_t property_value = UR_USM_TYPE_FORCE_UINT32; ASSERT_SUCCESS(urUSMGetMemAllocInfo(context, ptr, property_name, - property_size, &returned_type, nullptr)); + property_size, &property_value, nullptr)); - ASSERT_EQ(returned_type, UR_USM_TYPE_DEVICE); + ASSERT_EQ(property_value, UR_USM_TYPE_DEVICE); } TEST_P(urUSMGetMemAllocInfoTest, SuccessBasePtr) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); size_t property_size = 0; - ur_usm_alloc_info_t property_name = UR_USM_ALLOC_INFO_BASE_PTR; + const ur_usm_alloc_info_t property_name = UR_USM_ALLOC_INFO_BASE_PTR; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urUSMGetMemAllocInfo(context, ptr, property_name, 0, nullptr, @@ -77,18 +77,18 @@ TEST_P(urUSMGetMemAllocInfoTest, SuccessBasePtr) { property_name); ASSERT_GT(property_size, 0); - void *returned_ptr = nullptr; + void *property_value = nullptr; ASSERT_SUCCESS(urUSMGetMemAllocInfo(context, ptr, property_name, - property_size, &returned_ptr, nullptr)); + property_size, &property_value, nullptr)); - ASSERT_EQ(returned_ptr, ptr); + ASSERT_EQ(property_value, ptr); } TEST_P(urUSMGetMemAllocInfoTest, SuccessSize) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); size_t property_size = 0; - ur_usm_alloc_info_t property_name = UR_USM_ALLOC_INFO_SIZE; + const ur_usm_alloc_info_t property_name = UR_USM_ALLOC_INFO_SIZE; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urUSMGetMemAllocInfo(context, ptr, property_name, 0, nullptr, @@ -96,18 +96,18 @@ TEST_P(urUSMGetMemAllocInfoTest, SuccessSize) { property_name); ASSERT_EQ(sizeof(size_t), property_size); - size_t returned_size = 0; + size_t property_value = 0; ASSERT_SUCCESS(urUSMGetMemAllocInfo(context, ptr, property_name, - property_size, &returned_size, nullptr)); + property_size, &property_value, nullptr)); - ASSERT_GE(returned_size, allocation_size); + ASSERT_GE(property_value, allocation_size); } TEST_P(urUSMGetMemAllocInfoTest, SuccessDevice) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); size_t property_size = 0; - ur_usm_alloc_info_t property_name = UR_USM_ALLOC_INFO_DEVICE; + const ur_usm_alloc_info_t property_name = UR_USM_ALLOC_INFO_DEVICE; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urUSMGetMemAllocInfo(context, ptr, property_name, 0, nullptr, @@ -115,49 +115,49 @@ TEST_P(urUSMGetMemAllocInfoTest, SuccessDevice) { property_name); ASSERT_EQ(sizeof(ur_device_handle_t), property_size); - ur_device_handle_t returned_device = nullptr; - ASSERT_SUCCESS(urUSMGetMemAllocInfo( - context, ptr, property_name, property_size, &returned_device, nullptr)); + ur_device_handle_t property_value = nullptr; + ASSERT_SUCCESS(urUSMGetMemAllocInfo(context, ptr, property_name, + property_size, &property_value, nullptr)); - ASSERT_EQ(returned_device, device); + ASSERT_EQ(property_value, device); } TEST_P(urUSMGetMemAllocInfoTest, InvalidNullHandleContext) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); - ur_usm_type_t USMType = UR_USM_TYPE_FORCE_UINT32; + ur_usm_type_t property_value = UR_USM_TYPE_FORCE_UINT32; ASSERT_EQ_RESULT( UR_RESULT_ERROR_INVALID_NULL_HANDLE, urUSMGetMemAllocInfo(nullptr, ptr, UR_USM_ALLOC_INFO_FORCE_UINT32, - sizeof(ur_usm_type_t), &USMType, nullptr)); + sizeof(ur_usm_type_t), &property_value, nullptr)); } TEST_P(urUSMGetMemAllocInfoTest, InvalidNullPointerMem) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); - ur_usm_type_t USMType = UR_USM_TYPE_FORCE_UINT32; + ur_usm_type_t property_value = UR_USM_TYPE_FORCE_UINT32; ASSERT_EQ_RESULT( UR_RESULT_ERROR_INVALID_NULL_POINTER, urUSMGetMemAllocInfo(context, nullptr, UR_USM_ALLOC_INFO_FORCE_UINT32, - sizeof(ur_usm_type_t), &USMType, nullptr)); + sizeof(ur_usm_type_t), &property_value, nullptr)); } TEST_P(urUSMGetMemAllocInfoTest, InvalidEnumeration) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); - ur_usm_type_t USMType = UR_USM_TYPE_FORCE_UINT32; + ur_usm_type_t property_value = UR_USM_TYPE_FORCE_UINT32; ASSERT_EQ_RESULT( UR_RESULT_ERROR_INVALID_ENUMERATION, urUSMGetMemAllocInfo(context, ptr, UR_USM_ALLOC_INFO_FORCE_UINT32, - sizeof(ur_usm_type_t), &USMType, nullptr)); + sizeof(ur_usm_type_t), &property_value, nullptr)); } TEST_P(urUSMGetMemAllocInfoTest, InvalidValuePropSize) { UUR_KNOWN_FAILURE_ON(uur::NativeCPU{}); - ur_usm_type_t USMType = UR_USM_TYPE_FORCE_UINT32; + ur_usm_type_t property_value = UR_USM_TYPE_FORCE_UINT32; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE, urUSMGetMemAllocInfo(context, ptr, UR_USM_ALLOC_INFO_TYPE, - sizeof(ur_usm_type_t) - 1, &USMType, - nullptr)); + sizeof(ur_usm_type_t) - 1, + &property_value, nullptr)); } diff --git a/test/conformance/usm/urUSMPoolGetInfo.cpp b/test/conformance/usm/urUSMPoolGetInfo.cpp index da49b49768..52a335bf8c 100644 --- a/test/conformance/usm/urUSMPoolGetInfo.cpp +++ b/test/conformance/usm/urUSMPoolGetInfo.cpp @@ -11,65 +11,65 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urUSMPoolGetInfoTest); TEST_P(urUSMPoolGetInfoTest, SuccessReferenceCount) { size_t property_size = 0; - ur_usm_pool_info_t property_name = UR_USM_POOL_INFO_REFERENCE_COUNT; + const ur_usm_pool_info_t property_name = UR_USM_POOL_INFO_REFERENCE_COUNT; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urUSMPoolGetInfo(pool, property_name, 0, nullptr, &property_size), property_name); ASSERT_EQ(sizeof(uint32_t), property_size); - uint32_t returned_reference_count = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urUSMPoolGetInfo(pool, property_name, property_size, - &returned_reference_count, nullptr)); + &property_value, nullptr)); - ASSERT_GT(returned_reference_count, 0U); + ASSERT_GT(property_value, 0U); } TEST_P(urUSMPoolGetInfoTest, SuccessContext) { size_t property_size = 0; - ur_usm_pool_info_t property_name = UR_USM_POOL_INFO_CONTEXT; + const ur_usm_pool_info_t property_name = UR_USM_POOL_INFO_CONTEXT; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( urUSMPoolGetInfo(pool, property_name, 0, nullptr, &property_size), property_name); ASSERT_EQ(sizeof(ur_context_handle_t), property_size); - ur_context_handle_t returned_context = nullptr; + ur_context_handle_t property_value = nullptr; ASSERT_SUCCESS(urUSMPoolGetInfo(pool, property_name, property_size, - &returned_context, nullptr)); + &property_value, nullptr)); - ASSERT_EQ(context, returned_context); + ASSERT_EQ(context, property_value); } TEST_P(urUSMPoolGetInfoTest, InvalidNullHandlePool) { - ur_context_handle_t context = nullptr; + ur_context_handle_t property_value = nullptr; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE, urUSMPoolGetInfo(nullptr, UR_USM_POOL_INFO_CONTEXT, - sizeof(ur_context_handle_t), &context, - nullptr)); + sizeof(ur_context_handle_t), + &property_value, nullptr)); } TEST_P(urUSMPoolGetInfoTest, InvalidEnumerationProperty) { - ur_context_handle_t context = nullptr; + ur_context_handle_t property_value = nullptr; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION, urUSMPoolGetInfo(pool, UR_USM_POOL_INFO_FORCE_UINT32, - sizeof(ur_context_handle_t), &context, - nullptr)); + sizeof(ur_context_handle_t), + &property_value, nullptr)); } TEST_P(urUSMPoolGetInfoTest, InvalidSizeZero) { - ur_context_handle_t context = nullptr; - ASSERT_EQ_RESULT( - UR_RESULT_ERROR_INVALID_SIZE, - urUSMPoolGetInfo(pool, UR_USM_POOL_INFO_CONTEXT, 0, &context, nullptr)); + ur_context_handle_t property_value = nullptr; + ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE, + urUSMPoolGetInfo(pool, UR_USM_POOL_INFO_CONTEXT, 0, + &property_value, nullptr)); } TEST_P(urUSMPoolGetInfoTest, InvalidSizeTooSmall) { - ur_context_handle_t context = nullptr; + ur_context_handle_t property_value = nullptr; ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_SIZE, urUSMPoolGetInfo(pool, UR_USM_POOL_INFO_CONTEXT, - sizeof(ur_context_handle_t) - 1, &context, - nullptr)); + sizeof(ur_context_handle_t) - 1, + &property_value, nullptr)); } TEST_P(urUSMPoolGetInfoTest, InvalidNullPointerPropValue) { diff --git a/test/conformance/virtual_memory/urPhysicalMemGetInfo.cpp b/test/conformance/virtual_memory/urPhysicalMemGetInfo.cpp index ce22006c18..e997a9c692 100644 --- a/test/conformance/virtual_memory/urPhysicalMemGetInfo.cpp +++ b/test/conformance/virtual_memory/urPhysicalMemGetInfo.cpp @@ -9,10 +9,16 @@ using urPhysicalMemGetInfoTest = uur::urPhysicalMemTest; UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urPhysicalMemGetInfoTest); +bool operator==(ur_physical_mem_properties_t lhs, + ur_physical_mem_properties_t rhs) { + return lhs.flags == rhs.flags && lhs.pNext == rhs.pNext && + lhs.stype == rhs.stype; +} + TEST_P(urPhysicalMemGetInfoTest, SuccessContext) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); - ur_physical_mem_info_t property_name = UR_PHYSICAL_MEM_INFO_CONTEXT; + const ur_physical_mem_info_t property_name = UR_PHYSICAL_MEM_INFO_CONTEXT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -21,17 +27,17 @@ TEST_P(urPhysicalMemGetInfoTest, SuccessContext) { property_name); ASSERT_NE(property_size, 0); - ur_context_handle_t returned_context = nullptr; - ASSERT_SUCCESS(urPhysicalMemGetInfo( - physical_mem, property_name, property_size, &returned_context, nullptr)); + ur_context_handle_t property_value = nullptr; + ASSERT_SUCCESS(urPhysicalMemGetInfo(physical_mem, property_name, + property_size, &property_value, nullptr)); - ASSERT_EQ(context, returned_context); + ASSERT_EQ(context, property_value); } TEST_P(urPhysicalMemGetInfoTest, SuccessDevice) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); - ur_physical_mem_info_t property_name = UR_PHYSICAL_MEM_INFO_DEVICE; + const ur_physical_mem_info_t property_name = UR_PHYSICAL_MEM_INFO_DEVICE; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -40,17 +46,17 @@ TEST_P(urPhysicalMemGetInfoTest, SuccessDevice) { property_name); ASSERT_NE(property_size, 0); - ur_device_handle_t returned_device = nullptr; - ASSERT_SUCCESS(urPhysicalMemGetInfo( - physical_mem, property_name, property_size, &returned_device, nullptr)); + ur_device_handle_t property_value = nullptr; + ASSERT_SUCCESS(urPhysicalMemGetInfo(physical_mem, property_name, + property_size, &property_value, nullptr)); - ASSERT_EQ(device, returned_device); + ASSERT_EQ(device, property_value); } TEST_P(urPhysicalMemGetInfoTest, SuccessSize) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); - ur_physical_mem_info_t property_name = UR_PHYSICAL_MEM_INFO_SIZE; + const ur_physical_mem_info_t property_name = UR_PHYSICAL_MEM_INFO_SIZE; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -59,17 +65,17 @@ TEST_P(urPhysicalMemGetInfoTest, SuccessSize) { property_name); ASSERT_NE(property_size, 0); - size_t returned_size = 0; + size_t property_value = 0; ASSERT_SUCCESS(urPhysicalMemGetInfo(physical_mem, property_name, - property_size, &returned_size, nullptr)); + property_size, &property_value, nullptr)); - ASSERT_EQ(size, returned_size); + ASSERT_EQ(size, property_value); } TEST_P(urPhysicalMemGetInfoTest, SuccessProperties) { UUR_KNOWN_FAILURE_ON(uur::LevelZero{}); - ur_physical_mem_info_t property_name = UR_PHYSICAL_MEM_INFO_PROPERTIES; + const ur_physical_mem_info_t property_name = UR_PHYSICAL_MEM_INFO_PROPERTIES; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -78,18 +84,16 @@ TEST_P(urPhysicalMemGetInfoTest, SuccessProperties) { property_name); ASSERT_NE(property_size, 0); - ur_physical_mem_properties_t returned_properties = {}; + ur_physical_mem_properties_t property_value = {}; ASSERT_SUCCESS(urPhysicalMemGetInfo(physical_mem, property_name, - property_size, &returned_properties, - nullptr)); + property_size, &property_value, nullptr)); - ASSERT_EQ(properties.stype, returned_properties.stype); - ASSERT_EQ(properties.pNext, returned_properties.pNext); - ASSERT_EQ(properties.flags, returned_properties.flags); + ASSERT_EQ(properties, property_value); } TEST_P(urPhysicalMemGetInfoTest, SuccessReferenceCount) { - ur_physical_mem_info_t property_name = UR_PHYSICAL_MEM_INFO_REFERENCE_COUNT; + const ur_physical_mem_info_t property_name = + UR_PHYSICAL_MEM_INFO_REFERENCE_COUNT; size_t property_size = 0; ASSERT_SUCCESS_OR_OPTIONAL_QUERY( @@ -98,10 +102,9 @@ TEST_P(urPhysicalMemGetInfoTest, SuccessReferenceCount) { property_name); ASSERT_NE(property_size, 0); - uint32_t returned_reference_count = 0; + uint32_t property_value = 0; ASSERT_SUCCESS(urPhysicalMemGetInfo(physical_mem, property_name, - property_size, &returned_reference_count, - nullptr)); + property_size, &property_value, nullptr)); - ASSERT_EQ(returned_reference_count, 1); + ASSERT_EQ(property_value, 1); } diff --git a/test/conformance/virtual_memory/urVirtualMemGetInfo.cpp b/test/conformance/virtual_memory/urVirtualMemGetInfo.cpp index 6f4ad5ad6e..b4d93b8a79 100644 --- a/test/conformance/virtual_memory/urVirtualMemGetInfo.cpp +++ b/test/conformance/virtual_memory/urVirtualMemGetInfo.cpp @@ -10,7 +10,7 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urVirtualMemGetInfoTest); TEST_P(urVirtualMemGetInfoTest, SuccessAccessMode) { size_t property_size = 0; - ur_virtual_mem_info_t property_name = UR_VIRTUAL_MEM_INFO_ACCESS_MODE; + const ur_virtual_mem_info_t property_name = UR_VIRTUAL_MEM_INFO_ACCESS_MODE; ASSERT_SUCCESS_OR_OPTIONAL_QUERY(urVirtualMemGetInfo(context, virtual_ptr, size, property_name, 0, @@ -18,27 +18,28 @@ TEST_P(urVirtualMemGetInfoTest, SuccessAccessMode) { property_name); ASSERT_NE(property_size, 0); - ur_virtual_mem_access_flags_t returned_flags = + ur_virtual_mem_access_flags_t property_value = UR_VIRTUAL_MEM_ACCESS_FLAG_FORCE_UINT32; ASSERT_SUCCESS(urVirtualMemGetInfo(context, virtual_ptr, size, property_name, - property_size, &returned_flags, nullptr)); + property_size, &property_value, nullptr)); - ASSERT_TRUE(returned_flags & UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE); + ASSERT_TRUE(property_value & UR_VIRTUAL_MEM_ACCESS_FLAG_READ_WRITE); } TEST_P(urVirtualMemGetInfoTest, InvalidNullHandleContext) { - ur_virtual_mem_access_flags_t flags = 0; + ur_virtual_mem_access_flags_t property_value = 0; ASSERT_EQ_RESULT(urVirtualMemGetInfo(nullptr, virtual_ptr, size, UR_VIRTUAL_MEM_INFO_ACCESS_MODE, - sizeof(flags), &flags, nullptr), + sizeof(property_value), &property_value, + nullptr), UR_RESULT_ERROR_INVALID_NULL_HANDLE); } TEST_P(urVirtualMemGetInfoTest, InvalidNullPointerStart) { - ur_virtual_mem_access_flags_t flags = 0; - ASSERT_EQ_RESULT(urVirtualMemGetInfo(context, nullptr, size, - UR_VIRTUAL_MEM_INFO_ACCESS_MODE, - sizeof(flags), &flags, nullptr), + ur_virtual_mem_access_flags_t property_value = 0; + ASSERT_EQ_RESULT(urVirtualMemGetInfo( + context, nullptr, size, UR_VIRTUAL_MEM_INFO_ACCESS_MODE, + sizeof(property_value), &property_value, nullptr), UR_RESULT_ERROR_INVALID_NULL_POINTER); }