intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-18 22:08:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

Apply CamelCase for class and struct names

Browse Source 
Signed-off-by: Fabian Zwolinski <fabian.zwolinski@intel.com>
This commit is contained in:
Fabian Zwolinski
2023-04-24 09:39:55 +00:00
committed by Compute-Runtime-Automation
parent 856318ccc2
commit e2e00413a8
85 changed files with 737 additions and 737 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
level_zero/core/source/image/image_format_desc_helper.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -89,25 +89,25 @@ cl_channel_type getClChannelDataType(const ze_image_format_t &imgDescription) {
}
cl_channel_order getClChannelOrder(const ze_image_format_t &imgDescription) {
swizzles imgSwizzles{imgDescription.x, imgDescription.y, imgDescription.z, imgDescription.w};
Swizzles imgSwizzles{imgDescription.x, imgDescription.y, imgDescription.z, imgDescription.w};
if (imgSwizzles == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_1})
if (imgSwizzles == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_1})
return CL_R;
if (imgSwizzles == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_A})
if (imgSwizzles == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_A})
return CL_A;
if (imgSwizzles == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_1})
if (imgSwizzles == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_1})
return CL_RG;
if (imgSwizzles == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_A})
if (imgSwizzles == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_A})
return CL_RA;
if (imgSwizzles == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_1})
if (imgSwizzles == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_1})
return CL_RGB;
if (imgSwizzles == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_A})
if (imgSwizzles == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_A})
return CL_RGBA;
if (imgSwizzles == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_A})
if (imgSwizzles == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_A})
return CL_BGRA;
if (imgSwizzles == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_A, ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_B})
if (imgSwizzles == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_A, ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_B})
return CL_ARGB;
if (imgSwizzles == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_A, ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_R})
if (imgSwizzles == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_A, ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_R})
return CL_ABGR;
return CL_INVALID_VALUE;

6
level_zero/core/source/image/image_format_desc_helper.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -13,13 +13,13 @@
namespace L0 {
struct swizzles {
struct Swizzles {
ze_image_format_swizzle_t x;
ze_image_format_swizzle_t y;
ze_image_format_swizzle_t z;
ze_image_format_swizzle_t w;
bool operator==(const swizzles &rhs) {
bool operator==(const Swizzles &rhs) {
if (x != rhs.x)
return false;
if (y != rhs.y)

6
level_zero/core/test/black_box_tests/zello_copy_tracing.cpp
View File

@@ -280,7 +280,7 @@ uint32_t memAllocSharedCount = 0;
uint32_t memAllocSharedPrologCount = 0;
uint32_t memAllocSharedEpilogCount = 0;
struct tmpMemAllocSharedParams {
struct TmpMemAllocSharedParams {
ze_context_handle_t context;
ze_device_mem_alloc_desc_t *deviceDesc;
ze_host_mem_alloc_desc_t *hostDesc;
@@ -290,7 +290,7 @@ struct tmpMemAllocSharedParams {
void *buffer;
};
tmpMemAllocSharedParams memAllocSharedParams;
TmpMemAllocSharedParams memAllocSharedParams;
void setMemAllocSharedParams(ze_context_handle_t context, ze_device_mem_alloc_desc_t *deviceDesc,
ze_host_mem_alloc_desc_t *hostDesc, size_t allocSize, size_t alignment,
@@ -305,7 +305,7 @@ void setMemAllocSharedParams(ze_context_handle_t context, ze_device_mem_alloc_de
memAllocSharedCount++;
}
void checkMemAllocShared(ze_mem_alloc_shared_params_t *traceParams, tmpMemAllocSharedParams *checkParams) {
void checkMemAllocShared(ze_mem_alloc_shared_params_t *traceParams, TmpMemAllocSharedParams *checkParams) {
SUCCESS_OR_WARNING_BOOL(*(traceParams->phContext) == checkParams->context);
SUCCESS_OR_WARNING_BOOL(*(traceParams->pdevice_desc) == checkParams->deviceDesc);
SUCCESS_OR_WARNING_BOOL(*(traceParams->phost_desc) == checkParams->hostDesc);

12
level_zero/core/test/unit_tests/sources/image/test_image.cpp
View File

@@ -751,12 +751,12 @@ TEST(ImageFormatDescHelperTest, givenSupportedImageFormatLayoutAndTypeThenProper
}
TEST(ImageFormatDescHelperTest, givenSwizzlesThenEqualityIsProperlyDetermined) {
swizzles ref{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_A};
EXPECT_FALSE((ref == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0}));
EXPECT_FALSE((ref == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0}));
EXPECT_FALSE((ref == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0}));
EXPECT_FALSE((ref == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_0}));
EXPECT_TRUE((ref == swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_A}));
Swizzles ref{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_A};
EXPECT_FALSE((ref == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0}));
EXPECT_FALSE((ref == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0}));
EXPECT_FALSE((ref == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_0, ZE_IMAGE_FORMAT_SWIZZLE_0}));
EXPECT_FALSE((ref == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_0}));
EXPECT_TRUE((ref == Swizzles{ZE_IMAGE_FORMAT_SWIZZLE_R, ZE_IMAGE_FORMAT_SWIZZLE_G, ZE_IMAGE_FORMAT_SWIZZLE_B, ZE_IMAGE_FORMAT_SWIZZLE_A}));
}
TEST(ImageFormatDescHelperTest, givenSupportedSwizzlesThenProperClEnumIsReturned) {

2
level_zero/core/test/unit_tests/sources/tracing/test_api_tracing_common.h
View File

@@ -246,7 +246,7 @@ TSizeType generateRandomSize() {
return static_cast<TSizeType>(rand());
}
struct instanceDataStruct {
struct InstanceDataStruct {
void *instanceDataValue;
};

156
level_zero/core/test/unit_tests/sources/tracing/test_event_api_multi_tracing.cpp
View File

@@ -80,7 +80,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventCreateTracingW
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_create_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -91,7 +91,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventCreateTracingW
//
epilogCbs0.Event.pfnCreateCb =
[](ze_event_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_create_args.hEventPool1, *params->phEventPool);
EXPECT_EQ(&event_create_args.desc1, *params->pdesc);
@@ -114,7 +114,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventCreateTracingW
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_create_args.instanceData0);
delete instanceData;
};
@@ -205,7 +205,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventCreateTracingW
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_create_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -216,7 +216,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventCreateTracingW
//
epilogCbs3.Event.pfnCreateCb =
[](ze_event_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_create_args.hEventPool1, *params->phEventPool);
EXPECT_EQ(&event_create_args.desc1, *params->pdesc);
@@ -239,7 +239,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventCreateTracingW
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_create_args.instanceData3);
delete instanceData;
};
@@ -289,7 +289,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventDestroyTracing
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_destroy_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -300,14 +300,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventDestroyTracing
//
epilogCbs0.Event.pfnDestroyCb =
[](ze_event_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_destroy_args.hEvent1, *params->phEvent);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_destroy_args.instanceData0);
delete instanceData;
};
@@ -350,7 +350,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventDestroyTracing
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_destroy_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -361,14 +361,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventDestroyTracing
//
epilogCbs3.Event.pfnDestroyCb =
[](ze_event_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_destroy_args.hEvent1, *params->phEvent);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_destroy_args.instanceData3);
delete instanceData;
};
@@ -418,7 +418,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostSignalTrac
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_host_signal_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -429,14 +429,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostSignalTrac
//
epilogCbs0.Event.pfnHostSignalCb =
[](ze_event_host_signal_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_host_signal_args.hEvent1, *params->phEvent);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_host_signal_args.instanceData0);
delete instanceData;
};
@@ -479,7 +479,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostSignalTrac
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_host_signal_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -490,14 +490,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostSignalTrac
//
epilogCbs3.Event.pfnHostSignalCb =
[](ze_event_host_signal_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_host_signal_args.hEvent1, *params->phEvent);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_host_signal_args.instanceData3);
delete instanceData;
};
@@ -554,7 +554,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostSynchroniz
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_host_synchronize_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -565,7 +565,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostSynchroniz
//
epilogCbs0.Event.pfnHostSynchronizeCb =
[](ze_event_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_host_synchronize_args.hEvent1, *params->phEvent);
EXPECT_EQ(event_host_synchronize_args.timeout1, *params->ptimeout);
@@ -573,7 +573,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostSynchroniz
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_host_synchronize_args.instanceData0);
delete instanceData;
};
@@ -619,7 +619,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostSynchroniz
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_host_synchronize_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -630,7 +630,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostSynchroniz
//
epilogCbs3.Event.pfnHostSynchronizeCb =
[](ze_event_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_host_synchronize_args.hEvent1, *params->phEvent);
EXPECT_EQ(event_host_synchronize_args.timeout1, *params->ptimeout);
@@ -638,7 +638,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostSynchroniz
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_host_synchronize_args.instanceData3);
delete instanceData;
};
@@ -688,7 +688,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventQueryStatusTra
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_query_status_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -699,14 +699,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventQueryStatusTra
//
epilogCbs0.Event.pfnQueryStatusCb =
[](ze_event_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_query_status_args.hEvent1, *params->phEvent);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_query_status_args.instanceData0);
delete instanceData;
};
@@ -749,7 +749,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventQueryStatusTra
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_query_status_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -760,14 +760,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventQueryStatusTra
//
epilogCbs3.Event.pfnQueryStatusCb =
[](ze_event_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_query_status_args.hEvent1, *params->phEvent);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_query_status_args.instanceData3);
delete instanceData;
};
@@ -817,7 +817,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostResetTraci
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_reset_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -828,14 +828,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostResetTraci
//
epilogCbs0.Event.pfnHostResetCb =
[](ze_event_host_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_reset_args.hEvent1, *params->phEvent);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_reset_args.instanceData0);
delete instanceData;
};
@@ -878,7 +878,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostResetTraci
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_reset_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -889,14 +889,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventHostResetTraci
//
epilogCbs3.Event.pfnHostResetCb =
[](ze_event_host_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_reset_args.hEvent1, *params->phEvent);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_reset_args.instanceData3);
delete instanceData;
};
@@ -1004,7 +1004,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolCreateTrac
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_create_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -1015,7 +1015,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolCreateTrac
//
epilogCbs0.EventPool.pfnCreateCb =
[](ze_event_pool_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_create_args.hContext1, *params->phContext);
EXPECT_EQ(&event_pool_create_args.desc1, *params->pdesc);
@@ -1044,7 +1044,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolCreateTrac
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_create_args.instanceData0);
delete instanceData;
};
@@ -1153,7 +1153,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolCreateTrac
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_create_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -1164,7 +1164,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolCreateTrac
//
epilogCbs3.EventPool.pfnCreateCb =
[](ze_event_pool_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_create_args.hContext1, *params->phContext);
EXPECT_EQ(&event_pool_create_args.desc1, *params->pdesc);
@@ -1193,7 +1193,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolCreateTrac
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_create_args.instanceData3);
delete instanceData;
};
@@ -1247,7 +1247,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolDestroyTra
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_pool_destroy_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -1258,14 +1258,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolDestroyTra
//
epilogCbs0.EventPool.pfnDestroyCb =
[](ze_event_pool_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_destroy_args.hEventPool1, *params->phEventPool);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_pool_destroy_args.instanceData0);
delete instanceData;
};
@@ -1308,7 +1308,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolDestroyTra
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_pool_destroy_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -1319,14 +1319,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolDestroyTra
//
epilogCbs3.EventPool.pfnDestroyCb =
[](ze_event_pool_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_destroy_args.hEventPool1, *params->phEventPool);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_pool_destroy_args.instanceData3);
delete instanceData;
};
@@ -1405,7 +1405,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_pool_get_ipc_handle_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -1416,7 +1416,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
//
epilogCbs0.EventPool.pfnGetIpcHandleCb =
[](ze_event_pool_get_ipc_handle_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_get_ipc_handle_args.hEventPool1, *params->phEventPool);
EXPECT_EQ(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc);
@@ -1425,7 +1425,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_pool_get_ipc_handle_args.instanceData0);
delete instanceData;
};
@@ -1474,7 +1474,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_pool_get_ipc_handle_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -1485,7 +1485,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
//
epilogCbs3.EventPool.pfnGetIpcHandleCb =
[](ze_event_pool_get_ipc_handle_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_get_ipc_handle_args.hEventPool1, *params->phEventPool);
EXPECT_EQ(&event_pool_get_ipc_handle_args.hIpc1, *params->pphIpc);
@@ -1494,7 +1494,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolGetIpcHand
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_pool_get_ipc_handle_args.instanceData3);
delete instanceData;
};
@@ -1588,7 +1588,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_pool_open_ipc_handle_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -1599,7 +1599,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
//
epilogCbs0.EventPool.pfnOpenIpcHandleCb =
[](ze_event_pool_open_ipc_handle_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_open_ipc_handle_args.hContext1, *params->phContext);
EXPECT_TRUE(eventPoolOpenIpcHandlesCompare(&event_pool_open_ipc_handle_args.hIpc1, params->phIpc));
@@ -1622,7 +1622,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_pool_open_ipc_handle_args.instanceData0);
delete instanceData;
};
@@ -1713,7 +1713,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_pool_open_ipc_handle_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -1724,7 +1724,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
//
epilogCbs3.EventPool.pfnOpenIpcHandleCb =
[](ze_event_pool_open_ipc_handle_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_open_ipc_handle_args.hContext1, *params->phContext);
EXPECT_TRUE(eventPoolOpenIpcHandlesCompare(&event_pool_open_ipc_handle_args.hIpc1, params->phIpc));
@@ -1747,7 +1747,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolOpenIpcHan
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_pool_open_ipc_handle_args.instanceData3);
delete instanceData;
};
@@ -1799,7 +1799,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolCloseIpcHa
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_pool_close_ipc_handle_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -1810,14 +1810,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolCloseIpcHa
//
epilogCbs0.EventPool.pfnCloseIpcHandleCb =
[](ze_event_pool_close_ipc_handle_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_close_ipc_handle_args.hEventPool1, *params->phEventPool);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_pool_close_ipc_handle_args.instanceData0);
delete instanceData;
};
@@ -1860,7 +1860,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolCloseIpcHa
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = event_pool_close_ipc_handle_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -1871,14 +1871,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingEventPoolCloseIpcHa
//
epilogCbs3.EventPool.pfnCloseIpcHandleCb =
[](ze_event_pool_close_ipc_handle_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(event_pool_close_ipc_handle_args.hEventPool1, *params->phEventPool);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, event_pool_close_ipc_handle_args.instanceData3);
delete instanceData;
};
@@ -1937,7 +1937,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingCommandListAppendSi
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = command_list_append_signal_event_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -1948,14 +1948,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingCommandListAppendSi
//
epilogCbs0.CommandList.pfnAppendSignalEventCb =
[](ze_command_list_append_signal_event_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(command_list_append_signal_event_args.hCommandList1, *params->phCommandList);
EXPECT_EQ(command_list_append_signal_event_args.hEvent1, *params->phEvent);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, command_list_append_signal_event_args.instanceData0);
delete instanceData;
};
@@ -2001,21 +2001,21 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingCommandListAppendSi
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = command_list_append_signal_event_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
epilogCbs3.CommandList.pfnAppendSignalEventCb =
[](ze_command_list_append_signal_event_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(command_list_append_signal_event_args.hCommandList1, *params->phCommandList);
EXPECT_EQ(command_list_append_signal_event_args.hEvent1, *params->phEvent);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, command_list_append_signal_event_args.instanceData0);
delete instanceData;
};
@@ -2089,7 +2089,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingCommandListAppendWa
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = command_list_append_wait_on_events_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -2100,7 +2100,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingCommandListAppendWa
//
epilogCbs0.CommandList.pfnAppendWaitOnEventsCb =
[](ze_command_list_append_wait_on_events_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(command_list_append_wait_on_events_args.hCommandList1, *params->phCommandList);
EXPECT_EQ((uint32_t)NUM_COMMAND_LIST_APPEND_WAIT_ON_EVENTS_1, *params->pnumEvents);
@@ -2111,7 +2111,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingCommandListAppendWa
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, command_list_append_wait_on_events_args.instanceData0);
delete instanceData;
};
@@ -2166,14 +2166,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingCommandListAppendWa
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = command_list_append_wait_on_events_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
epilogCbs3.CommandList.pfnAppendWaitOnEventsCb =
[](ze_command_list_append_wait_on_events_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(command_list_append_wait_on_events_args.hCommandList1, *params->phCommandList);
EXPECT_EQ((uint32_t)NUM_COMMAND_LIST_APPEND_WAIT_ON_EVENTS_1, *params->pnumEvents);
@@ -2184,7 +2184,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingCommandListAppendWa
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, command_list_append_wait_on_events_args.instanceData0);
delete instanceData;
};

62
level_zero/core/test/unit_tests/sources/tracing/test_fence_api_tracing.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -152,7 +152,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_create_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -163,7 +163,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
//
epilogCbs0.Fence.pfnCreateCb =
[](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_create_args.hCommandQueue1, *params->phCommandQueue);
EXPECT_EQ(&fence_create_args.desc1, *params->pdesc);
@@ -186,7 +186,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_create_args.instanceData0);
delete instanceData;
};
@@ -277,7 +277,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_create_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -288,7 +288,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
//
epilogCbs3.Fence.pfnCreateCb =
[](ze_fence_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_create_args.hCommandQueue1, *params->phCommandQueue);
EXPECT_EQ(&fence_create_args.desc1, *params->pdesc);
@@ -312,7 +312,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceCreateTracingW
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_create_args.instanceData3);
delete instanceData;
};
@@ -363,7 +363,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceDestroyTracing
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_destroy_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -374,14 +374,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceDestroyTracing
//
epilogCbs0.Fence.pfnDestroyCb =
[](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_destroy_args.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_destroy_args.instanceData0);
delete instanceData;
};
@@ -424,7 +424,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceDestroyTracing
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_destroy_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -435,14 +435,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceDestroyTracing
//
epilogCbs3.Fence.pfnDestroyCb =
[](ze_fence_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_destroy_args.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_destroy_args.instanceData3);
delete instanceData;
};
@@ -499,7 +499,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchroniz
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_host_synchronize_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -510,7 +510,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchroniz
//
epilogCbs0.Fence.pfnHostSynchronizeCb =
[](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_host_synchronize_args.hFence1, *params->phFence);
EXPECT_EQ(fence_host_synchronize_args.timeout1, *params->ptimeout);
@@ -518,7 +518,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchroniz
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_host_synchronize_args.instanceData0);
delete instanceData;
};
@@ -564,7 +564,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchroniz
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_host_synchronize_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -575,7 +575,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchroniz
//
epilogCbs3.Fence.pfnHostSynchronizeCb =
[](ze_fence_host_synchronize_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_host_synchronize_args.hFence1, *params->phFence);
EXPECT_EQ(fence_host_synchronize_args.timeout1, *params->ptimeout);
@@ -583,7 +583,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceHostSynchroniz
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_host_synchronize_args.instanceData3);
delete instanceData;
};
@@ -633,7 +633,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceQueryStatusTra
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_query_status_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -644,14 +644,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceQueryStatusTra
//
epilogCbs0.Fence.pfnQueryStatusCb =
[](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_query_status_args.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_query_status_args.instanceData0);
delete instanceData;
};
@@ -694,7 +694,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceQueryStatusTra
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_query_status_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -705,14 +705,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceQueryStatusTra
//
epilogCbs3.Fence.pfnQueryStatusCb =
[](ze_fence_query_status_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_query_status_args.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_query_status_args.instanceData3);
delete instanceData;
};
@@ -762,7 +762,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceResetTracingWr
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_reset_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -773,14 +773,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceResetTracingWr
//
epilogCbs0.Fence.pfnResetCb =
[](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_reset_args.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_reset_args.instanceData0);
delete instanceData;
};
@@ -823,7 +823,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceResetTracingWr
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = fence_reset_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -834,14 +834,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingFenceResetTracingWr
//
epilogCbs3.Fence.pfnResetCb =
[](ze_fence_reset_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(fence_reset_args.hFence1, *params->phFence);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, fence_reset_args.instanceData3);
delete instanceData;
};

38
level_zero/core/test/unit_tests/sources/tracing/test_image_api_tracing.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -108,7 +108,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageGetProperties_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -119,7 +119,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
//
epilogCbs0.Image.pfnGetPropertiesCb =
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
@@ -128,7 +128,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageGetProperties_args.instanceData0);
delete instanceData;
};
@@ -177,7 +177,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageGetProperties_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -188,7 +188,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
//
epilogCbs3.Image.pfnGetPropertiesCb =
[](ze_image_get_properties_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageGetProperties_args.hDevice1, *params->phDevice);
EXPECT_EQ(&ImageGetProperties_args.desc1, *params->pdesc);
@@ -197,7 +197,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageGetPropertiesT
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageGetProperties_args.instanceData3);
delete instanceData;
};
@@ -289,7 +289,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageCreate_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -300,7 +300,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
//
epilogCbs0.Image.pfnCreateCb =
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
ASSERT_NE(nullptr, params);
ASSERT_NE(nullptr, params->phContext);
@@ -329,7 +329,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageCreate_args.instanceData0);
delete instanceData;
};
@@ -423,7 +423,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageCreate_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -434,7 +434,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
//
epilogCbs3.Image.pfnCreateCb =
[](ze_image_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageCreate_args.hContext1, *params->phContext);
EXPECT_EQ(ImageCreate_args.hDevice1, *params->phDevice);
@@ -458,7 +458,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageCreateTracingW
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageCreate_args.instanceData3);
delete instanceData;
};
@@ -508,7 +508,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracing
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageDestroy_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -519,14 +519,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracing
//
epilogCbs0.Image.pfnDestroyCb =
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageDestroy_args.instanceData0);
delete instanceData;
};
@@ -569,7 +569,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracing
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = ImageDestroy_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -580,14 +580,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingImageDestroyTracing
//
epilogCbs3.Image.pfnDestroyCb =
[](ze_image_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(ImageDestroy_args.hImage1, *params->phImage);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, ImageDestroy_args.instanceData3);
delete instanceData;
};

38
level_zero/core/test/unit_tests/sources/tracing/test_module_api_multi_tracing.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -132,7 +132,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = module_create_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -143,7 +143,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
//
epilogCbs0.Module.pfnCreateCb =
[](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_create_args.hContext1, *params->phContext);
EXPECT_EQ(module_create_args.hDevice1, *params->phDevice);
@@ -181,7 +181,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, module_create_args.instanceData0);
delete instanceData;
};
@@ -317,7 +317,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = module_create_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -328,7 +328,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
//
epilogCbs3.Module.pfnCreateCb =
[](ze_module_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_create_args.hContext1, *params->phContext);
EXPECT_EQ(module_create_args.hDevice1, *params->phDevice);
@@ -366,7 +366,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleCreateTracing
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, module_create_args.instanceData3);
delete instanceData;
};
@@ -416,7 +416,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleDestroyTracin
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = module_destroy_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -427,14 +427,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleDestroyTracin
//
epilogCbs0.Module.pfnDestroyCb =
[](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_destroy_args.hModule1, *params->phModule);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, module_destroy_args.instanceData0);
delete instanceData;
};
@@ -477,7 +477,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleDestroyTracin
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = module_destroy_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -488,14 +488,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleDestroyTracin
//
epilogCbs3.Module.pfnDestroyCb =
[](ze_module_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_destroy_args.hModule1, *params->phModule);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, module_destroy_args.instanceData3);
delete instanceData;
};
@@ -597,7 +597,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = module_get_native_binary_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -608,7 +608,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
//
epilogCbs0.Module.pfnGetNativeBinaryCb =
[](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_get_native_binary_args.hModule1, *params->phModule);
@@ -633,7 +633,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, module_get_native_binary_args.instanceData0);
delete instanceData;
};
@@ -731,7 +731,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = module_get_native_binary_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -742,7 +742,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
//
epilogCbs3.Module.pfnGetNativeBinaryCb =
[](ze_module_get_native_binary_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(module_get_native_binary_args.hModule1, *params->phModule);
@@ -767,7 +767,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingModuleGetNativeBina
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, module_get_native_binary_args.instanceData3);
delete instanceData;
};

50
level_zero/core/test/unit_tests/sources/tracing/test_residency_api_tracing.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -183,7 +183,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = MakeMemoryResident_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -194,7 +194,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
epilogCbs0.Context.pfnMakeMemoryResidentCb =
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
@@ -204,7 +204,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, MakeMemoryResident_args.instanceData0);
delete instanceData;
};
@@ -256,7 +256,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = MakeMemoryResident_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -267,7 +267,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
epilogCbs3.Context.pfnMakeMemoryResidentCb =
[](ze_context_make_memory_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, MakeMemoryResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeMemoryResident_args.hDevice1);
@@ -277,7 +277,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, MakeMemoryResident_args.instanceData3);
delete instanceData;
};
@@ -350,7 +350,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryT
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = EvictMemory_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -361,7 +361,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryT
//
epilogCbs0.Context.pfnEvictMemoryCb =
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
@@ -371,7 +371,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryT
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, EvictMemory_args.instanceData0);
delete instanceData;
};
@@ -423,14 +423,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryT
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = EvictMemory_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
epilogCbs3.Context.pfnEvictMemoryCb =
[](ze_context_evict_memory_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictMemory_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictMemory_args.hDevice1);
@@ -440,7 +440,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests, WhenCallingContextEvictMemoryT
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, EvictMemory_args.instanceData3);
delete instanceData;
};
@@ -506,7 +506,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = MakeImageResident_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -517,7 +517,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
epilogCbs0.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
@@ -526,7 +526,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, MakeImageResident_args.instanceData0);
delete instanceData;
};
@@ -575,7 +575,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = MakeImageResident_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -586,7 +586,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
epilogCbs3.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phDevice, MakeImageResident_args.hDevice1);
EXPECT_EQ(*params->phContext, MakeImageResident_args.hContext1);
@@ -595,7 +595,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, MakeImageResident_args.instanceData3);
delete instanceData;
};
@@ -661,7 +661,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = EvictImage_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -672,7 +672,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
epilogCbs0.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
@@ -681,7 +681,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, EvictImage_args.instanceData0);
delete instanceData;
};
@@ -730,7 +730,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = EvictImage_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -741,7 +741,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
epilogCbs3.Context.pfnMakeImageResidentCb =
[](ze_context_make_image_resident_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(*params->phContext, EvictImage_args.hContext1);
EXPECT_EQ(*params->phDevice, EvictImage_args.hDevice1);
@@ -750,7 +750,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, EvictImage_args.instanceData3);
delete instanceData;
};

26
level_zero/core/test/unit_tests/sources/tracing/test_sampler_api_tracing.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -115,7 +115,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_create_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -126,7 +126,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
epilogCbs0.Sampler.pfnCreateCb =
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
@@ -150,7 +150,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_create_args.instanceData0);
delete instanceData;
};
@@ -244,7 +244,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_create_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -255,7 +255,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
epilogCbs3.Sampler.pfnCreateCb =
[](ze_sampler_create_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_create_args.hContext1, *params->phContext);
EXPECT_EQ(sampler_create_args.hDevice1, *params->phDevice);
@@ -279,7 +279,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_create_args.instanceData3);
delete instanceData;
};
@@ -332,7 +332,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 1);
*val += 1;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_destroy_args.instanceData0;
*ppTracerInstanceUserData = instanceData;
};
@@ -343,14 +343,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
epilogCbs0.Sampler.pfnDestroyCb =
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 2);
*val += 1;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_destroy_args.instanceData0);
delete instanceData;
};
@@ -393,7 +393,7 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 31);
*val += 31;
struct instanceDataStruct *instanceData = new struct instanceDataStruct;
struct InstanceDataStruct *instanceData = new struct InstanceDataStruct;
instanceData->instanceDataValue = sampler_destroy_args.instanceData3;
*ppTracerInstanceUserData = instanceData;
};
@@ -404,14 +404,14 @@ TEST_F(ZeApiTracingRuntimeMultipleArgumentsTests,
//
epilogCbs3.Sampler.pfnDestroyCb =
[](ze_sampler_destroy_params_t *params, ze_result_t result, void *pTracerUserData, void **ppTracerInstanceUserData) {
struct instanceDataStruct *instanceData;
struct InstanceDataStruct *instanceData;
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_EQ(sampler_destroy_args.hSampler1, *params->phSampler);
ASSERT_NE(nullptr, pTracerUserData);
int *val = static_cast<int *>(pTracerUserData);
EXPECT_EQ(*val, 62);
*val += 31;
instanceData = (struct instanceDataStruct *)*ppTracerInstanceUserData;
instanceData = (struct InstanceDataStruct *)*ppTracerInstanceUserData;
EXPECT_EQ(instanceData->instanceDataValue, sampler_destroy_args.instanceData3);
delete instanceData;
};

2
level_zero/experimental/source/tracing/tracing_imp.h
View File

@@ -46,7 +46,7 @@ typedef struct tracer_array_entry {
void *pUserData;
} tracer_array_entry_t;
typedef struct tracerArray {
typedef struct TracerArray {
size_t tracerArrayCount;
tracer_array_entry_t *tracerArrayEntries;
} tracer_array_t;

16
level_zero/sysman/source/global_operations/linux/os_global_operations_imp.cpp
View File

@@ -313,13 +313,13 @@ ze_result_t LinuxGlobalOperationsImp::reset(ze_bool_t force) {
// this engine 0 is used by process.
ze_result_t LinuxGlobalOperationsImp::scanProcessesState(std::vector<zes_process_state_t> &pProcessList) {
std::vector<std::string> clientIds;
struct deviceMemStruct {
struct DeviceMemStruct {
uint64_t deviceMemorySize;
uint64_t deviceSharedMemorySize;
};
struct engineMemoryPairType {
struct EngineMemoryPairType {
int64_t engineTypeField;
deviceMemStruct deviceMemStructField;
DeviceMemStruct deviceMemStructField;
};
ze_result_t result = pSysfsAccess->scanDirEntries(clientsDir, clientIds);
@@ -328,7 +328,7 @@ ze_result_t LinuxGlobalOperationsImp::scanProcessesState(std::vector<zes_process
}
// Create a map with unique pid as key and engineType as value
std::map<uint64_t, engineMemoryPairType> pidClientMap;
std::map<uint64_t, EngineMemoryPairType> pidClientMap;
for (const auto &clientId : clientIds) {
// realClientPidPath will be something like: clients/<clientId>/pid
std::string realClientPidPath = clientsDir + "/" + clientId + "/" + "pid";
@@ -416,13 +416,13 @@ ze_result_t LinuxGlobalOperationsImp::scanProcessesState(std::vector<zes_process
return result;
}
}
deviceMemStruct totalDeviceMem = {memSize, sharedMemSize};
engineMemoryPairType engineMemoryPair = {engineType, totalDeviceMem};
DeviceMemStruct totalDeviceMem = {memSize, sharedMemSize};
EngineMemoryPairType engineMemoryPair = {engineType, totalDeviceMem};
auto ret = pidClientMap.insert(std::make_pair(pid, engineMemoryPair));
if (ret.second == false) {
// insertion failed as entry with same pid already exists in map
// Now update the engineMemoryPairType field for the existing pid entry
engineMemoryPairType updateEngineMemoryPair;
// Now update the EngineMemoryPairType field for the existing pid entry
EngineMemoryPairType updateEngineMemoryPair;
auto pidEntryFromMap = pidClientMap.find(pid);
auto existingEngineType = pidEntryFromMap->second.engineTypeField;
auto existingdeviceMemorySize = pidEntryFromMap->second.deviceMemStructField.deviceMemorySize;

4
level_zero/sysman/source/sysman_const.h
View File

@@ -16,11 +16,11 @@ constexpr double milliVoltsFactor = 1000.0;
namespace L0 {
namespace Sysman {
struct steadyClock {
struct SteadyClock {
typedef std::chrono::duration<uint64_t, std::milli> duration;
typedef duration::rep rep;
typedef duration::period period;
typedef std::chrono::time_point<steadyClock> time_point;
typedef std::chrono::time_point<SteadyClock> time_point;
static time_point now() noexcept {
static auto epoch = std::chrono::steady_clock::now();
return time_point(std::chrono::duration_cast<duration>(std::chrono::steady_clock::now() - epoch));

2
level_zero/tools/source/metrics/metric_ip_sampling_source.cpp
View File

@@ -401,7 +401,7 @@ bool IpSamplingMetricGroupImp::stallIpDataMapUpdate(StallSumIpDataMap_t &stallSu
stallSumData.syncCount += getCount();
stallSumData.instFetchCount += getCount();
struct stallCntrInfo {
struct StallCntrInfo {
uint16_t subslice;
uint16_t flags;
} stallCntrInfo = {};

8
level_zero/tools/source/sysman/events/linux/os_events_imp.cpp
View File

@@ -348,7 +348,7 @@ bool LinuxEventsUtil::listenSystemEvents(zes_event_type_flags_t *pEvents, uint32
pfd[1].events = POLLIN;
pfd[1].revents = 0;
auto start = L0::steadyClock::now();
auto start = L0::SteadyClock::now();
std::chrono::duration<double, std::milli> timeElapsed;
getDevIndexToDevPathMap(registeredEvents, count, phDevices, mapOfDevIndexToDevPath);
eventsMutex.unlock();
@@ -374,7 +374,7 @@ bool LinuxEventsUtil::listenSystemEvents(zes_event_type_flags_t *pEvents, uint32
}
if (!eventReceived) {
timeElapsed = L0::steadyClock::now() - start;
timeElapsed = L0::SteadyClock::now() - start;
if (timeout > timeElapsed.count()) {
timeout = timeout - timeElapsed.count();
continue;
@@ -386,7 +386,7 @@ bool LinuxEventsUtil::listenSystemEvents(zes_event_type_flags_t *pEvents, uint32
void *dev = nullptr;
dev = pUdevLib->allocateDeviceToReceiveData();
if (dev == nullptr) {
timeElapsed = L0::steadyClock::now() - start;
timeElapsed = L0::SteadyClock::now() - start;
if (timeout > timeElapsed.count()) {
timeout = timeout - timeElapsed.count();
continue;
@@ -407,7 +407,7 @@ bool LinuxEventsUtil::listenSystemEvents(zes_event_type_flags_t *pEvents, uint32
if (retval) {
break;
}
timeElapsed = L0::steadyClock::now() - start;
timeElapsed = L0::SteadyClock::now() - start;
if (timeout > timeElapsed.count()) {
timeout = timeout - timeElapsed.count();
continue;

16
level_zero/tools/source/sysman/global_operations/linux/os_global_operations_imp.cpp
View File

@@ -334,13 +334,13 @@ ze_result_t LinuxGlobalOperationsImp::reset(ze_bool_t force) {
// this engine 0 is used by process.
ze_result_t LinuxGlobalOperationsImp::scanProcessesState(std::vector<zes_process_state_t> &pProcessList) {
std::vector<std::string> clientIds;
struct deviceMemStruct {
struct DeviceMemStruct {
uint64_t deviceMemorySize;
uint64_t deviceSharedMemorySize;
};
struct engineMemoryPairType {
struct EngineMemoryPairType {
int64_t engineTypeField;
deviceMemStruct deviceMemStructField;
DeviceMemStruct deviceMemStructField;
};
ze_result_t result = pSysfsAccess->scanDirEntries(clientsDir, clientIds);
@@ -350,7 +350,7 @@ ze_result_t LinuxGlobalOperationsImp::scanProcessesState(std::vector<zes_process
}
// Create a map with unique pid as key and engineType as value
std::map<uint64_t, engineMemoryPairType> pidClientMap;
std::map<uint64_t, EngineMemoryPairType> pidClientMap;
for (const auto &clientId : clientIds) {
// realClientPidPath will be something like: clients/<clientId>/pid
std::string realClientPidPath = clientsDir + "/" + clientId + "/" + "pid";
@@ -440,13 +440,13 @@ ze_result_t LinuxGlobalOperationsImp::scanProcessesState(std::vector<zes_process
return result;
}
}
deviceMemStruct totalDeviceMem = {memSize, sharedMemSize};
engineMemoryPairType engineMemoryPair = {engineType, totalDeviceMem};
DeviceMemStruct totalDeviceMem = {memSize, sharedMemSize};
EngineMemoryPairType engineMemoryPair = {engineType, totalDeviceMem};
auto ret = pidClientMap.insert(std::make_pair(pid, engineMemoryPair));
if (ret.second == false) {
// insertion failed as entry with same pid already exists in map
// Now update the engineMemoryPairType field for the existing pid entry
engineMemoryPairType updateEngineMemoryPair;
// Now update the EngineMemoryPairType field for the existing pid entry
EngineMemoryPairType updateEngineMemoryPair;
auto pidEntryFromMap = pidClientMap.find(pid);
auto existingEngineType = pidEntryFromMap->second.engineTypeField;
auto existingdeviceMemorySize = pidEntryFromMap->second.deviceMemStructField.deviceMemorySize;

4
level_zero/tools/source/sysman/sysman_const.h
View File

@@ -15,11 +15,11 @@ constexpr uint32_t MbpsToBytesPerSecond = 125000;
constexpr double milliVoltsFactor = 1000.0;
namespace L0 {
struct steadyClock {
struct SteadyClock {
typedef std::chrono::duration<uint64_t, std::milli> duration;
typedef duration::rep rep;
typedef duration::period period;
typedef std::chrono::time_point<steadyClock> time_point;
typedef std::chrono::time_point<SteadyClock> time_point;
static time_point now() noexcept {
static auto epoch = std::chrono::steady_clock::now();
return time_point(std::chrono::duration_cast<duration>(std::chrono::steady_clock::now() - epoch));

4
level_zero/tools/source/sysman/windows/os_sysman_driver_imp.cpp
View File

@@ -18,7 +18,7 @@ namespace L0 {
ze_result_t WddmSysmanDriverImp::eventsListen(uint64_t timeout, uint32_t count, zes_device_handle_t *phDevices, uint32_t *pNumDeviceEvents, zes_event_type_flags_t *pEvents) {
bool gotSysmanEvent = false;
memset(pEvents, 0, count * sizeof(zes_event_type_flags_t));
auto timeToExitLoop = L0::steadyClock::now() + std::chrono::duration<uint64_t, std::milli>(timeout);
auto timeToExitLoop = L0::SteadyClock::now() + std::chrono::duration<uint64_t, std::milli>(timeout);
do {
for (uint32_t devIndex = 0; devIndex < count; devIndex++) {
gotSysmanEvent = L0::SysmanDevice::fromHandle(phDevices[devIndex])->deviceEventListen(pEvents[devIndex], timeout);
@@ -31,7 +31,7 @@ ze_result_t WddmSysmanDriverImp::eventsListen(uint64_t timeout, uint32_t count,
break;
}
NEO::sleep(std::chrono::milliseconds(10)); // Sleep for 10 milliseconds before next check of events
} while ((L0::steadyClock::now() <= timeToExitLoop));
} while ((L0::SteadyClock::now() <= timeToExitLoop));
return ZE_RESULT_SUCCESS;
}

14
opencl/test/unit_test/api/cl_add_comment_to_aub_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
* Copyright (C) 2019-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -19,7 +19,7 @@ using namespace NEO;
namespace ULT {
struct clAddCommentToAubTest : api_tests {
struct ClAddCommentToAubTest : api_tests {
void SetUp() override {
api_tests::SetUp();
pDevice = pContext->getDevice(0);
@@ -31,29 +31,29 @@ struct clAddCommentToAubTest : api_tests {
ClDevice *pDevice = nullptr;
};
TEST_F(clAddCommentToAubTest, givenProperCommentNullptrAubCenterWhenAddCommentToAubThenSuccessIsReturned) {
TEST_F(ClAddCommentToAubTest, givenProperCommentNullptrAubCenterWhenAddCommentToAubThenSuccessIsReturned) {
auto retVal = clAddCommentINTEL(pDevice, "comment");
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clAddCommentToAubTest, givenInvalidDeviceWhenAddCommentToAubThenErrorIsReturned) {
TEST_F(ClAddCommentToAubTest, givenInvalidDeviceWhenAddCommentToAubThenErrorIsReturned) {
auto retVal = clAddCommentINTEL(nullptr, "comment");
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
}
TEST_F(clAddCommentToAubTest, givenNullptrCommentWhenAddCommentToAubThenErrorIsReturned) {
TEST_F(ClAddCommentToAubTest, givenNullptrCommentWhenAddCommentToAubThenErrorIsReturned) {
auto retVal = clAddCommentINTEL(pDevice, nullptr);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clAddCommentToAubTest, givenAubCenterAndProperCommentButNullptrAubManagerWhenAddCommentToAubThenErrorIsReturned) {
TEST_F(ClAddCommentToAubTest, givenAubCenterAndProperCommentButNullptrAubManagerWhenAddCommentToAubThenErrorIsReturned) {
pDevice->getExecutionEnvironment()->rootDeviceEnvironments[testedRootDeviceIndex]->aubCenter.reset(new MockAubCenter());
auto retVal = clAddCommentINTEL(pDevice, "comment");
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clAddCommentToAubTest, givenProperCommentAubCenterAndAubManagerWhenAddCommentToAubThenSuccessIsReturned) {
TEST_F(ClAddCommentToAubTest, givenProperCommentAubCenterAndAubManagerWhenAddCommentToAubThenSuccessIsReturned) {
struct AubManagerCommentMock : public MockAubManager {
using MockAubManager::MockAubManager;
void addComment(const char *message) override {

22
opencl/test/unit_test/api/cl_build_program_tests.inl
View File

@@ -20,7 +20,7 @@
using namespace NEO;
struct clBuildProgramTests : public api_tests {
struct ClBuildProgramTests : public api_tests {
void SetUp() override {
DebugManager.flags.FailBuildProgramWithStatefulAccess.set(0);
api_tests::setUp();
@@ -34,7 +34,7 @@ struct clBuildProgramTests : public api_tests {
namespace ULT {
TEST_F(clBuildProgramTests, GivenSourceAsInputWhenCreatingProgramWithSourceThenProgramBuildSucceeds) {
TEST_F(ClBuildProgramTests, GivenSourceAsInputWhenCreatingProgramWithSourceThenProgramBuildSucceeds) {
cl_program pProgram = nullptr;
std::unique_ptr<char[]> pSource = nullptr;
size_t sourceSize = 0;
@@ -85,7 +85,7 @@ TEST_F(clBuildProgramTests, GivenSourceAsInputWhenCreatingProgramWithSourceThenP
EXPECT_EQ(nullptr, pProgram);
}
TEST_F(clBuildProgramTests, GivenBinaryAsInputWhenCreatingProgramWithSourceThenProgramBuildSucceeds) {
TEST_F(ClBuildProgramTests, GivenBinaryAsInputWhenCreatingProgramWithSourceThenProgramBuildSucceeds) {
cl_program pProgram = nullptr;
cl_int binaryStatus = CL_SUCCESS;
@@ -125,7 +125,7 @@ TEST_F(clBuildProgramTests, GivenBinaryAsInputWhenCreatingProgramWithSourceThenP
EXPECT_EQ(CL_SUCCESS, retVal);
}
HWTEST2_F(clBuildProgramTests, GivenFailBuildProgramAndBinaryAsInputWhenCreatingProgramWithSourceThenProgramBuildFails, IsAtLeastXeHpcCore) {
HWTEST2_F(ClBuildProgramTests, GivenFailBuildProgramAndBinaryAsInputWhenCreatingProgramWithSourceThenProgramBuildFails, IsAtLeastXeHpcCore) {
DebugManager.flags.FailBuildProgramWithStatefulAccess.set(1);
@@ -168,7 +168,7 @@ HWTEST2_F(clBuildProgramTests, GivenFailBuildProgramAndBinaryAsInputWhenCreating
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clBuildProgramTests, GivenBinaryAsInputWhenCreatingProgramWithBinaryForMultipleDevicesThenProgramBuildSucceeds) {
TEST_F(ClBuildProgramTests, GivenBinaryAsInputWhenCreatingProgramWithBinaryForMultipleDevicesThenProgramBuildSucceeds) {
MockUnrestrictiveContextMultiGPU context;
cl_program pProgram = nullptr;
cl_int binaryStatus = CL_SUCCESS;
@@ -214,7 +214,7 @@ TEST_F(clBuildProgramTests, GivenBinaryAsInputWhenCreatingProgramWithBinaryForMu
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clBuildProgramTests, GivenProgramCreatedFromBinaryWhenBuildProgramWithOptionsIsCalledThenStoredOptionsAreUsed) {
TEST_F(ClBuildProgramTests, GivenProgramCreatedFromBinaryWhenBuildProgramWithOptionsIsCalledThenStoredOptionsAreUsed) {
cl_program pProgram = nullptr;
cl_int binaryStatus = CL_SUCCESS;
@@ -263,7 +263,7 @@ TEST_F(clBuildProgramTests, GivenProgramCreatedFromBinaryWhenBuildProgramWithOpt
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clBuildProgramTests, GivenSpirAsInputWhenCreatingProgramFromBinaryThenProgramBuildSucceeds) {
TEST_F(ClBuildProgramTests, GivenSpirAsInputWhenCreatingProgramFromBinaryThenProgramBuildSucceeds) {
cl_program pProgram = nullptr;
cl_int binaryStatus = CL_SUCCESS;
unsigned char llvm[16] = "BC\xc0\xde_unique";
@@ -307,7 +307,7 @@ TEST_F(clBuildProgramTests, GivenSpirAsInputWhenCreatingProgramFromBinaryThenPro
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clBuildProgramTests, GivenNullAsInputWhenCreatingProgramThenInvalidProgramErrorIsReturned) {
TEST_F(ClBuildProgramTests, GivenNullAsInputWhenCreatingProgramThenInvalidProgramErrorIsReturned) {
retVal = clBuildProgram(
nullptr,
1,
@@ -318,7 +318,7 @@ TEST_F(clBuildProgramTests, GivenNullAsInputWhenCreatingProgramThenInvalidProgra
EXPECT_EQ(CL_INVALID_PROGRAM, retVal);
}
TEST_F(clBuildProgramTests, GivenInvalidCallbackInputWhenBuildProgramThenInvalidValueErrorIsReturned) {
TEST_F(ClBuildProgramTests, GivenInvalidCallbackInputWhenBuildProgramThenInvalidValueErrorIsReturned) {
cl_program pProgram = nullptr;
cl_int binaryStatus = CL_SUCCESS;
size_t binarySize = 0;
@@ -358,7 +358,7 @@ TEST_F(clBuildProgramTests, GivenInvalidCallbackInputWhenBuildProgramThenInvalid
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clBuildProgramTests, GivenValidCallbackInputWhenBuildProgramThenCallbackIsInvoked) {
TEST_F(ClBuildProgramTests, GivenValidCallbackInputWhenBuildProgramThenCallbackIsInvoked) {
cl_program pProgram = nullptr;
cl_int binaryStatus = CL_SUCCESS;
@@ -401,7 +401,7 @@ TEST_F(clBuildProgramTests, GivenValidCallbackInputWhenBuildProgramThenCallbackI
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clBuildProgramTests, givenProgramWhenBuildingForInvalidDevicesInputThenInvalidDeviceErrorIsReturned) {
TEST_F(ClBuildProgramTests, givenProgramWhenBuildingForInvalidDevicesInputThenInvalidDeviceErrorIsReturned) {
cl_program pProgram = nullptr;
size_t sourceSize = 0;
std::string testFile;

48
opencl/test/unit_test/api/cl_create_buffer_tests.cpp
View File

@@ -16,9 +16,9 @@
using namespace NEO;
typedef api_tests clCreateBufferTests;
typedef api_tests ClCreateBufferTests;
namespace ClCreateBufferTests {
namespace ULT {
class ClCreateBufferTemplateTests : public ApiFixture<>,
public testing::TestWithParam<uint64_t> {
@@ -31,11 +31,11 @@ class ClCreateBufferTemplateTests : public ApiFixture<>,
}
};
struct clCreateBufferValidFlagsTests : public ClCreateBufferTemplateTests {
struct ClCreateBufferValidFlagsTests : public ClCreateBufferTemplateTests {
cl_uchar pHostPtr[64];
};
TEST_P(clCreateBufferValidFlagsTests, GivenValidFlagsWhenCreatingBufferThenBufferIsCreated) {
TEST_P(ClCreateBufferValidFlagsTests, GivenValidFlagsWhenCreatingBufferThenBufferIsCreated) {
cl_mem_flags flags = GetParam() | CL_MEM_USE_HOST_PTR;
auto buffer = clCreateBuffer(pContext, flags, 64, pHostPtr, &retVal);
@@ -66,7 +66,7 @@ static cl_mem_flags validFlags[] = {
INSTANTIATE_TEST_CASE_P(
CreateBufferCheckFlags,
clCreateBufferValidFlagsTests,
ClCreateBufferValidFlagsTests,
testing::ValuesIn(validFlags));
using clCreateBufferInvalidFlagsTests = ClCreateBufferTemplateTests;
@@ -156,7 +156,7 @@ TEST_F(clCreateBufferInvalidProperties, GivenInvalidPropertyKeyWhenCreatingBuffe
EXPECT_EQ(CL_INVALID_PROPERTY, retVal);
};
TEST_F(clCreateBufferTests, GivenValidParametersWhenCreatingBufferThenSuccessIsReturned) {
TEST_F(ClCreateBufferTests, GivenValidParametersWhenCreatingBufferThenSuccessIsReturned) {
cl_mem_flags flags = CL_MEM_USE_HOST_PTR;
static const unsigned int bufferSize = 16;
cl_mem buffer = nullptr;
@@ -173,7 +173,7 @@ TEST_F(clCreateBufferTests, GivenValidParametersWhenCreatingBufferThenSuccessIsR
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateBufferTests, GivenForceExtendedBufferSizeDebugFlagWhenBufferIsCreatedThenSizeIsProperlyExtended) {
TEST_F(ClCreateBufferTests, GivenForceExtendedBufferSizeDebugFlagWhenBufferIsCreatedThenSizeIsProperlyExtended) {
DebugManagerStateRestore restorer;
unsigned char *pHostMem = nullptr;
@@ -223,7 +223,7 @@ TEST_F(clCreateBufferTests, GivenForceExtendedBufferSizeDebugFlagWhenBufferIsCre
clReleaseMemObject(buffer);
}
TEST_F(clCreateBufferTests, GivenNullContextWhenCreatingBufferThenInvalidContextErrorIsReturned) {
TEST_F(ClCreateBufferTests, GivenNullContextWhenCreatingBufferThenInvalidContextErrorIsReturned) {
unsigned char *pHostMem = nullptr;
cl_mem_flags flags = 0;
static const unsigned int bufferSize = 16;
@@ -235,38 +235,38 @@ TEST_F(clCreateBufferTests, GivenNullContextWhenCreatingBufferThenInvalidContext
ASSERT_EQ(CL_INVALID_CONTEXT, retVal);
}
TEST_F(clCreateBufferTests, GivenBufferSizeZeroWhenCreatingBufferThenInvalidBufferSizeErrorIsReturned) {
TEST_F(ClCreateBufferTests, GivenBufferSizeZeroWhenCreatingBufferThenInvalidBufferSizeErrorIsReturned) {
uint8_t hostData = 0;
clCreateBuffer(pContext, CL_MEM_USE_HOST_PTR, 0, &hostData, &retVal);
ASSERT_EQ(CL_INVALID_BUFFER_SIZE, retVal);
}
TEST_F(clCreateBufferTests, GivenInvalidHostPointerWhenCreatingBufferThenInvalidHostPointerErrorIsReturned) {
TEST_F(ClCreateBufferTests, GivenInvalidHostPointerWhenCreatingBufferThenInvalidHostPointerErrorIsReturned) {
uint32_t hostData = 0;
cl_mem_flags flags = 0;
clCreateBuffer(pContext, flags, sizeof(uint32_t), &hostData, &retVal);
ASSERT_EQ(CL_INVALID_HOST_PTR, retVal);
}
TEST_F(clCreateBufferTests, GivenNullHostPointerAndMemCopyHostPtrFlagWhenCreatingBufferThenInvalidHostPointerErrorIsReturned) {
TEST_F(ClCreateBufferTests, GivenNullHostPointerAndMemCopyHostPtrFlagWhenCreatingBufferThenInvalidHostPointerErrorIsReturned) {
cl_mem_flags flags = CL_MEM_COPY_HOST_PTR;
clCreateBuffer(pContext, flags, sizeof(uint32_t), nullptr, &retVal);
ASSERT_EQ(CL_INVALID_HOST_PTR, retVal);
}
TEST_F(clCreateBufferTests, GivenNullHostPointerAndMemUseHostPtrFlagWhenCreatingBufferThenInvalidHostPointerErrorIsReturned) {
TEST_F(ClCreateBufferTests, GivenNullHostPointerAndMemUseHostPtrFlagWhenCreatingBufferThenInvalidHostPointerErrorIsReturned) {
cl_mem_flags flags = CL_MEM_USE_HOST_PTR;
clCreateBuffer(pContext, flags, sizeof(uint32_t), nullptr, &retVal);
ASSERT_EQ(CL_INVALID_HOST_PTR, retVal);
}
TEST_F(clCreateBufferTests, GivenMemWriteOnlyFlagAndMemReadWriteFlagWhenCreatingBufferThenInvalidValueErrorIsReturned) {
TEST_F(ClCreateBufferTests, GivenMemWriteOnlyFlagAndMemReadWriteFlagWhenCreatingBufferThenInvalidValueErrorIsReturned) {
cl_mem_flags flags = CL_MEM_WRITE_ONLY | CL_MEM_READ_WRITE;
clCreateBuffer(pContext, flags, 16, nullptr, &retVal);
ASSERT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeWhenCreatingBufferThenInvalidBufferSizeErrorIsReturned) {
TEST_F(ClCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeWhenCreatingBufferThenInvalidBufferSizeErrorIsReturned) {
auto pDevice = pContext->getDevice(0);
size_t size = static_cast<size_t>(pDevice->getDevice().getDeviceInfo().maxMemAllocSize) + 1;
@@ -275,7 +275,7 @@ TEST_F(clCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeWhenCreatingBuffer
EXPECT_EQ(nullptr, buffer);
}
TEST_F(clCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeWhenCreateBufferWithPropertiesINTELThenInvalidBufferSizeErrorIsReturned) {
TEST_F(ClCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeWhenCreateBufferWithPropertiesINTELThenInvalidBufferSizeErrorIsReturned) {
auto pDevice = pContext->getDevice(0);
size_t size = static_cast<size_t>(pDevice->getDevice().getDeviceInfo().maxMemAllocSize) + 1;
@@ -284,7 +284,7 @@ TEST_F(clCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeWhenCreateBufferWi
EXPECT_EQ(nullptr, buffer);
}
TEST_F(clCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeAndClMemAllowUnrestirctedSizeFlagWhenCreatingBufferThenClSuccessIsReturned) {
TEST_F(ClCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeAndClMemAllowUnrestirctedSizeFlagWhenCreatingBufferThenClSuccessIsReturned) {
auto pDevice = pContext->getDevice(0);
uint64_t bigSize = GB * 5;
size_t size = static_cast<size_t>(bigSize);
@@ -304,7 +304,7 @@ TEST_F(clCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeAndClMemAllowUnres
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeAndClMemAllowUnrestirctedSizeFlagWhenCreatingBufferWithPropertiesINTELThenClSuccesssIsReturned) {
TEST_F(ClCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeAndClMemAllowUnrestirctedSizeFlagWhenCreatingBufferWithPropertiesINTELThenClSuccesssIsReturned) {
auto pDevice = pContext->getDevice(0);
uint64_t bigSize = GB * 5;
size_t size = static_cast<size_t>(bigSize);
@@ -325,7 +325,7 @@ TEST_F(clCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeAndClMemAllowUnres
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeAndDebugFlagSetWhenCreatingBufferThenClSuccessIsReturned) {
TEST_F(ClCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeAndDebugFlagSetWhenCreatingBufferThenClSuccessIsReturned) {
DebugManagerStateRestore restorer;
DebugManager.flags.AllowUnrestrictedSize.set(1);
auto pDevice = pContext->getDevice(0);
@@ -345,7 +345,7 @@ TEST_F(clCreateBufferTests, GivenBufferSizeOverMaxMemAllocSizeAndDebugFlagSetWhe
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateBufferTests, GivenNullHostPointerAndMemCopyHostPtrFlagWhenCreatingBufferThenNullIsReturned) {
TEST_F(ClCreateBufferTests, GivenNullHostPointerAndMemCopyHostPtrFlagWhenCreatingBufferThenNullIsReturned) {
cl_mem_flags flags = CL_MEM_USE_HOST_PTR;
static const unsigned int bufferSize = 16;
cl_mem buffer = nullptr;
@@ -361,7 +361,7 @@ TEST_F(clCreateBufferTests, GivenNullHostPointerAndMemCopyHostPtrFlagWhenCreatin
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateBufferTests, WhenCreatingBufferWithPropertiesThenParametersAreCorrectlyPassed) {
TEST_F(ClCreateBufferTests, WhenCreatingBufferWithPropertiesThenParametersAreCorrectlyPassed) {
VariableBackup<BufferFunctions::ValidateInputAndCreateBufferFunc> bufferCreateBackup{&BufferFunctions::validateInputAndCreateBuffer};
cl_context context = pContext;
@@ -396,7 +396,7 @@ TEST_F(clCreateBufferTests, WhenCreatingBufferWithPropertiesThenParametersAreCor
}
}
TEST_F(clCreateBufferTests, WhenCreatingBufferWithPropertiesThenErrorCodeIsCorrectlySet) {
TEST_F(ClCreateBufferTests, WhenCreatingBufferWithPropertiesThenErrorCodeIsCorrectlySet) {
VariableBackup<BufferFunctions::ValidateInputAndCreateBufferFunc> bufferCreateBackup{&BufferFunctions::validateInputAndCreateBuffer};
cl_mem_properties *properties = nullptr;
@@ -425,7 +425,7 @@ TEST_F(clCreateBufferTests, WhenCreatingBufferWithPropertiesThenErrorCodeIsCorre
}
}
TEST_F(clCreateBufferTests, GivenBufferCreatedWithNullPropertiesWhenQueryingPropertiesThenNothingIsReturned) {
TEST_F(ClCreateBufferTests, GivenBufferCreatedWithNullPropertiesWhenQueryingPropertiesThenNothingIsReturned) {
cl_int retVal = CL_SUCCESS;
size_t size = 10;
auto buffer = clCreateBufferWithPropertiesINTEL(pContext, nullptr, 0, size, nullptr, &retVal);
@@ -440,7 +440,7 @@ TEST_F(clCreateBufferTests, GivenBufferCreatedWithNullPropertiesWhenQueryingProp
clReleaseMemObject(buffer);
}
TEST_F(clCreateBufferTests, WhenCreatingBufferWithPropertiesThenPropertiesAreCorrectlyStored) {
TEST_F(ClCreateBufferTests, WhenCreatingBufferWithPropertiesThenPropertiesAreCorrectlyStored) {
cl_int retVal = CL_SUCCESS;
size_t size = 10;
cl_mem_properties properties[5];
@@ -610,4 +610,4 @@ TEST_F(clCreateBufferWithMultiDeviceContextFaillingAllocationTests, GivenContext
alignedFree(hostBuffer);
}
} // namespace ClCreateBufferTests
} // namespace ULT

62
opencl/test/unit_test/api/cl_create_command_queue_with_properties_tests.cpp
View File

@@ -48,10 +48,10 @@ struct CommandQueueWithPropertiesTest : public ApiFixture<>,
cl_queue_throttle_khr queueThrottle;
};
struct clCreateCommandQueueWithPropertiesApi : public ApiFixture<>,
struct ClCreateCommandQueueWithPropertiesApi : public ApiFixture<>,
public MemoryManagementFixture,
public ::testing::Test {
clCreateCommandQueueWithPropertiesApi() {
ClCreateCommandQueueWithPropertiesApi() {
}
void SetUp() override {
@@ -167,7 +167,7 @@ INSTANTIATE_TEST_CASE_P(api,
::testing::ValuesIn(queuePriorities),
::testing::ValuesIn(queueThrottles)));
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenNullContextWhenCreatingCommandQueueWithPropertiesThenInvalidContextErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenNullContextWhenCreatingCommandQueueWithPropertiesThenInvalidContextErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
auto cmdQ = clCreateCommandQueueWithProperties(
nullptr,
@@ -178,7 +178,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenNullContextWhenCreatingComman
EXPECT_EQ(retVal, CL_INVALID_CONTEXT);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenNullContextWhenCreatingCommandQueueWithPropertiesKHRThenInvalidContextErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenNullContextWhenCreatingCommandQueueWithPropertiesKHRThenInvalidContextErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
auto cmdQ = clCreateCommandQueueWithPropertiesKHR(
nullptr,
@@ -189,7 +189,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenNullContextWhenCreatingComman
EXPECT_EQ(retVal, CL_INVALID_CONTEXT);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenOoqPropertiesWhenQueueIsCreatedThenSuccessIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenOoqPropertiesWhenQueueIsCreatedThenSuccessIsReturned) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties ooq[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, 0};
auto cmdq = clCreateCommandQueueWithProperties(pContext, testedClDevice, ooq, &retVal);
@@ -200,14 +200,14 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenOoqPropertiesWhenQueueIsCreat
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenQueueOnDeviceWithoutOoqPropertiesWhenQueueIsCreatedThenErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenQueueOnDeviceWithoutOoqPropertiesWhenQueueIsCreatedThenErrorIsReturned) {
cl_queue_properties ondevice[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_ON_DEVICE, 0};
auto cmdqd = clCreateCommandQueueWithProperties(pContext, testedClDevice, ondevice, &retVal);
EXPECT_EQ(nullptr, cmdqd);
EXPECT_EQ(retVal, CL_INVALID_VALUE);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenNullContextAndOoqPropertiesWhenCreatingCommandQueueWithPropertiesThenInvalidContextErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenNullContextAndOoqPropertiesWhenCreatingCommandQueueWithPropertiesThenInvalidContextErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties ooq[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE | CL_QUEUE_ON_DEVICE_DEFAULT, 0};
auto cmdq = clCreateCommandQueueWithProperties(nullptr, testedClDevice, ooq, &retVal);
@@ -215,7 +215,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenNullContextAndOoqPropertiesWh
EXPECT_EQ(retVal, CL_INVALID_CONTEXT);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenNullDeviceWhenCreatingCommandQueueWithPropertiesThenInvalidDeviceErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenNullDeviceWhenCreatingCommandQueueWithPropertiesThenInvalidDeviceErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties ooq[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE | CL_QUEUE_ON_DEVICE_DEFAULT, 0};
auto cmdq = clCreateCommandQueueWithProperties(pContext, nullptr, ooq, &retVal);
@@ -223,7 +223,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenNullDeviceWhenCreatingCommand
EXPECT_EQ(retVal, CL_INVALID_DEVICE);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenDeviceNotAssociatedWithContextWhenCreatingCommandQueueWithPropertiesThenInvalidDeviceErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenDeviceNotAssociatedWithContextWhenCreatingCommandQueueWithPropertiesThenInvalidDeviceErrorIsReturned) {
cl_int retVal = CL_OUT_OF_HOST_MEMORY;
UltClDeviceFactory deviceFactory{1, 0};
EXPECT_FALSE(pContext->isDeviceAssociated(*deviceFactory.rootDevices[0]));
@@ -232,7 +232,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenDeviceNotAssociatedWithContex
EXPECT_EQ(retVal, CL_INVALID_DEVICE);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenSizeWhichExceedsMaxDeviceQueueSizeWhenCreatingCommandQueueWithPropertiesThenInvalidQueuePropertiesErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenSizeWhichExceedsMaxDeviceQueueSizeWhenCreatingCommandQueueWithPropertiesThenInvalidQueuePropertiesErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties ooq[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE | CL_QUEUE_ON_DEVICE_DEFAULT, CL_QUEUE_SIZE, (cl_uint)0xffffffff, 0, 0};
auto cmdq = clCreateCommandQueueWithProperties(pContext, testedClDevice, ooq, &retVal);
@@ -240,7 +240,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenSizeWhichExceedsMaxDeviceQueu
EXPECT_EQ(retVal, CL_INVALID_QUEUE_PROPERTIES);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenQueueOnDeviceWithoutOutOfOrderExecModePropertyWhenCreatingCommandQueueWithPropertiesThenInvalidValueErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenQueueOnDeviceWithoutOutOfOrderExecModePropertyWhenCreatingCommandQueueWithPropertiesThenInvalidValueErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties odq[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_ON_DEVICE, 0};
auto cmdq = clCreateCommandQueueWithProperties(pContext, testedClDevice, odq, &retVal);
@@ -248,7 +248,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenQueueOnDeviceWithoutOutOfOrde
EXPECT_EQ(retVal, CL_INVALID_VALUE);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenDefaultDeviceQueueWithoutQueueOnDevicePropertyWhenCreatingCommandQueueWithPropertiesThenInvalidValueErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenDefaultDeviceQueueWithoutQueueOnDevicePropertyWhenCreatingCommandQueueWithPropertiesThenInvalidValueErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties ddq[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_ON_DEVICE_DEFAULT, 0};
auto cmdq = clCreateCommandQueueWithProperties(pContext, testedClDevice, ddq, &retVal);
@@ -256,7 +256,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenDefaultDeviceQueueWithoutQueu
EXPECT_EQ(retVal, CL_INVALID_VALUE);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenHighPriorityWhenCreatingOoqCommandQueueWithPropertiesThenInvalidQueuePropertiesErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenHighPriorityWhenCreatingOoqCommandQueueWithPropertiesThenInvalidQueuePropertiesErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties ondevice[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, CL_QUEUE_PRIORITY_KHR, CL_QUEUE_PRIORITY_HIGH_KHR, 0};
auto cmdqd = clCreateCommandQueueWithProperties(pContext, testedClDevice, ondevice, &retVal);
@@ -264,14 +264,14 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenHighPriorityWhenCreatingOoqCo
EXPECT_EQ(retVal, CL_INVALID_QUEUE_PROPERTIES);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenLowPriorityWhenCreatingOoqCommandQueueWithPropertiesThenInvalidQueuePropertiesErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenLowPriorityWhenCreatingOoqCommandQueueWithPropertiesThenInvalidQueuePropertiesErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties ondevice[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, CL_QUEUE_PRIORITY_KHR, CL_QUEUE_PRIORITY_LOW_KHR, 0};
auto cmdqd = clCreateCommandQueueWithProperties(pContext, testedClDevice, ondevice, &retVal);
EXPECT_EQ(nullptr, cmdqd);
EXPECT_EQ(retVal, CL_INVALID_QUEUE_PROPERTIES);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenMedPriorityWhenCreatingOoqCommandQueueWithPropertiesThenInvalidQueuePropertiesErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenMedPriorityWhenCreatingOoqCommandQueueWithPropertiesThenInvalidQueuePropertiesErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties ondevice[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_ON_DEVICE | CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, CL_QUEUE_PRIORITY_KHR, CL_QUEUE_PRIORITY_MED_KHR, 0};
auto cmdqd = clCreateCommandQueueWithProperties(pContext, testedClDevice, ondevice, &retVal);
@@ -279,7 +279,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenMedPriorityWhenCreatingOoqCom
EXPECT_EQ(retVal, CL_INVALID_QUEUE_PROPERTIES);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, givenDeviceQueuePropertiesWhenCreatingCommandQueueWithPropertiesThenNullQueueAndInvalidQueuePropertiesErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, givenDeviceQueuePropertiesWhenCreatingCommandQueueWithPropertiesThenNullQueueAndInvalidQueuePropertiesErrorIsReturned) {
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockContext context{pClDevice.get()};
@@ -290,7 +290,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, givenDeviceQueuePropertiesWhenCrea
EXPECT_EQ(retVal, CL_INVALID_QUEUE_PROPERTIES);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, givenDefaultDeviceQueuePropertiesWhenCreatingCommandQueueWithPropertiesThenNullQueueAndInvalidQueuePropertiesErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, givenDefaultDeviceQueuePropertiesWhenCreatingCommandQueueWithPropertiesThenNullQueueAndInvalidQueuePropertiesErrorIsReturned) {
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
MockContext context{pClDevice.get()};
@@ -301,7 +301,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, givenDefaultDeviceQueuePropertiesW
EXPECT_EQ(retVal, CL_INVALID_QUEUE_PROPERTIES);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenInvalidPropertiesWhenCreatingOoqCommandQueueWithPropertiesThenInvalidValueErrorIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenInvalidPropertiesWhenCreatingOoqCommandQueueWithPropertiesThenInvalidValueErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties properties = CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
auto commandQueue = clCreateCommandQueueWithProperties(pContext, testedClDevice, &properties, &retVal);
@@ -309,7 +309,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenInvalidPropertiesWhenCreating
EXPECT_EQ(retVal, CL_INVALID_VALUE);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, givenInvalidPropertiesOnSubsequentTokenWhenQueueIsCreatedThenReturnError) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, givenInvalidPropertiesOnSubsequentTokenWhenQueueIsCreatedThenReturnError) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties properties[] = {CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, CL_DEVICE_PARTITION_EQUALLY, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, 0};
auto commandQueue = clCreateCommandQueueWithProperties(pContext, testedClDevice, properties, &retVal);
@@ -317,7 +317,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, givenInvalidPropertiesOnSubsequent
EXPECT_EQ(retVal, CL_INVALID_VALUE);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenNullPropertiesWhenCreatingCommandQueueWithPropertiesThenSuccessIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenNullPropertiesWhenCreatingCommandQueueWithPropertiesThenSuccessIsReturned) {
cl_int retVal = CL_SUCCESS;
auto commandQueue = clCreateCommandQueueWithProperties(pContext, testedClDevice, nullptr, &retVal);
EXPECT_NE(nullptr, commandQueue);
@@ -325,7 +325,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenNullPropertiesWhenCreatingCom
clReleaseCommandQueue(commandQueue);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenLowPriorityWhenCreatingCommandQueueWithPropertiesThenSuccessIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenLowPriorityWhenCreatingCommandQueueWithPropertiesThenSuccessIsReturned) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties ondevice[] = {CL_QUEUE_PRIORITY_KHR, CL_QUEUE_PRIORITY_LOW_KHR, 0};
auto cmdqd = clCreateCommandQueueWithProperties(pContext, testedClDevice, ondevice, &retVal);
@@ -335,7 +335,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenLowPriorityWhenCreatingComman
EXPECT_EQ(retVal, CL_SUCCESS);
}
HWTEST_F(clCreateCommandQueueWithPropertiesApi, GivenLowPriorityWhenCreatingCommandQueueThenSelectRcsEngine) {
HWTEST_F(ClCreateCommandQueueWithPropertiesApi, GivenLowPriorityWhenCreatingCommandQueueThenSelectRcsEngine) {
cl_queue_properties properties[] = {CL_QUEUE_PRIORITY_KHR, CL_QUEUE_PRIORITY_LOW_KHR, 0};
auto cmdQ = clCreateCommandQueueWithProperties(pContext, testedClDevice, properties, nullptr);
@@ -347,7 +347,7 @@ HWTEST_F(clCreateCommandQueueWithPropertiesApi, GivenLowPriorityWhenCreatingComm
clReleaseCommandQueue(cmdQ);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenCommandQueueCreatedWithNullPropertiesWhenQueryingPropertiesArrayThenNothingIsReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenCommandQueueCreatedWithNullPropertiesWhenQueryingPropertiesArrayThenNothingIsReturned) {
cl_int retVal = CL_SUCCESS;
auto commandQueue = clCreateCommandQueueWithProperties(pContext, testedClDevice, nullptr, &retVal);
EXPECT_EQ(retVal, CL_SUCCESS);
@@ -361,7 +361,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenCommandQueueCreatedWithNullPr
clReleaseCommandQueue(commandQueue);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, GivenCommandQueueCreatedWithVariousPropertiesWhenQueryingPropertiesArrayThenCorrectValuesAreReturned) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, GivenCommandQueueCreatedWithVariousPropertiesWhenQueryingPropertiesArrayThenCorrectValuesAreReturned) {
cl_int retVal = CL_SUCCESS;
cl_queue_properties propertiesArray[3];
size_t propertiesArraySize;
@@ -387,7 +387,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, GivenCommandQueueCreatedWithVariou
}
}
TEST_F(clCreateCommandQueueWithPropertiesApi, givenQueueFamilySelectedAndNotIndexWhenCreatingQueueThenFail) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, givenQueueFamilySelectedAndNotIndexWhenCreatingQueueThenFail) {
cl_queue_properties queueProperties[] = {
CL_QUEUE_FAMILY_INTEL,
0,
@@ -399,7 +399,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, givenQueueFamilySelectedAndNotInde
EXPECT_EQ(CL_INVALID_QUEUE_PROPERTIES, retVal);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, givenQueueIndexSelectedAndNotFamilyWhenCreatingQueueThenFail) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, givenQueueIndexSelectedAndNotFamilyWhenCreatingQueueThenFail) {
cl_queue_properties queueProperties[] = {
CL_QUEUE_INDEX_INTEL,
0,
@@ -411,7 +411,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, givenQueueIndexSelectedAndNotFamil
EXPECT_EQ(CL_INVALID_QUEUE_PROPERTIES, retVal);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, givenValidFamilyAndIndexSelectedWhenCreatingQueueThenReturnSuccess) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, givenValidFamilyAndIndexSelectedWhenCreatingQueueThenReturnSuccess) {
cl_queue_properties queueProperties[] = {
CL_QUEUE_FAMILY_INTEL,
0,
@@ -426,7 +426,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, givenValidFamilyAndIndexSelectedWh
EXPECT_EQ(CL_SUCCESS, clReleaseCommandQueue(queue));
}
TEST_F(clCreateCommandQueueWithPropertiesApi, givenInvalidQueueFamilySelectedWhenCreatingQueueThenFail) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, givenInvalidQueueFamilySelectedWhenCreatingQueueThenFail) {
cl_queue_properties queueProperties[] = {
CL_QUEUE_FAMILY_INTEL,
CommonConstants::engineGroupCount,
@@ -440,7 +440,7 @@ TEST_F(clCreateCommandQueueWithPropertiesApi, givenInvalidQueueFamilySelectedWhe
EXPECT_EQ(CL_INVALID_QUEUE_PROPERTIES, retVal);
}
TEST_F(clCreateCommandQueueWithPropertiesApi, givenInvalidQueueIndexSelectedWhenCreatingQueueThenFail) {
TEST_F(ClCreateCommandQueueWithPropertiesApi, givenInvalidQueueIndexSelectedWhenCreatingQueueThenFail) {
cl_queue_properties queueProperties[] = {
CL_QUEUE_FAMILY_INTEL,
0,
@@ -478,7 +478,7 @@ std::pair<uint32_t, QueuePriority> priorityParams[3]{
std::make_pair(CL_QUEUE_PRIORITY_MED_KHR, QueuePriority::MEDIUM),
std::make_pair(CL_QUEUE_PRIORITY_HIGH_KHR, QueuePriority::HIGH)};
class ClCreateCommandQueueWithPropertiesApiPriority : public clCreateCommandQueueWithPropertiesApi,
class ClCreateCommandQueueWithPropertiesApiPriority : public ClCreateCommandQueueWithPropertiesApi,
public ::testing::WithParamInterface<std::pair<uint32_t, QueuePriority>> {
};
@@ -505,7 +505,7 @@ std::pair<uint32_t, QueueThrottle> throttleParams[3]{
std::make_pair(CL_QUEUE_THROTTLE_MED_KHR, QueueThrottle::MEDIUM),
std::make_pair(CL_QUEUE_THROTTLE_HIGH_KHR, QueueThrottle::HIGH)};
class ClCreateCommandQueueWithPropertiesApiThrottle : public clCreateCommandQueueWithPropertiesApi,
class ClCreateCommandQueueWithPropertiesApiThrottle : public ClCreateCommandQueueWithPropertiesApi,
public ::testing::WithParamInterface<std::pair<uint32_t, QueueThrottle>> {
};

20
opencl/test/unit_test/api/cl_create_context_from_type_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -12,7 +12,7 @@
using namespace NEO;
struct clCreateContextFromTypeTests : Test<PlatformFixture> {
struct ClCreateContextFromTypeTests : Test<PlatformFixture> {
cl_int retVal = CL_DEVICE_NOT_AVAILABLE;
};
@@ -21,7 +21,7 @@ void CL_CALLBACK contextCallBack(const char *, const void *,
size_t, void *) {
}
TEST_F(clCreateContextFromTypeTests, GivenOnlyGpuDeviceTypeAndReturnValueWhenCreatingContextFromTypeThenContextWithSingleDeviceIsCreated) {
TEST_F(ClCreateContextFromTypeTests, GivenOnlyGpuDeviceTypeAndReturnValueWhenCreatingContextFromTypeThenContextWithSingleDeviceIsCreated) {
auto context =
clCreateContextFromType(nullptr, CL_DEVICE_TYPE_GPU, nullptr, nullptr, &retVal);
@@ -37,14 +37,14 @@ TEST_F(clCreateContextFromTypeTests, GivenOnlyGpuDeviceTypeAndReturnValueWhenCre
ASSERT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateContextFromTypeTests, GivenCpuTypeWhenCreatingContextFromTypeThenInvalidValueErrorIsReturned) {
TEST_F(ClCreateContextFromTypeTests, GivenCpuTypeWhenCreatingContextFromTypeThenInvalidValueErrorIsReturned) {
auto context =
clCreateContextFromType(nullptr, CL_DEVICE_TYPE_CPU, nullptr, nullptr, &retVal);
ASSERT_EQ(nullptr, context);
ASSERT_EQ(CL_DEVICE_NOT_FOUND, retVal);
}
TEST_F(clCreateContextFromTypeTests, GivenNullCallbackFunctionAndNotNullUserDataWhenCreatingContextFromTypeThenInvalidValueErrorIsReturned) {
TEST_F(ClCreateContextFromTypeTests, GivenNullCallbackFunctionAndNotNullUserDataWhenCreatingContextFromTypeThenInvalidValueErrorIsReturned) {
cl_int a;
auto context =
clCreateContextFromType(nullptr, CL_DEVICE_TYPE_GPU, nullptr, &a, &retVal);
@@ -52,7 +52,7 @@ TEST_F(clCreateContextFromTypeTests, GivenNullCallbackFunctionAndNotNullUserData
ASSERT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clCreateContextFromTypeTests, GivenCallbackFunctionWhenCreatingContextFromTypeThenCallSucceeds) {
TEST_F(ClCreateContextFromTypeTests, GivenCallbackFunctionWhenCreatingContextFromTypeThenCallSucceeds) {
auto context = clCreateContextFromType(nullptr, CL_DEVICE_TYPE_GPU, contextCallBack, nullptr, &retVal);
ASSERT_NE(nullptr, context);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -61,7 +61,7 @@ TEST_F(clCreateContextFromTypeTests, GivenCallbackFunctionWhenCreatingContextFro
ASSERT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateContextFromTypeTests, GivenOnlyGpuDeviceTypeWhenCreatingContextFromTypeThenCallSucceeds) {
TEST_F(ClCreateContextFromTypeTests, GivenOnlyGpuDeviceTypeWhenCreatingContextFromTypeThenCallSucceeds) {
auto context =
clCreateContextFromType(nullptr, CL_DEVICE_TYPE_GPU, nullptr, nullptr, nullptr);
@@ -73,14 +73,14 @@ TEST_F(clCreateContextFromTypeTests, GivenOnlyGpuDeviceTypeWhenCreatingContextFr
ASSERT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateContextFromTypeTests, GivenInvalidContextCreationPropertiesWhenCreatingContextFromTypeThenInvalidPlatformErrorIsReturned) {
TEST_F(ClCreateContextFromTypeTests, GivenInvalidContextCreationPropertiesWhenCreatingContextFromTypeThenInvalidPlatformErrorIsReturned) {
cl_context_properties invalidProperties[3] = {CL_CONTEXT_PLATFORM, (cl_context_properties) nullptr, 0};
auto context = clCreateContextFromType(invalidProperties, CL_DEVICE_TYPE_GPU, nullptr, nullptr, &retVal);
EXPECT_EQ(CL_INVALID_PLATFORM, retVal);
EXPECT_EQ(nullptr, context);
}
TEST_F(clCreateContextFromTypeTests, GivenNonDefaultPlatformInContextCreationPropertiesWhenCreatingContextFromTypeThenSuccessIsReturned) {
TEST_F(ClCreateContextFromTypeTests, GivenNonDefaultPlatformInContextCreationPropertiesWhenCreatingContextFromTypeThenSuccessIsReturned) {
auto nonDefaultPlatform = std::make_unique<MockPlatform>();
nonDefaultPlatform->initializeWithNewDevices();
cl_platform_id nonDefaultPlatformCl = nonDefaultPlatform.get();
@@ -95,7 +95,7 @@ TEST_F(clCreateContextFromTypeTests, GivenNonDefaultPlatformInContextCreationPro
clReleaseContext(clContext);
}
TEST_F(clCreateContextFromTypeTests, GivenNonDefaultPlatformWithInvalidIcdDispatchInContextCreationPropertiesWhenCreatingContextFromTypeThenInvalidPlatformErrorIsReturned) {
TEST_F(ClCreateContextFromTypeTests, GivenNonDefaultPlatformWithInvalidIcdDispatchInContextCreationPropertiesWhenCreatingContextFromTypeThenInvalidPlatformErrorIsReturned) {
auto nonDefaultPlatform = std::make_unique<MockPlatform>();
nonDefaultPlatform->initializeWithNewDevices();
cl_platform_id nonDefaultPlatformCl = nonDefaultPlatform.get();

44
opencl/test/unit_test/api/cl_create_image_tests.cpp
View File

@@ -22,10 +22,10 @@
using namespace NEO;
namespace ClCreateImageTests {
namespace ULT {
template <typename T>
struct clCreateImageTests : public ApiFixture<>,
struct ClCreateImageTests : public ApiFixture<>,
public T {
void SetUp() override {
@@ -56,7 +56,7 @@ struct clCreateImageTests : public ApiFixture<>,
cl_image_desc imageDesc;
};
typedef clCreateImageTests<::testing::Test> clCreateImageTest;
typedef ClCreateImageTests<::testing::Test> clCreateImageTest;
TEST_F(clCreateImageTest, GivenNullHostPtrWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
@@ -589,7 +589,7 @@ TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenPropertiesAreCorrec
}
}
typedef clCreateImageTests<::testing::Test> clCreateImageTestYUV;
typedef ClCreateImageTests<::testing::Test> clCreateImageTestYUV;
TEST_F(clCreateImageTestYUV, GivenInvalidGlagWhenCreatingYuvImageThenInvalidValueErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_YUYV_INTEL;
@@ -625,7 +625,7 @@ TEST_F(clCreateImageTestYUV, Given1DImageTypeWhenCreatingYuvImageThenInvalidImag
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
typedef clCreateImageTests<::testing::TestWithParam<uint64_t>> clCreateImageValidFlags;
typedef ClCreateImageTests<::testing::TestWithParam<uint64_t>> clCreateImageValidFlags;
static cl_mem_flags validFlags[] = {
CL_MEM_READ_WRITE,
@@ -673,7 +673,7 @@ TEST_P(clCreateImageValidFlags, GivenValidFlagsWhenCreatingImageThenImageIsCreat
EXPECT_EQ(CL_SUCCESS, retVal);
}
typedef clCreateImageTests<::testing::TestWithParam<uint64_t>> clCreateImageInvalidFlags;
typedef ClCreateImageTests<::testing::TestWithParam<uint64_t>> clCreateImageInvalidFlags;
static cl_mem_flags invalidFlagsCombinations[] = {
CL_MEM_READ_WRITE | CL_MEM_WRITE_ONLY,
@@ -751,7 +751,7 @@ static ImageFlags flagsWithUnrestrictedIntel[] = {
{CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL, CL_MEM_READ_WRITE},
{CL_MEM_READ_WRITE, CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL}};
typedef clCreateImageTests<::testing::TestWithParam<ImageFlags>> clCreateImageFlagsUnrestrictedIntel;
typedef ClCreateImageTests<::testing::TestWithParam<ImageFlags>> clCreateImageFlagsUnrestrictedIntel;
INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
clCreateImageFlagsUnrestrictedIntel,
@@ -802,7 +802,7 @@ static ImageFlags validFlagsAndParentFlags[] = {
{CL_MEM_NO_ACCESS_INTEL, CL_MEM_HOST_NO_ACCESS},
{CL_MEM_HOST_NO_ACCESS, CL_MEM_READ_WRITE}};
typedef clCreateImageTests<::testing::TestWithParam<ImageFlags>> clCreateImageValidFlagsAndParentFlagsCombinations;
typedef ClCreateImageTests<::testing::TestWithParam<ImageFlags>> clCreateImageValidFlagsAndParentFlagsCombinations;
INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
clCreateImageValidFlagsAndParentFlagsCombinations,
@@ -858,7 +858,7 @@ static ImageFlags invalidFlagsAndParentFlags[] = {
{CL_MEM_HOST_NO_ACCESS, CL_MEM_HOST_WRITE_ONLY},
{CL_MEM_HOST_NO_ACCESS, CL_MEM_HOST_READ_ONLY}};
typedef clCreateImageTests<::testing::TestWithParam<ImageFlags>> clCreateImageInvalidFlagsAndParentFlagsCombinations;
typedef ClCreateImageTests<::testing::TestWithParam<ImageFlags>> clCreateImageInvalidFlagsAndParentFlagsCombinations;
INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
clCreateImageInvalidFlagsAndParentFlagsCombinations,
@@ -910,7 +910,7 @@ struct ImageSizes {
ImageSizes validImage2DSizes[] = {{64, 64, 1}, {3, 3, 1}, {8192, 1, 1}, {117, 39, 1}, {16384, 4, 1}, {4, 16384, 1}};
typedef clCreateImageTests<::testing::TestWithParam<ImageSizes>> clCreateImageValidSizesTest;
typedef ClCreateImageTests<::testing::TestWithParam<ImageSizes>> clCreateImageValidSizesTest;
INSTANTIATE_TEST_CASE_P(validImage2DSizes,
clCreateImageValidSizesTest,
@@ -936,7 +936,7 @@ TEST_P(clCreateImageValidSizesTest, GivenValidSizesWhenCreatingImageThenImageIsC
retVal = clReleaseMemObject(image);
}
typedef clCreateImageTests<::testing::Test> clCreateImage2DTest;
typedef ClCreateImageTests<::testing::Test> clCreateImage2DTest;
TEST_F(clCreateImage2DTest, GivenValidParametersWhenCreating2DImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
@@ -1010,7 +1010,7 @@ TEST_F(clCreateImage2DTest, GivenDeviceThatDoesntSupportImagesWhenCreatingImages
ASSERT_EQ(CL_INVALID_OPERATION, retVal);
}
typedef clCreateImageTests<::testing::Test> clCreateImage3DTest;
typedef ClCreateImageTests<::testing::Test> clCreateImage3DTest;
TEST_F(clCreateImage3DTest, GivenValidParametersWhenCreating3DImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
@@ -1160,9 +1160,9 @@ TEST_F(clCreateImageWithPropertiesINTELTest, GivenInvalidPropertyKeyWhenCreating
EXPECT_EQ(CL_INVALID_PROPERTY, retVal);
}
typedef clCreateImageTests<::testing::Test> clCreateImageFromImageTest;
typedef ClCreateImageTests<::testing::Test> ClCreateImageFromImageTest;
TEST_F(clCreateImageFromImageTest, GivenImage2dWhenCreatingImage2dFromImageWithTheSameDescriptorAndValidFormatThenImageIsCreatedAndSuccessReturned) {
TEST_F(ClCreateImageFromImageTest, GivenImage2dWhenCreatingImage2dFromImageWithTheSameDescriptorAndValidFormatThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGES_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_BGRA;
@@ -1220,7 +1220,7 @@ TEST_F(clCreateImageFromImageTest, GivenImage2dWhenCreatingImage2dFromImageWithT
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageFromImageTest, GivenImage2dWhenCreatingImage2dFromImageWithDifferentDescriptorAndValidFormatThenInvalidImageFormatDescriptorErrorIsReturned) {
TEST_F(ClCreateImageFromImageTest, GivenImage2dWhenCreatingImage2dFromImageWithDifferentDescriptorAndValidFormatThenInvalidImageFormatDescriptorErrorIsReturned) {
REQUIRE_IMAGES_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_BGRA;
@@ -1275,7 +1275,7 @@ TEST_F(clCreateImageFromImageTest, GivenImage2dWhenCreatingImage2dFromImageWithD
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageFromImageTest, GivenImage2dWhenCreatingImage2dFromImageWithTheSameDescriptorAndNotValidFormatThenInvalidImageFormatDescriptorErrorIsReturned) {
TEST_F(ClCreateImageFromImageTest, GivenImage2dWhenCreatingImage2dFromImageWithTheSameDescriptorAndNotValidFormatThenInvalidImageFormatDescriptorErrorIsReturned) {
REQUIRE_IMAGES_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_BGRA;
@@ -1327,10 +1327,10 @@ TEST_F(clCreateImageFromImageTest, GivenImage2dWhenCreatingImage2dFromImageWithT
uint32_t non2dImageTypes[] = {CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE1D_BUFFER, CL_MEM_OBJECT_IMAGE2D_ARRAY, CL_MEM_OBJECT_IMAGE3D};
struct clCreateNon2dImageFromImageTest : public clCreateImageFromImageTest,
struct ClCreateNon2dImageFromImageTest : public ClCreateImageFromImageTest,
public ::testing::WithParamInterface<uint32_t /*image type*/> {
void SetUp() override {
clCreateImageFromImageTest::SetUp();
ClCreateImageFromImageTest::SetUp();
image = ImageFunctions::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
@@ -1338,12 +1338,12 @@ struct clCreateNon2dImageFromImageTest : public clCreateImageFromImageTest,
}
void TearDown() override {
retVal = clReleaseMemObject(image);
clCreateImageFromImageTest::TearDown();
ClCreateImageFromImageTest::TearDown();
}
cl_mem image;
};
TEST_P(clCreateNon2dImageFromImageTest, GivenImage2dWhenCreatingImageFromNon2dImageThenInvalidImageDescriptorErrorIsReturned) {
TEST_P(ClCreateNon2dImageFromImageTest, GivenImage2dWhenCreatingImageFromNon2dImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageDesc.image_type = GetParam();
auto imageFromImageObject = clCreateImage(
@@ -1359,7 +1359,7 @@ TEST_P(clCreateNon2dImageFromImageTest, GivenImage2dWhenCreatingImageFromNon2dIm
}
INSTANTIATE_TEST_CASE_P(clCreateNon2dImageFromImageTests,
clCreateNon2dImageFromImageTest,
ClCreateNon2dImageFromImageTest,
::testing::ValuesIn(non2dImageTypes));
using clCreateImageWithMultiDeviceContextTests = MultiRootDeviceFixture;
@@ -1416,4 +1416,4 @@ TEST_F(clCreateImageWithMultiDeviceContextTests, GivenContextdWithMultiDeviceFai
}
}
} // namespace ClCreateImageTests
} // namespace ULT

14
opencl/test/unit_test/api/cl_create_kernels_in_program_tests.inl
View File

@@ -16,7 +16,7 @@
using namespace NEO;
struct clCreateKernelsInProgramTests : public api_tests {
struct ClCreateKernelsInProgramTests : public api_tests {
void SetUp() override {
DebugManager.flags.FailBuildProgramWithStatefulAccess.set(0);
@@ -66,7 +66,7 @@ struct clCreateKernelsInProgramTests : public api_tests {
DebugManagerStateRestore restore;
};
TEST_F(clCreateKernelsInProgramTests, GivenValidParametersWhenCreatingKernelObjectsThenKernelsAndSuccessAreReturned) {
TEST_F(ClCreateKernelsInProgramTests, GivenValidParametersWhenCreatingKernelObjectsThenKernelsAndSuccessAreReturned) {
cl_uint numKernelsRet = 0;
retVal = clCreateKernelsInProgram(
program,
@@ -78,7 +78,7 @@ TEST_F(clCreateKernelsInProgramTests, GivenValidParametersWhenCreatingKernelObje
EXPECT_NE(nullptr, kernel);
}
TEST_F(clCreateKernelsInProgramTests, GivenNullKernelArgWhenCreatingKernelObjectsThenSuccessIsReturned) {
TEST_F(ClCreateKernelsInProgramTests, GivenNullKernelArgWhenCreatingKernelObjectsThenSuccessIsReturned) {
cl_uint numKernelsRet = 0;
retVal = clCreateKernelsInProgram(
program,
@@ -89,7 +89,7 @@ TEST_F(clCreateKernelsInProgramTests, GivenNullKernelArgWhenCreatingKernelObject
EXPECT_EQ(1u, numKernelsRet);
}
TEST_F(clCreateKernelsInProgramTests, GivenNullPtrForNumKernelsReturnWhenCreatingKernelObjectsThenSuccessIsReturned) {
TEST_F(ClCreateKernelsInProgramTests, GivenNullPtrForNumKernelsReturnWhenCreatingKernelObjectsThenSuccessIsReturned) {
retVal = clCreateKernelsInProgram(
program,
1,
@@ -99,7 +99,7 @@ TEST_F(clCreateKernelsInProgramTests, GivenNullPtrForNumKernelsReturnWhenCreatin
EXPECT_NE(nullptr, kernel);
}
TEST_F(clCreateKernelsInProgramTests, GivenNullProgramWhenCreatingKernelObjectsThenInvalidProgramErrorIsReturn) {
TEST_F(ClCreateKernelsInProgramTests, GivenNullProgramWhenCreatingKernelObjectsThenInvalidProgramErrorIsReturn) {
retVal = clCreateKernelsInProgram(
nullptr,
1,
@@ -109,7 +109,7 @@ TEST_F(clCreateKernelsInProgramTests, GivenNullProgramWhenCreatingKernelObjectsT
EXPECT_EQ(nullptr, kernel);
}
TEST_F(clCreateKernelsInProgramTests, GivenTooSmallOutputBufferWhenCreatingKernelObjectsThenInvalidValueErrorIsReturned) {
TEST_F(ClCreateKernelsInProgramTests, GivenTooSmallOutputBufferWhenCreatingKernelObjectsThenInvalidValueErrorIsReturned) {
retVal = clCreateKernelsInProgram(
program,
0,
@@ -119,7 +119,7 @@ TEST_F(clCreateKernelsInProgramTests, GivenTooSmallOutputBufferWhenCreatingKerne
EXPECT_EQ(nullptr, kernel);
}
TEST_F(clCreateKernelsInProgramTests, whenKernelCreationFailsOnClCreateKernelsInProgramAPICallThenPropagateTheErrorToAPICallAndReturnNullptrForEachKernel) {
TEST_F(ClCreateKernelsInProgramTests, whenKernelCreationFailsOnClCreateKernelsInProgramAPICallThenPropagateTheErrorToAPICallAndReturnNullptrForEachKernel) {
const auto rootDeviceIndex = pDevice->getRootDeviceIndex();
auto &kernelInfoArray = pProgram->getKernelInfoArray(rootDeviceIndex);
kernelInfoArray.push_back(new MockKernelInfo());

34
opencl/test/unit_test/api/cl_create_perf_counters_command_queue_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -16,7 +16,7 @@
using namespace NEO;
struct clCreatePerfCountersCommandQueueINTELTests : public DeviceInstrumentationFixture,
struct ClCreatePerfCountersCommandQueueINTELTests : public DeviceInstrumentationFixture,
public PerformanceCountersDeviceFixture,
::testing::Test {
void SetUp() override {
@@ -39,7 +39,7 @@ struct clCreatePerfCountersCommandQueueINTELTests : public DeviceInstrumentation
namespace ULT {
TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenCorrectParamatersWhenCreatingPerfCountersCmdQThenCmdQIsCreatedAndPerfCountersAreEnabled) {
TEST_F(ClCreatePerfCountersCommandQueueINTELTests, GivenCorrectParamatersWhenCreatingPerfCountersCmdQThenCmdQIsCreatedAndPerfCountersAreEnabled) {
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE;
cl_uint configuration = 0;
@@ -55,7 +55,7 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenCorrectParamatersWhenCre
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenNullPropertiesWhenCreatingPerfCountersCmdQThenInvalidQueuePropertiesErrorIsReturned) {
TEST_F(ClCreatePerfCountersCommandQueueINTELTests, GivenNullPropertiesWhenCreatingPerfCountersCmdQThenInvalidQueuePropertiesErrorIsReturned) {
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = 0;
cl_uint configuration = 0;
@@ -66,7 +66,7 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenNullPropertiesWhenCreati
ASSERT_EQ(CL_INVALID_QUEUE_PROPERTIES, retVal);
}
TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenClQueueOnDevicePropertyWhenCreatingPerfCountersCmdQThenInvalidQueuePropertiesErrorIsReturned) {
TEST_F(ClCreatePerfCountersCommandQueueINTELTests, GivenClQueueOnDevicePropertyWhenCreatingPerfCountersCmdQThenInvalidQueuePropertiesErrorIsReturned) {
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE | CL_QUEUE_ON_DEVICE;
cl_uint configuration = 0;
@@ -82,7 +82,7 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenClQueueOnDevicePropertyW
ASSERT_EQ(CL_INVALID_QUEUE_PROPERTIES, retVal);
}
TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenNullContextWhenCreatingPerfCountersCmdQThenInvalidContextErrorIsReturned) {
TEST_F(ClCreatePerfCountersCommandQueueINTELTests, GivenNullContextWhenCreatingPerfCountersCmdQThenInvalidContextErrorIsReturned) {
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE;
cl_uint configuration = 0;
@@ -93,7 +93,7 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenNullContextWhenCreatingP
ASSERT_EQ(CL_INVALID_CONTEXT, retVal);
}
TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenMaximumGtdiConfigurationWhenCreatingPerfCountersCmdQThenOutOfResourcesErrorIsReturned) {
TEST_F(ClCreatePerfCountersCommandQueueINTELTests, GivenMaximumGtdiConfigurationWhenCreatingPerfCountersCmdQThenOutOfResourcesErrorIsReturned) {
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE;
cl_uint configuration = 4;
@@ -104,7 +104,7 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenMaximumGtdiConfiguration
ASSERT_EQ(CL_INVALID_OPERATION, retVal);
}
TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenCorrectCmdQWhenEventIsCreatedThenPerfCountersAreEnabled) {
TEST_F(ClCreatePerfCountersCommandQueueINTELTests, GivenCorrectCmdQWhenEventIsCreatedThenPerfCountersAreEnabled) {
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE;
cl_uint configuration = 0;
@@ -123,7 +123,7 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenCorrectCmdQWhenEventIsCr
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenInstrumentationEnabledIsFalseWhenCreatingPerfCountersCmdQThenInvalidDeviceErrorIsReturned) {
TEST_F(ClCreatePerfCountersCommandQueueINTELTests, GivenInstrumentationEnabledIsFalseWhenCreatingPerfCountersCmdQThenInvalidDeviceErrorIsReturned) {
hwInfo->capabilityTable.instrumentationEnabled = false;
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE;
@@ -134,7 +134,7 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenInstrumentationEnabledIs
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
}
TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenInvalidDeviceWhenCreatingPerfCountersCmdQThenInvalidDeviceErrorIsReturned) {
TEST_F(ClCreatePerfCountersCommandQueueINTELTests, GivenInvalidDeviceWhenCreatingPerfCountersCmdQThenInvalidDeviceErrorIsReturned) {
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE;
cl_uint configuration = 0;
@@ -145,7 +145,7 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenInvalidDeviceWhenCreatin
ASSERT_EQ(CL_INVALID_DEVICE, retVal);
}
TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenInvalidMetricsLibraryWhenCreatingPerfCountersThenPerfCountersReturnError) {
TEST_F(ClCreatePerfCountersCommandQueueINTELTests, GivenInvalidMetricsLibraryWhenCreatingPerfCountersThenPerfCountersReturnError) {
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE;
cl_uint configuration = 0;
@@ -164,7 +164,7 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, GivenInvalidMetricsLibraryWhe
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreatePerfCountersCommandQueueINTELTests, givenInvalidMetricsLibraryWhenCreatingCommandQueueThenReturnError) {
TEST_F(ClCreatePerfCountersCommandQueueINTELTests, givenInvalidMetricsLibraryWhenCreatingCommandQueueThenReturnError) {
cl_command_queue cmdQ = nullptr;
cl_queue_properties properties = CL_QUEUE_PROFILING_ENABLE;
cl_uint configuration = 0;
@@ -179,14 +179,14 @@ TEST_F(clCreatePerfCountersCommandQueueINTELTests, givenInvalidMetricsLibraryWhe
EXPECT_EQ(CL_OUT_OF_RESOURCES, retVal);
}
struct clCreateCommandQueueWithPropertiesMdapiTests : public clCreatePerfCountersCommandQueueINTELTests {
struct ClCreateCommandQueueWithPropertiesMdapiTests : public ClCreatePerfCountersCommandQueueINTELTests {
cl_queue_properties queueProperties[7] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE,
CL_QUEUE_MDAPI_PROPERTIES_INTEL, CL_QUEUE_MDAPI_ENABLE_INTEL,
CL_QUEUE_MDAPI_CONFIGURATION_INTEL, 0,
0};
};
TEST_F(clCreateCommandQueueWithPropertiesMdapiTests, givenCorrectParamsWhenCreatingQueueWithPropertiesThenEnablePerfCounters) {
TEST_F(ClCreateCommandQueueWithPropertiesMdapiTests, givenCorrectParamsWhenCreatingQueueWithPropertiesThenEnablePerfCounters) {
auto cmdQ = clCreateCommandQueueWithProperties(context.get(), deviceId, queueProperties, &retVal);
ASSERT_NE(nullptr, cmdQ);
@@ -198,7 +198,7 @@ TEST_F(clCreateCommandQueueWithPropertiesMdapiTests, givenCorrectParamsWhenCreat
clReleaseCommandQueue(cmdQ);
}
TEST_F(clCreateCommandQueueWithPropertiesMdapiTests, givenParamsWithDisabledPerfCounterWhenCreatingQueueWithPropertiesThenCreateRegularQueue) {
TEST_F(ClCreateCommandQueueWithPropertiesMdapiTests, givenParamsWithDisabledPerfCounterWhenCreatingQueueWithPropertiesThenCreateRegularQueue) {
queueProperties[3] = 0;
auto cmdQ = clCreateCommandQueueWithProperties(context.get(), deviceId, queueProperties, &retVal);
@@ -211,7 +211,7 @@ TEST_F(clCreateCommandQueueWithPropertiesMdapiTests, givenParamsWithDisabledPerf
clReleaseCommandQueue(cmdQ);
}
TEST_F(clCreateCommandQueueWithPropertiesMdapiTests, givenIncorrectConfigurationWhenCreatingQueueWithPropertiesThenFail) {
TEST_F(ClCreateCommandQueueWithPropertiesMdapiTests, givenIncorrectConfigurationWhenCreatingQueueWithPropertiesThenFail) {
queueProperties[5] = 1;
auto cmdQ = clCreateCommandQueueWithProperties(context.get(), deviceId, queueProperties, &retVal);
@@ -220,7 +220,7 @@ TEST_F(clCreateCommandQueueWithPropertiesMdapiTests, givenIncorrectConfiguration
EXPECT_NE(CL_SUCCESS, retVal);
}
TEST_F(clCreateCommandQueueWithPropertiesMdapiTests, givenInvalidMdapiOpenWhenCreatingQueueWithPropertiesThenFail) {
TEST_F(ClCreateCommandQueueWithPropertiesMdapiTests, givenInvalidMdapiOpenWhenCreatingQueueWithPropertiesThenFail) {
auto performanceCounters = device->getPerformanceCounters();
auto metricsLibary = static_cast<MockMetricsLibrary *>(performanceCounters->getMetricsLibraryInterface());

22
opencl/test/unit_test/api/cl_create_pipe_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -17,11 +17,11 @@
using namespace NEO;
struct clCreatePipeTests : api_tests {
struct ClCreatePipeTests : api_tests {
VariableBackup<bool> supportsPipesBackup{&defaultHwInfo->capabilityTable.supportsPipes, true};
};
namespace ClCreatePipeTests {
namespace ULT {
class ClCreatePipeWithParamTests : public ApiFixture<>, public testing::TestWithParam<uint64_t> {
void SetUp() override {
@@ -101,7 +101,7 @@ INSTANTIATE_TEST_CASE_P(
ClCreatePipeWithParamNegativeTests,
testing::ValuesIn(invalidFlags));
TEST_F(clCreatePipeTests, GivenValidFlagsAndNullReturnWhenCreatingPipeThenPipeIsCreated) {
TEST_F(ClCreatePipeTests, GivenValidFlagsAndNullReturnWhenCreatingPipeThenPipeIsCreated) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
auto pipe = clCreatePipe(pContext, flags, 1, 20, nullptr, nullptr);
@@ -110,7 +110,7 @@ TEST_F(clCreatePipeTests, GivenValidFlagsAndNullReturnWhenCreatingPipeThenPipeIs
clReleaseMemObject(pipe);
}
TEST_F(clCreatePipeTests, GivenPipePacketSizeZeroWhenCreatingPipeThenInvalidPipeSizeErrorIsReturned) {
TEST_F(ClCreatePipeTests, GivenPipePacketSizeZeroWhenCreatingPipeThenInvalidPipeSizeErrorIsReturned) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
auto pipe = clCreatePipe(pContext, flags, 0, 20, nullptr, &retVal);
@@ -120,7 +120,7 @@ TEST_F(clCreatePipeTests, GivenPipePacketSizeZeroWhenCreatingPipeThenInvalidPipe
clReleaseMemObject(pipe);
}
TEST_F(clCreatePipeTests, GivenPipeMaxSizeZeroWhenCreatingPipeThenInvalidPipeSizeErrorIsReturned) {
TEST_F(ClCreatePipeTests, GivenPipeMaxSizeZeroWhenCreatingPipeThenInvalidPipeSizeErrorIsReturned) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
auto pipe = clCreatePipe(pContext, flags, 1, 0, nullptr, &retVal);
@@ -130,7 +130,7 @@ TEST_F(clCreatePipeTests, GivenPipeMaxSizeZeroWhenCreatingPipeThenInvalidPipeSiz
clReleaseMemObject(pipe);
}
TEST_F(clCreatePipeTests, GivenPipePropertiesNotNullWhenCreatingPipeThenInvalidValueErrorIsReturned) {
TEST_F(ClCreatePipeTests, GivenPipePropertiesNotNullWhenCreatingPipeThenInvalidValueErrorIsReturned) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
cl_pipe_properties properties = {0};
auto pipe = clCreatePipe(pContext, flags, 1, 20, &properties, &retVal);
@@ -141,7 +141,7 @@ TEST_F(clCreatePipeTests, GivenPipePropertiesNotNullWhenCreatingPipeThenInvalidV
clReleaseMemObject(pipe);
}
TEST_F(clCreatePipeTests, GivenDeviceNotSupportingPipesWhenCreatingPipeThenInvalidOperationErrorIsReturned) {
TEST_F(ClCreatePipeTests, GivenDeviceNotSupportingPipesWhenCreatingPipeThenInvalidOperationErrorIsReturned) {
auto hardwareInfo = *defaultHwInfo;
hardwareInfo.capabilityTable.supportsPipes = false;
@@ -153,7 +153,7 @@ TEST_F(clCreatePipeTests, GivenDeviceNotSupportingPipesWhenCreatingPipeThenInval
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
}
TEST_F(clCreatePipeTests, GivenPipePacketSizeGreaterThanAllowedWhenCreatingPipeThenInvalidPipeSizeErrorIsReturned) {
TEST_F(ClCreatePipeTests, GivenPipePacketSizeGreaterThanAllowedWhenCreatingPipeThenInvalidPipeSizeErrorIsReturned) {
cl_uint packetSize = pContext->getDevice(0)->getDeviceInfo().pipeMaxPacketSize;
cl_mem_flags flags = CL_MEM_READ_WRITE;
@@ -172,7 +172,7 @@ TEST_F(clCreatePipeTests, GivenPipePacketSizeGreaterThanAllowedWhenCreatingPipeT
clReleaseMemObject(pipe);
}
TEST_F(clCreatePipeTests, GivenNullContextWhenCreatingPipeThenInvalidContextErrorIsReturned) {
TEST_F(ClCreatePipeTests, GivenNullContextWhenCreatingPipeThenInvalidContextErrorIsReturned) {
auto pipe = clCreatePipe(nullptr, 0, 1, 20, nullptr, &retVal);
@@ -206,4 +206,4 @@ TEST(clCreatePipeTest, givenPlatformWithoutDevicesWhenClCreatePipeIsCalledThenDe
clReleaseMemObject(pipe);
}
} // namespace ClCreatePipeTests
} // namespace ULT

28
opencl/test/unit_test/api/cl_create_program_with_built_in_kernels_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -22,11 +22,11 @@
using namespace NEO;
typedef api_tests clCreateProgramWithBuiltInKernelsTests;
typedef api_tests ClCreateProgramWithBuiltInKernelsTests;
struct clCreateProgramWithBuiltInVmeKernelsTests : clCreateProgramWithBuiltInKernelsTests {
struct ClCreateProgramWithBuiltInVmeKernelsTests : ClCreateProgramWithBuiltInKernelsTests {
void SetUp() override {
clCreateProgramWithBuiltInKernelsTests::SetUp();
ClCreateProgramWithBuiltInKernelsTests::SetUp();
if (!castToObject<ClDevice>(testedClDevice)->getHardwareInfo().capabilityTable.supportsVme) {
GTEST_SKIP();
}
@@ -39,7 +39,7 @@ struct clCreateProgramWithBuiltInVmeKernelsTests : clCreateProgramWithBuiltInKer
namespace ULT {
TEST_F(clCreateProgramWithBuiltInKernelsTests, GivenInvalidContextWhenCreatingProgramWithBuiltInKernelsThenInvalidContextErrorIsReturned) {
TEST_F(ClCreateProgramWithBuiltInKernelsTests, GivenInvalidContextWhenCreatingProgramWithBuiltInKernelsThenInvalidContextErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
auto program = clCreateProgramWithBuiltInKernels(
nullptr, // context
@@ -51,7 +51,7 @@ TEST_F(clCreateProgramWithBuiltInKernelsTests, GivenInvalidContextWhenCreatingPr
EXPECT_EQ(CL_INVALID_CONTEXT, retVal);
}
TEST_F(clCreateProgramWithBuiltInKernelsTests, GivenNoKernelsWhenCreatingProgramWithBuiltInKernelsThenInvalidValueErrorIsReturned) {
TEST_F(ClCreateProgramWithBuiltInKernelsTests, GivenNoKernelsWhenCreatingProgramWithBuiltInKernelsThenInvalidValueErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
auto program = clCreateProgramWithBuiltInKernels(
pContext, // context
@@ -63,7 +63,7 @@ TEST_F(clCreateProgramWithBuiltInKernelsTests, GivenNoKernelsWhenCreatingProgram
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clCreateProgramWithBuiltInKernelsTests, GivenNoDeviceWhenCreatingProgramWithBuiltInKernelsThenInvalidValueErrorIsReturned) {
TEST_F(ClCreateProgramWithBuiltInKernelsTests, GivenNoDeviceWhenCreatingProgramWithBuiltInKernelsThenInvalidValueErrorIsReturned) {
cl_int retVal = CL_SUCCESS;
auto program = clCreateProgramWithBuiltInKernels(
pContext, // context
@@ -75,7 +75,7 @@ TEST_F(clCreateProgramWithBuiltInKernelsTests, GivenNoDeviceWhenCreatingProgramW
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clCreateProgramWithBuiltInKernelsTests, GivenNoKernelsAndNoReturnWhenCreatingProgramWithBuiltInKernelsThenProgramIsNotCreated) {
TEST_F(ClCreateProgramWithBuiltInKernelsTests, GivenNoKernelsAndNoReturnWhenCreatingProgramWithBuiltInKernelsThenProgramIsNotCreated) {
auto program = clCreateProgramWithBuiltInKernels(
pContext, // context
1, // num_devices
@@ -85,7 +85,7 @@ TEST_F(clCreateProgramWithBuiltInKernelsTests, GivenNoKernelsAndNoReturnWhenCrea
EXPECT_EQ(nullptr, program);
}
TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenDeviceNotAssociatedWithContextWhenCreatingProgramWithBuiltInThenInvalidDeviceErrorIsReturned) {
TEST_F(ClCreateProgramWithBuiltInVmeKernelsTests, GivenDeviceNotAssociatedWithContextWhenCreatingProgramWithBuiltInThenInvalidDeviceErrorIsReturned) {
cl_program pProgram = nullptr;
const char *kernelNamesString = {
@@ -119,7 +119,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenDeviceNotAssociatedWithCo
EXPECT_EQ(nullptr, pProgram);
}
TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenValidMediaKernelsWhenCreatingProgramWithBuiltInKernelsThenProgramIsSuccessfullyCreated) {
TEST_F(ClCreateProgramWithBuiltInVmeKernelsTests, GivenValidMediaKernelsWhenCreatingProgramWithBuiltInKernelsThenProgramIsSuccessfullyCreated) {
cl_int retVal = CL_SUCCESS;
overwriteBuiltInBinaryName("media_kernels_frontend");
@@ -162,7 +162,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenValidMediaKernelsWhenCrea
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenValidMediaKernelsWithOptionsWhenCreatingProgramWithBuiltInKernelsThenProgramIsSuccessfullyCreatedWithThoseOptions) {
TEST_F(ClCreateProgramWithBuiltInVmeKernelsTests, GivenValidMediaKernelsWithOptionsWhenCreatingProgramWithBuiltInKernelsThenProgramIsSuccessfullyCreatedWithThoseOptions) {
cl_int retVal = CL_SUCCESS;
overwriteBuiltInBinaryName("media_kernels_frontend");
@@ -187,7 +187,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenValidMediaKernelsWithOpti
clReleaseProgram(program);
}
TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockMotionEstimateKernelWhenCreatingProgramWithBuiltInKernelsThenCorrectDispatchBuilderAndFrontendKernelIsCreated) {
TEST_F(ClCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockMotionEstimateKernelWhenCreatingProgramWithBuiltInKernelsThenCorrectDispatchBuilderAndFrontendKernelIsCreated) {
cl_int retVal = CL_SUCCESS;
overwriteBuiltInBinaryName("media_kernels_backend");
@@ -224,7 +224,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockMotionEstimateKer
clReleaseProgram(program);
}
TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEstimateKernelWhenCreatingProgramWithBuiltInKernelsThenCorrectDispatchBuilderAndFrontendKernelIsCreated) {
TEST_F(ClCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEstimateKernelWhenCreatingProgramWithBuiltInKernelsThenCorrectDispatchBuilderAndFrontendKernelIsCreated) {
cl_int retVal = CL_SUCCESS;
overwriteBuiltInBinaryName("media_kernels_backend");
@@ -261,7 +261,7 @@ TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEst
clReleaseProgram(program);
}
TEST_F(clCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEstimateBidirectionalCheckKernelWhenCreatingProgramWithBuiltInKernelsThenCorrectDispatchBuilderAndFrontendKernelIsCreated) {
TEST_F(ClCreateProgramWithBuiltInVmeKernelsTests, GivenVmeBlockAdvancedMotionEstimateBidirectionalCheckKernelWhenCreatingProgramWithBuiltInKernelsThenCorrectDispatchBuilderAndFrontendKernelIsCreated) {
cl_int retVal = CL_SUCCESS;
overwriteBuiltInBinaryName("media_kernels_backend");

14
opencl/test/unit_test/api/cl_create_sub_buffer_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -41,11 +41,11 @@ class ClCreateSubBufferTemplateTests : public ApiFixture<>,
cl_uchar pHostPtr[64];
};
struct clCreateSubBufferValidFlagsNoHostPtrTests
struct ClCreateSubBufferValidFlagsNoHostPtrTests
: public ClCreateSubBufferTemplateTests<false, CL_MEM_READ_WRITE> {
};
TEST_P(clCreateSubBufferValidFlagsNoHostPtrTests, GivenValidFlagsWhenCreatingSubBufferThenSubBufferIsCreatedAndSuccessIsReturned) {
TEST_P(ClCreateSubBufferValidFlagsNoHostPtrTests, GivenValidFlagsWhenCreatingSubBufferThenSubBufferIsCreatedAndSuccessIsReturned) {
cl_buffer_region region = {0, 12};
cl_mem_flags flags = GetParam();
@@ -68,14 +68,14 @@ static cl_mem_flags validFlags[] = {
INSTANTIATE_TEST_CASE_P(
CreateSubBufferCheckFlags,
clCreateSubBufferValidFlagsNoHostPtrTests,
ClCreateSubBufferValidFlagsNoHostPtrTests,
testing::ValuesIn(validFlags));
struct clCreateSubBufferInvalidFlagsHostPtrTests
struct ClCreateSubBufferInvalidFlagsHostPtrTests
: public ClCreateSubBufferTemplateTests<true, CL_MEM_HOST_NO_ACCESS | CL_MEM_READ_ONLY> {
};
TEST_P(clCreateSubBufferInvalidFlagsHostPtrTests, GivenInvalidFlagsWhenCreatingSubBufferThenInvalidValueErrorIsReturned) {
TEST_P(ClCreateSubBufferInvalidFlagsHostPtrTests, GivenInvalidFlagsWhenCreatingSubBufferThenInvalidValueErrorIsReturned) {
cl_buffer_region region = {4, 12};
cl_mem_flags flags = GetParam();
@@ -98,7 +98,7 @@ cl_mem_flags invalidFlags[] = {
INSTANTIATE_TEST_CASE_P(
CreateSubBufferCheckFlags,
clCreateSubBufferInvalidFlagsHostPtrTests,
ClCreateSubBufferInvalidFlagsHostPtrTests,
testing::ValuesIn(invalidFlags));
class ClCreateSubBufferTests : public api_tests {

30
opencl/test/unit_test/api/cl_create_sub_devices_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -17,7 +17,7 @@ using namespace NEO;
namespace ULT {
struct clCreateSubDevicesTests : ::testing::Test {
struct ClCreateSubDevicesTests : ::testing::Test {
DebugManagerStateRestore restorer;
VariableBackup<bool> mockDeviceCreateSingleDeviceBackup{&MockDevice::createSingleDevice};
std::unique_ptr<MockClDevice> device;
@@ -33,7 +33,7 @@ struct clCreateSubDevicesTests : ::testing::Test {
}
};
TEST_F(clCreateSubDevicesTests, GivenInvalidDeviceWhenCreatingSubDevicesThenInvalidDeviceErrorIsReturned) {
TEST_F(ClCreateSubDevicesTests, GivenInvalidDeviceWhenCreatingSubDevicesThenInvalidDeviceErrorIsReturned) {
auto retVal = clCreateSubDevices(
nullptr,
nullptr,
@@ -43,7 +43,7 @@ TEST_F(clCreateSubDevicesTests, GivenInvalidDeviceWhenCreatingSubDevicesThenInva
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
}
TEST_F(clCreateSubDevicesTests, GivenDeviceWithoutSubDevicesWhenCreatingSubDevicesThenDevicePartitionFailedErrorIsReturned) {
TEST_F(ClCreateSubDevicesTests, GivenDeviceWithoutSubDevicesWhenCreatingSubDevicesThenDevicePartitionFailedErrorIsReturned) {
setup(1);
EXPECT_EQ(0u, device->getNumGenericSubDevices());
@@ -59,7 +59,7 @@ TEST_F(clCreateSubDevicesTests, GivenDeviceWithoutSubDevicesWhenCreatingSubDevic
EXPECT_EQ(CL_DEVICE_PARTITION_FAILED, retVal);
}
TEST_F(clCreateSubDevicesTests, GivenInvalidOrUnsupportedPropertiesWhenCreatingSubDevicesThenInvalidValueErrorIsReturned) {
TEST_F(ClCreateSubDevicesTests, GivenInvalidOrUnsupportedPropertiesWhenCreatingSubDevicesThenInvalidValueErrorIsReturned) {
setup(2);
auto retVal = clCreateSubDevices(device.get(), nullptr, 0, nullptr, nullptr);
@@ -80,7 +80,7 @@ TEST_F(clCreateSubDevicesTests, GivenInvalidOrUnsupportedPropertiesWhenCreatingS
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clCreateSubDevicesTests, GivenOutDevicesNullWhenCreatingSubDevicesThenSuccessIsReturned) {
TEST_F(ClCreateSubDevicesTests, GivenOutDevicesNullWhenCreatingSubDevicesThenSuccessIsReturned) {
setup(2);
cl_uint returnedOutDeviceCount = 0;
@@ -89,7 +89,7 @@ TEST_F(clCreateSubDevicesTests, GivenOutDevicesNullWhenCreatingSubDevicesThenSuc
EXPECT_EQ(2u, returnedOutDeviceCount);
}
TEST_F(clCreateSubDevicesTests, GivenOutDevicesTooSmallWhenCreatingSubDevicesThenInvalidValueErrorIsReturned) {
TEST_F(ClCreateSubDevicesTests, GivenOutDevicesTooSmallWhenCreatingSubDevicesThenInvalidValueErrorIsReturned) {
setup(2);
outDevicesCount = 1;
@@ -97,7 +97,7 @@ TEST_F(clCreateSubDevicesTests, GivenOutDevicesTooSmallWhenCreatingSubDevicesThe
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clCreateSubDevicesTests, GivenValidInputWhenCreatingSubDevicesThenSubDevicesAreReturned) {
TEST_F(ClCreateSubDevicesTests, GivenValidInputWhenCreatingSubDevicesThenSubDevicesAreReturned) {
setup(2);
auto retVal = clCreateSubDevices(device.get(), properties, outDevicesCount, outDevices, nullptr);
@@ -113,7 +113,7 @@ TEST_F(clCreateSubDevicesTests, GivenValidInputWhenCreatingSubDevicesThenSubDevi
EXPECT_EQ(outDevices[1], outDevices2[1]);
}
TEST_F(clCreateSubDevicesTests, GivenValidInputWhenCreatingSubDevicesThenDeviceApiReferenceCountIsIncreasedEveryTime) {
TEST_F(ClCreateSubDevicesTests, GivenValidInputWhenCreatingSubDevicesThenDeviceApiReferenceCountIsIncreasedEveryTime) {
setup(2);
EXPECT_EQ(0, device->getSubDevice(0)->getRefApiCount());
@@ -130,9 +130,9 @@ TEST_F(clCreateSubDevicesTests, GivenValidInputWhenCreatingSubDevicesThenDeviceA
EXPECT_EQ(2, device->getSubDevice(1)->getRefApiCount());
}
struct clCreateSubDevicesDeviceInfoTests : clCreateSubDevicesTests {
struct ClCreateSubDevicesDeviceInfoTests : ClCreateSubDevicesTests {
void setup(int numberOfDevices) {
clCreateSubDevicesTests::setup(numberOfDevices);
ClCreateSubDevicesTests::setup(numberOfDevices);
expectedSubDeviceParentDevice = device.get();
expectedRootDevicePartitionMaxSubDevices = numberOfDevices;
}
@@ -165,7 +165,7 @@ struct clCreateSubDevicesDeviceInfoTests : clCreateSubDevicesTests {
size_t returnValueSize;
};
TEST_F(clCreateSubDevicesDeviceInfoTests, WhenGettingSubDeviceRelatedDeviceInfoThenCorrectValuesAreSet) {
TEST_F(ClCreateSubDevicesDeviceInfoTests, WhenGettingSubDeviceRelatedDeviceInfoThenCorrectValuesAreSet) {
setup(4);
auto &rootDeviceInfo = device->getDeviceInfo();
@@ -211,7 +211,7 @@ TEST_F(clCreateSubDevicesDeviceInfoTests, WhenGettingSubDeviceRelatedDeviceInfoT
}
}
TEST_F(clCreateSubDevicesDeviceInfoTests, GivenRootDeviceWithoutSubDevicesWhenGettingSubDeviceRelatedDeviceInfoThenCorrectValuesAreSet) {
TEST_F(ClCreateSubDevicesDeviceInfoTests, GivenRootDeviceWithoutSubDevicesWhenGettingSubDeviceRelatedDeviceInfoThenCorrectValuesAreSet) {
setup(1);
auto &rootDeviceInfo = device->getDeviceInfo();
@@ -236,7 +236,7 @@ TEST_F(clCreateSubDevicesDeviceInfoTests, GivenRootDeviceWithoutSubDevicesWhenGe
}
}
TEST_F(clCreateSubDevicesDeviceInfoTests, WhenGettingSubDeviceRelatedDeviceInfoViaApiThenCorrectValuesAreSet) {
TEST_F(ClCreateSubDevicesDeviceInfoTests, WhenGettingSubDeviceRelatedDeviceInfoViaApiThenCorrectValuesAreSet) {
setup(4);
size_t partitionPropertiesReturnValueSize = 0;
@@ -347,7 +347,7 @@ TEST_F(clCreateSubDevicesDeviceInfoTests, WhenGettingSubDeviceRelatedDeviceInfoV
}
}
TEST_F(clCreateSubDevicesDeviceInfoTests, GivenRootDeviceWithoutSubDevicesWhenGettingSubDeviceRelatedDeviceInfoViaApiThenCorrectValuesAreSet) {
TEST_F(ClCreateSubDevicesDeviceInfoTests, GivenRootDeviceWithoutSubDevicesWhenGettingSubDeviceRelatedDeviceInfoViaApiThenCorrectValuesAreSet) {
DebugManager.flags.EngineInstancedSubDevices.set(false);
setup(1);

18
opencl/test/unit_test/api/cl_enqueue_copy_buffer_rect_tests.inl
View File

@@ -14,7 +14,7 @@
using namespace NEO;
struct clEnqueueCopyBufferRectTests : public ApiFixture<0>, ::testing::Test {
struct ClEnqueueCopyBufferRectTests : public ApiFixture<0>, ::testing::Test {
void SetUp() override {
ApiFixture::setUp();
}
@@ -25,7 +25,7 @@ struct clEnqueueCopyBufferRectTests : public ApiFixture<0>, ::testing::Test {
namespace ULT {
TEST_F(clEnqueueCopyBufferRectTests, GivenCorrectParametersWhenEnqueingCopyBufferRectThenSuccessIsReturned) {
TEST_F(ClEnqueueCopyBufferRectTests, GivenCorrectParametersWhenEnqueingCopyBufferRectThenSuccessIsReturned) {
MockBuffer srcBuffer;
MockBuffer dstBuffer;
size_t srcOrigin[] = {0, 0, 0};
@@ -50,7 +50,7 @@ TEST_F(clEnqueueCopyBufferRectTests, GivenCorrectParametersWhenEnqueingCopyBuffe
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueCopyBufferRectTests, GivenNullCommandQueueWhenEnqueingCopyBufferRectThenInvalidCommandQueueErrorIsReturned) {
TEST_F(ClEnqueueCopyBufferRectTests, GivenNullCommandQueueWhenEnqueingCopyBufferRectThenInvalidCommandQueueErrorIsReturned) {
auto retVal = clEnqueueCopyBufferRect(
nullptr, // command_queue
nullptr, // srcBuffer
@@ -69,7 +69,7 @@ TEST_F(clEnqueueCopyBufferRectTests, GivenNullCommandQueueWhenEnqueingCopyBuffer
EXPECT_EQ(CL_INVALID_COMMAND_QUEUE, retVal);
}
TEST_F(clEnqueueCopyBufferRectTests, GivenQueueIncapableWhenEnqueingCopyBufferRectThenInvalidOperationIsReturned) {
TEST_F(ClEnqueueCopyBufferRectTests, GivenQueueIncapableWhenEnqueingCopyBufferRectThenInvalidOperationIsReturned) {
MockBuffer srcBuffer;
MockBuffer dstBuffer;
size_t srcOrigin[] = {0, 0, 0};
@@ -95,7 +95,7 @@ TEST_F(clEnqueueCopyBufferRectTests, GivenQueueIncapableWhenEnqueingCopyBufferRe
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
}
TEST_F(clEnqueueCopyBufferRectTests, givenPitchesEqualZeroAndZerosInRegionWhenCallClEnqueueCopyBufferRectThenClInvalidValueIsReturned) {
TEST_F(ClEnqueueCopyBufferRectTests, givenPitchesEqualZeroAndZerosInRegionWhenCallClEnqueueCopyBufferRectThenClInvalidValueIsReturned) {
MockBuffer srcBuffer;
MockBuffer dstBuffer;
size_t srcOrigin[] = {0, 0, 0};
@@ -120,7 +120,7 @@ TEST_F(clEnqueueCopyBufferRectTests, givenPitchesEqualZeroAndZerosInRegionWhenCa
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clEnqueueCopyBufferRectTests, givenZeroInRegionWhenCallClEnqueueCopyBufferRectThenClInvalidValueIsReturned) {
TEST_F(ClEnqueueCopyBufferRectTests, givenZeroInRegionWhenCallClEnqueueCopyBufferRectThenClInvalidValueIsReturned) {
MockBuffer srcBuffer;
MockBuffer dstBuffer;
size_t srcOrigin[] = {0, 0, 0};
@@ -200,7 +200,7 @@ TEST_F(clEnqueueCopyBufferRectTests, givenZeroInRegionWhenCallClEnqueueCopyBuffe
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clEnqueueCopyBufferRectTests, givenNonProperSrcBufferSizeWhenCallClEnqueueCopyBufferRectThenClInvalidValueIsReturned) {
TEST_F(ClEnqueueCopyBufferRectTests, givenNonProperSrcBufferSizeWhenCallClEnqueueCopyBufferRectThenClInvalidValueIsReturned) {
MockBuffer srcBuffer;
srcBuffer.size = 10;
MockBuffer dstBuffer;
@@ -226,7 +226,7 @@ TEST_F(clEnqueueCopyBufferRectTests, givenNonProperSrcBufferSizeWhenCallClEnqueu
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clEnqueueCopyBufferRectTests, givenNonProperDstBufferSizeWhenCallClEnqueueCopyBufferRectThenClInvalidValueIsReturned) {
TEST_F(ClEnqueueCopyBufferRectTests, givenNonProperDstBufferSizeWhenCallClEnqueueCopyBufferRectThenClInvalidValueIsReturned) {
MockBuffer srcBuffer;
MockBuffer dstBuffer;
dstBuffer.size = 10;
@@ -252,7 +252,7 @@ TEST_F(clEnqueueCopyBufferRectTests, givenNonProperDstBufferSizeWhenCallClEnqueu
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clEnqueueCopyBufferRectTests, givenPitchesEqualZeroAndNotZeroRegionWhenCallClEnqueueCopyBufferRectThenPitchIsSetBasedOnRegionAndClSuccessIsReturned) {
TEST_F(ClEnqueueCopyBufferRectTests, givenPitchesEqualZeroAndNotZeroRegionWhenCallClEnqueueCopyBufferRectThenPitchIsSetBasedOnRegionAndClSuccessIsReturned) {
class CommandQueueMock : public MockCommandQueue {
public:
CommandQueueMock(Context *context, ClDevice *device, const cl_queue_properties *props) : MockCommandQueue(context, device, props, false) {}

20
opencl/test/unit_test/api/cl_enqueue_copy_buffer_to_image_tests.inl
View File

@@ -14,11 +14,11 @@
using namespace NEO;
typedef api_tests clEnqueueCopyBufferToImageTests;
typedef api_tests ClEnqueueCopyBufferToImageTests;
namespace ULT {
struct clEnqueueCopyBufferToImageTests : public ApiFixture<>,
struct ClEnqueueCopyBufferToImageTests : public ApiFixture<>,
public ::testing::Test {
void SetUp() override {
ApiFixture::setUp();
@@ -48,7 +48,7 @@ struct clEnqueueCopyBufferToImageTests : public ApiFixture<>,
cl_image_desc imageDesc;
};
TEST_F(clEnqueueCopyBufferToImageTests, GivenInvalidCmdQueueWhenCopyingBufferToImageThenInvalidCommandQueueErrorIsReturned) {
TEST_F(ClEnqueueCopyBufferToImageTests, GivenInvalidCmdQueueWhenCopyingBufferToImageThenInvalidCommandQueueErrorIsReturned) {
size_t dstOrigin[] = {0, 0, 0};
size_t region[] = {10, 10, 0};
@@ -66,7 +66,7 @@ TEST_F(clEnqueueCopyBufferToImageTests, GivenInvalidCmdQueueWhenCopyingBufferToI
EXPECT_EQ(CL_INVALID_COMMAND_QUEUE, retVal);
}
TEST_F(clEnqueueCopyBufferToImageTests, GivenInvalidSrcBufferWhenCopyingBufferToImageThenInvalidMemObjectErrorIsReturned) {
TEST_F(ClEnqueueCopyBufferToImageTests, GivenInvalidSrcBufferWhenCopyingBufferToImageThenInvalidMemObjectErrorIsReturned) {
size_t dstOrigin[] = {0, 0, 0};
size_t region[] = {10, 10, 0};
@@ -84,7 +84,7 @@ TEST_F(clEnqueueCopyBufferToImageTests, GivenInvalidSrcBufferWhenCopyingBufferTo
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clEnqueueCopyBufferToImageTests, GivenValidParametersWhenCopyingBufferToImageThenSuccessIsReturned) {
TEST_F(ClEnqueueCopyBufferToImageTests, GivenValidParametersWhenCopyingBufferToImageThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
cl_mem dstImage = ImageFunctions::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc,
@@ -111,7 +111,7 @@ TEST_F(clEnqueueCopyBufferToImageTests, GivenValidParametersWhenCopyingBufferToI
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueCopyBufferToImageTests, GivenQueueIncapableWhenCopyingBufferToImageThenInvalidOperationIsReturned) {
TEST_F(ClEnqueueCopyBufferToImageTests, GivenQueueIncapableWhenCopyingBufferToImageThenInvalidOperationIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
cl_mem dstImage = ImageFunctions::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc,
@@ -139,9 +139,9 @@ TEST_F(clEnqueueCopyBufferToImageTests, GivenQueueIncapableWhenCopyingBufferToIm
EXPECT_EQ(CL_SUCCESS, retVal);
}
typedef clEnqueueCopyBufferToImageTests clEnqueueCopyBufferToImageYUV;
typedef ClEnqueueCopyBufferToImageTests ClEnqueueCopyBufferToImageYUV;
TEST_F(clEnqueueCopyBufferToImageYUV, GivenValidYuvDstImageWhenCopyingBufferToImageThenSuccessIsReturned) {
TEST_F(ClEnqueueCopyBufferToImageYUV, GivenValidYuvDstImageWhenCopyingBufferToImageThenSuccessIsReturned) {
auto srcBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -164,7 +164,7 @@ TEST_F(clEnqueueCopyBufferToImageYUV, GivenValidYuvDstImageWhenCopyingBufferToIm
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueCopyBufferToImageYUV, GivenInvalidOriginAndYuvDstImageWhenCopyingBufferToImageThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueCopyBufferToImageYUV, GivenInvalidOriginAndYuvDstImageWhenCopyingBufferToImageThenInvalidValueErrorIsReturned) {
auto srcBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -187,7 +187,7 @@ TEST_F(clEnqueueCopyBufferToImageYUV, GivenInvalidOriginAndYuvDstImageWhenCopyin
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueCopyBufferToImageYUV, GivenInvalidRegionAndValidYuvDstImageWhenCopyingBufferToImageThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueCopyBufferToImageYUV, GivenInvalidRegionAndValidYuvDstImageWhenCopyingBufferToImageThenInvalidValueErrorIsReturned) {
auto srcBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);

28
opencl/test/unit_test/api/cl_enqueue_copy_image_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -15,11 +15,11 @@
using namespace NEO;
typedef api_tests clEnqueueCopyImageTests;
typedef api_tests ClEnqueueCopyImageTests;
namespace ULT {
struct clEnqueueCopyImageTests : public ApiFixture<>,
struct ClEnqueueCopyImageTests : public ApiFixture<>,
public ::testing::Test {
void SetUp() override {
ApiFixture::setUp();
@@ -49,7 +49,7 @@ struct clEnqueueCopyImageTests : public ApiFixture<>,
cl_image_desc imageDesc;
};
TEST_F(clEnqueueCopyImageTests, GivenNullCommandQueueWhenCopyingImageThenInvalidCommandQueueErrorIsReturned) {
TEST_F(ClEnqueueCopyImageTests, GivenNullCommandQueueWhenCopyingImageThenInvalidCommandQueueErrorIsReturned) {
auto buffer = (cl_mem)ptrGarbage;
retVal = clEnqueueCopyImage(
@@ -65,7 +65,7 @@ TEST_F(clEnqueueCopyImageTests, GivenNullCommandQueueWhenCopyingImageThenInvalid
EXPECT_EQ(CL_INVALID_COMMAND_QUEUE, retVal);
}
TEST_F(clEnqueueCopyImageTests, GivenNullSrcBufferWhenCopyingImageThenInvalidMemObjectErrorIsReturned) {
TEST_F(ClEnqueueCopyImageTests, GivenNullSrcBufferWhenCopyingImageThenInvalidMemObjectErrorIsReturned) {
auto buffer = (cl_mem)ptrGarbage;
retVal = clEnqueueCopyImage(
@@ -81,7 +81,7 @@ TEST_F(clEnqueueCopyImageTests, GivenNullSrcBufferWhenCopyingImageThenInvalidMem
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clEnqueueCopyImageTests, GivenNullDstBufferWhenCopyingImageThenInvalidMemObjectErrorIsReturned) {
TEST_F(ClEnqueueCopyImageTests, GivenNullDstBufferWhenCopyingImageThenInvalidMemObjectErrorIsReturned) {
auto buffer = (cl_mem)ptrGarbage;
retVal = clEnqueueCopyImage(
@@ -97,7 +97,7 @@ TEST_F(clEnqueueCopyImageTests, GivenNullDstBufferWhenCopyingImageThenInvalidMem
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clEnqueueCopyImageTests, GivenDifferentSrcAndDstImageFormatsWhenCopyingImageThenImageFormatMismatchErrorIsReturned) {
TEST_F(ClEnqueueCopyImageTests, GivenDifferentSrcAndDstImageFormatsWhenCopyingImageThenImageFormatMismatchErrorIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
imageFormat.image_channel_order = CL_BGRA;
@@ -125,7 +125,7 @@ TEST_F(clEnqueueCopyImageTests, GivenDifferentSrcAndDstImageFormatsWhenCopyingIm
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueCopyImageTests, GivenValidParametersWhenCopyingImageThenSuccessIsReturned) {
TEST_F(ClEnqueueCopyImageTests, GivenValidParametersWhenCopyingImageThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
@@ -152,7 +152,7 @@ TEST_F(clEnqueueCopyImageTests, GivenValidParametersWhenCopyingImageThenSuccessI
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueCopyImageTests, GivenQueueIncapableWhenCopyingImageThenInvalidOperationIsReturned) {
TEST_F(ClEnqueueCopyImageTests, GivenQueueIncapableWhenCopyingImageThenInvalidOperationIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
@@ -177,9 +177,9 @@ TEST_F(clEnqueueCopyImageTests, GivenQueueIncapableWhenCopyingImageThenInvalidOp
EXPECT_EQ(CL_SUCCESS, retVal);
}
typedef clEnqueueCopyImageTests clEnqueueCopyImageYUVTests;
typedef ClEnqueueCopyImageTests ClEnqueueCopyImageYUVTests;
TEST_F(clEnqueueCopyImageYUVTests, GivenValidParametersWhenCopyingYuvImageThenSuccessIsReturned) {
TEST_F(ClEnqueueCopyImageYUVTests, GivenValidParametersWhenCopyingYuvImageThenSuccessIsReturned) {
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -205,7 +205,7 @@ TEST_F(clEnqueueCopyImageYUVTests, GivenValidParametersWhenCopyingYuvImageThenSu
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidSrcOriginWhenCopyingYuvImageThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueCopyImageYUVTests, GivenInvalidSrcOriginWhenCopyingYuvImageThenInvalidValueErrorIsReturned) {
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -232,7 +232,7 @@ TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidSrcOriginWhenCopyingYuvImageThenI
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidDstOriginWhenCopyingYuvImageThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueCopyImageYUVTests, GivenInvalidDstOriginWhenCopyingYuvImageThenInvalidValueErrorIsReturned) {
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -259,7 +259,7 @@ TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidDstOriginWhenCopyingYuvImageThenI
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueCopyImageYUVTests, GivenInvalidDstOriginFor2dImageWhenCopyingYuvImageThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueCopyImageYUVTests, GivenInvalidDstOriginFor2dImageWhenCopyingYuvImageThenInvalidValueErrorIsReturned) {
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
auto dstImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);

20
opencl/test/unit_test/api/cl_enqueue_copy_image_to_buffer_tests.inl
View File

@@ -13,11 +13,11 @@
using namespace NEO;
typedef api_tests clEnqueueCopyImageToBufferTests;
typedef api_tests ClEnqueueCopyImageToBufferTests;
namespace ULT {
struct clEnqueueCopyImageToBufferTests : public ApiFixture<>,
struct ClEnqueueCopyImageToBufferTests : public ApiFixture<>,
public ::testing::Test {
void SetUp() override {
ApiFixture::setUp();
@@ -47,7 +47,7 @@ struct clEnqueueCopyImageToBufferTests : public ApiFixture<>,
cl_image_desc imageDesc;
};
TEST_F(clEnqueueCopyImageToBufferTests, GivenInvalidQueueWhenCopyingImageToBufferThenInvalidCommandQueueErrorIsReturned) {
TEST_F(ClEnqueueCopyImageToBufferTests, GivenInvalidQueueWhenCopyingImageToBufferThenInvalidCommandQueueErrorIsReturned) {
size_t srcOrigin[] = {0, 0, 0};
size_t region[] = {10, 10, 0};
@@ -65,7 +65,7 @@ TEST_F(clEnqueueCopyImageToBufferTests, GivenInvalidQueueWhenCopyingImageToBuffe
EXPECT_EQ(CL_INVALID_COMMAND_QUEUE, retVal);
}
TEST_F(clEnqueueCopyImageToBufferTests, GivenInvalidBufferWhenCopyingImageToBufferThenInvalidMemObjectErrorIsReturned) {
TEST_F(ClEnqueueCopyImageToBufferTests, GivenInvalidBufferWhenCopyingImageToBufferThenInvalidMemObjectErrorIsReturned) {
size_t srcOrigin[] = {0, 0, 0};
size_t region[] = {10, 10, 0};
@@ -83,7 +83,7 @@ TEST_F(clEnqueueCopyImageToBufferTests, GivenInvalidBufferWhenCopyingImageToBuff
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clEnqueueCopyImageToBufferTests, GivenValidParametersWhenCopyingImageToBufferThenSuccessIsReturned) {
TEST_F(ClEnqueueCopyImageToBufferTests, GivenValidParametersWhenCopyingImageToBufferThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
@@ -109,7 +109,7 @@ TEST_F(clEnqueueCopyImageToBufferTests, GivenValidParametersWhenCopyingImageToBu
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueCopyImageToBufferTests, GivenQueueIncapableWhenCopyingImageToBufferThenInvalidOperationIsReturned) {
TEST_F(ClEnqueueCopyImageToBufferTests, GivenQueueIncapableWhenCopyingImageToBufferThenInvalidOperationIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -134,9 +134,9 @@ TEST_F(clEnqueueCopyImageToBufferTests, GivenQueueIncapableWhenCopyingImageToBuf
EXPECT_EQ(CL_SUCCESS, retVal);
}
typedef clEnqueueCopyImageToBufferTests clEnqueueCopyImageToBufferYUVTests;
typedef ClEnqueueCopyImageToBufferTests ClEnqueueCopyImageToBufferYUVTests;
TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenValidParametersWhenCopyingYuvImageToBufferThenSuccessIsReturned) {
TEST_F(ClEnqueueCopyImageToBufferYUVTests, GivenValidParametersWhenCopyingYuvImageToBufferThenSuccessIsReturned) {
auto dstBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -159,7 +159,7 @@ TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenValidParametersWhenCopyingYuvIma
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenInvalidOriginWhenCopyingYuvImageToBufferThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueCopyImageToBufferYUVTests, GivenInvalidOriginWhenCopyingYuvImageToBufferThenInvalidValueErrorIsReturned) {
auto dstBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -182,7 +182,7 @@ TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenInvalidOriginWhenCopyingYuvImage
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueCopyImageToBufferYUVTests, GivenInvalidRegionWhenCopyingYuvImageToBufferThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueCopyImageToBufferYUVTests, GivenInvalidRegionWhenCopyingYuvImageToBufferThenInvalidValueErrorIsReturned) {
auto dstBuffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
auto srcImage = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);

16
opencl/test/unit_test/api/cl_enqueue_map_image_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -16,7 +16,7 @@ using namespace NEO;
namespace ULT {
struct clEnqueueMapImageTests : public ApiFixture<>,
struct ClEnqueueMapImageTests : public ApiFixture<>,
public ::testing::Test {
void SetUp() override {
@@ -47,7 +47,7 @@ struct clEnqueueMapImageTests : public ApiFixture<>,
cl_image_desc imageDesc;
};
TEST_F(clEnqueueMapImageTests, GivenValidParametersWhenMappingImageThenSuccessIsReturned) {
TEST_F(ClEnqueueMapImageTests, GivenValidParametersWhenMappingImageThenSuccessIsReturned) {
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
@@ -74,7 +74,7 @@ TEST_F(clEnqueueMapImageTests, GivenValidParametersWhenMappingImageThenSuccessIs
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueMapImageTests, GivenQueueIncapableWhenMappingImageThenInvalidOperationIsReturned) {
TEST_F(ClEnqueueMapImageTests, GivenQueueIncapableWhenMappingImageThenInvalidOperationIsReturned) {
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
@@ -102,7 +102,7 @@ TEST_F(clEnqueueMapImageTests, GivenQueueIncapableWhenMappingImageThenInvalidOpe
EXPECT_EQ(CL_SUCCESS, retVal);
}
struct clEnqueueMapImageYUVTests : public ApiFixture<>,
struct ClEnqueueMapImageYUVTests : public ApiFixture<>,
public ::testing::Test {
void SetUp() override {
@@ -133,7 +133,7 @@ struct clEnqueueMapImageYUVTests : public ApiFixture<>,
cl_image_desc imageDesc;
};
TEST_F(clEnqueueMapImageYUVTests, GivenValidYuvImageWhenMappingImageThenSuccessIsReturned) {
TEST_F(ClEnqueueMapImageYUVTests, GivenValidYuvImageWhenMappingImageThenSuccessIsReturned) {
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
@@ -158,7 +158,7 @@ TEST_F(clEnqueueMapImageYUVTests, GivenValidYuvImageWhenMappingImageThenSuccessI
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueMapImageYUVTests, GivenInvalidOriginWhenMappingYuvImageThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueMapImageYUVTests, GivenInvalidOriginWhenMappingYuvImageThenInvalidValueErrorIsReturned) {
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
@@ -183,7 +183,7 @@ TEST_F(clEnqueueMapImageYUVTests, GivenInvalidOriginWhenMappingYuvImageThenInval
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueMapImageYUVTests, GivenInvalidRegionWhenMappingYuvImageThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueMapImageYUVTests, GivenInvalidRegionWhenMappingYuvImageThenInvalidValueErrorIsReturned) {
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);

22
opencl/test/unit_test/api/cl_enqueue_read_image_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -14,11 +14,11 @@
using namespace NEO;
typedef api_tests clEnqueueReadImageTests;
typedef api_tests ClEnqueueReadImageTests;
namespace ULT {
struct clEnqueueReadImageTests : public ApiFixture<>,
struct ClEnqueueReadImageTests : public ApiFixture<>,
public ::testing::Test {
void SetUp() override {
ApiFixture::setUp();
@@ -48,7 +48,7 @@ struct clEnqueueReadImageTests : public ApiFixture<>,
cl_image_desc imageDesc;
};
TEST_F(clEnqueueReadImageTests, GivenNullCommandQueueWhenReadingImageThenInvalidCommandQueueErrorIsReturned) {
TEST_F(ClEnqueueReadImageTests, GivenNullCommandQueueWhenReadingImageThenInvalidCommandQueueErrorIsReturned) {
auto retVal = clEnqueueReadImage(
nullptr,
nullptr,
@@ -65,7 +65,7 @@ TEST_F(clEnqueueReadImageTests, GivenNullCommandQueueWhenReadingImageThenInvalid
EXPECT_EQ(CL_INVALID_COMMAND_QUEUE, retVal);
}
TEST_F(clEnqueueReadImageTests, GivenNullImageWhenReadingImageThenInvalidMemObjectErrorIsReturned) {
TEST_F(ClEnqueueReadImageTests, GivenNullImageWhenReadingImageThenInvalidMemObjectErrorIsReturned) {
auto retVal = clEnqueueReadImage(
pCommandQueue,
nullptr,
@@ -82,7 +82,7 @@ TEST_F(clEnqueueReadImageTests, GivenNullImageWhenReadingImageThenInvalidMemObje
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clEnqueueReadImageTests, GivenValidParametersWhenReadinImagesThenSuccessIsReturned) {
TEST_F(ClEnqueueReadImageTests, GivenValidParametersWhenReadinImagesThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -107,7 +107,7 @@ TEST_F(clEnqueueReadImageTests, GivenValidParametersWhenReadinImagesThenSuccessI
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueReadImageTests, GivenQueueIncapableParametersWhenReadingImageThenInvalidOperationIsReturned) {
TEST_F(ClEnqueueReadImageTests, GivenQueueIncapableParametersWhenReadingImageThenInvalidOperationIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
const size_t origin[] = {2, 2, 0};
@@ -132,9 +132,9 @@ TEST_F(clEnqueueReadImageTests, GivenQueueIncapableParametersWhenReadingImageThe
EXPECT_EQ(CL_SUCCESS, retVal);
}
typedef clEnqueueReadImageTests clEnqueueReadImageYuv;
typedef ClEnqueueReadImageTests ClEnqueueReadImageYuv;
TEST_F(clEnqueueReadImageYuv, GivenValidYuvImageWhenReadingImageThenSuccessIsReturned) {
TEST_F(ClEnqueueReadImageYuv, GivenValidYuvImageWhenReadingImageThenSuccessIsReturned) {
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
@@ -158,7 +158,7 @@ TEST_F(clEnqueueReadImageYuv, GivenValidYuvImageWhenReadingImageThenSuccessIsRet
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueReadImageYuv, GivenInvalidOriginWhenReadingYuvImageThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueReadImageYuv, GivenInvalidOriginWhenReadingYuvImageThenInvalidValueErrorIsReturned) {
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
@@ -182,7 +182,7 @@ TEST_F(clEnqueueReadImageYuv, GivenInvalidOriginWhenReadingYuvImageThenInvalidVa
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueReadImageYuv, GivenInvalidRegionWhenReadingYuvImageThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueReadImageYuv, GivenInvalidRegionWhenReadingYuvImageThenInvalidValueErrorIsReturned) {
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);

24
opencl/test/unit_test/api/cl_enqueue_unmap_mem_object_tests.inl
View File

@@ -15,9 +15,9 @@
using namespace NEO;
typedef api_tests clEnqueueUnmapMemObjTests;
typedef api_tests ClEnqueueUnmapMemObjTests;
TEST_F(clEnqueueUnmapMemObjTests, givenValidAddressWhenUnmappingThenReturnSuccess) {
TEST_F(ClEnqueueUnmapMemObjTests, givenValidAddressWhenUnmappingThenReturnSuccess) {
auto buffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
cl_int retVal = CL_SUCCESS;
@@ -34,7 +34,7 @@ TEST_F(clEnqueueUnmapMemObjTests, givenValidAddressWhenUnmappingThenReturnSucces
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueUnmapMemObjTests, GivenQueueIncapableWhenUnmappingBufferThenInvalidOperationIsReturned) {
TEST_F(ClEnqueueUnmapMemObjTests, GivenQueueIncapableWhenUnmappingBufferThenInvalidOperationIsReturned) {
auto buffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
cl_int retVal = CL_SUCCESS;
@@ -52,7 +52,7 @@ TEST_F(clEnqueueUnmapMemObjTests, GivenQueueIncapableWhenUnmappingBufferThenInva
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
}
TEST_F(clEnqueueUnmapMemObjTests, givenInvalidAddressWhenUnmappingOnCpuThenReturnError) {
TEST_F(ClEnqueueUnmapMemObjTests, givenInvalidAddressWhenUnmappingOnCpuThenReturnError) {
auto buffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
EXPECT_TRUE(buffer->mappingOnCpuAllowed());
cl_int retVal = CL_SUCCESS;
@@ -70,7 +70,7 @@ TEST_F(clEnqueueUnmapMemObjTests, givenInvalidAddressWhenUnmappingOnCpuThenRetur
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clEnqueueUnmapMemObjTests, givenInvalidAddressWhenUnmappingOnGpuThenReturnError) {
TEST_F(ClEnqueueUnmapMemObjTests, givenInvalidAddressWhenUnmappingOnGpuThenReturnError) {
auto buffer = std::unique_ptr<Buffer>(BufferHelper<BufferUseHostPtr<>>::create(pContext));
buffer->setSharingHandler(new SharingHandler());
EXPECT_FALSE(buffer->mappingOnCpuAllowed());
@@ -89,7 +89,7 @@ TEST_F(clEnqueueUnmapMemObjTests, givenInvalidAddressWhenUnmappingOnGpuThenRetur
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clEnqueueUnmapMemObjTests, GivenInvalidMemObjectTypeWhenUnmappingImageThenInvalidMemObjectIsReturned) {
TEST_F(ClEnqueueUnmapMemObjTests, GivenInvalidMemObjectTypeWhenUnmappingImageThenInvalidMemObjectIsReturned) {
MockContext context{};
MockGraphicsAllocation allocation{};
MockBuffer buffer{&context, allocation};
@@ -109,10 +109,10 @@ TEST_F(clEnqueueUnmapMemObjTests, GivenInvalidMemObjectTypeWhenUnmappingImageThe
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
struct clEnqueueUnmapImageTests : clEnqueueUnmapMemObjTests,
struct ClEnqueueUnmapImageTests : ClEnqueueUnmapMemObjTests,
::testing::WithParamInterface<uint32_t> {
void SetUp() override {
clEnqueueUnmapMemObjTests::SetUp();
ClEnqueueUnmapMemObjTests::SetUp();
const auto imageType = static_cast<cl_mem_object_type>(GetParam());
this->image.reset(createImage(imageType));
EXPECT_NE(nullptr, image.get());
@@ -145,7 +145,7 @@ struct clEnqueueUnmapImageTests : clEnqueueUnmapMemObjTests,
size_t imageSlicePitch = 0;
};
TEST_P(clEnqueueUnmapImageTests, GivenValidParametersWhenUnmappingImageThenSuccessIsReturned) {
TEST_P(ClEnqueueUnmapImageTests, GivenValidParametersWhenUnmappingImageThenSuccessIsReturned) {
void *mappedImage = clEnqueueMapImage(
pCommandQueue,
image.get(),
@@ -171,7 +171,7 @@ TEST_P(clEnqueueUnmapImageTests, GivenValidParametersWhenUnmappingImageThenSucce
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_P(clEnqueueUnmapImageTests, GivenQueueIncapableParametersWhenUnmappingImageThenInvalidOperationIsReturned) {
TEST_P(ClEnqueueUnmapImageTests, GivenQueueIncapableParametersWhenUnmappingImageThenInvalidOperationIsReturned) {
void *mappedImage = clEnqueueMapImage(
pCommandQueue,
image.get(),
@@ -199,8 +199,8 @@ TEST_P(clEnqueueUnmapImageTests, GivenQueueIncapableParametersWhenUnmappingImage
}
INSTANTIATE_TEST_SUITE_P(
clEnqueueUnmapImageTests,
clEnqueueUnmapImageTests,
ClEnqueueUnmapImageTests,
ClEnqueueUnmapImageTests,
::testing::Values(
CL_MEM_OBJECT_IMAGE2D,
CL_MEM_OBJECT_IMAGE3D,

4
opencl/test/unit_test/api/cl_enqueue_verify_memory.inl
View File

@@ -23,7 +23,7 @@ TEST(CheckVerifyMemoryRelatedApiConstants, givenVerifyMemoryRelatedApiConstantsW
EXPECT_EQ(AubMemDump::CmdServicesMemTraceMemoryCompare::CompareOperationValues::CompareNotEqual, CL_MEM_COMPARE_NOT_EQUAL);
}
struct clEnqueueVerifyMemoryINTELSettings {
struct ClEnqueueVerifyMemoryINTELSettings {
const cl_uint comparisonMode = CL_MEM_COMPARE_EQUAL;
const size_t bufferSize = 1;
static constexpr size_t expectedSize = 1;
@@ -32,7 +32,7 @@ struct clEnqueueVerifyMemoryINTELSettings {
};
class ClEnqueueVerifyMemoryIntelTests : public api_tests,
public clEnqueueVerifyMemoryINTELSettings {
public ClEnqueueVerifyMemoryINTELSettings {
};
TEST_F(ClEnqueueVerifyMemoryIntelTests, givenSizeOfComparisonEqualZeroWhenCallingVerifyMemoryThenErrorIsReturned) {

22
opencl/test/unit_test/api/cl_enqueue_write_image_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -14,11 +14,11 @@
using namespace NEO;
typedef api_tests clEnqueueWriteImageTests;
typedef api_tests ClEnqueueWriteImageTests;
namespace ULT {
struct clEnqueueWriteImageTests : public ApiFixture<>,
struct ClEnqueueWriteImageTests : public ApiFixture<>,
public ::testing::Test {
void SetUp() override {
ApiFixture::setUp();
@@ -48,7 +48,7 @@ struct clEnqueueWriteImageTests : public ApiFixture<>,
cl_image_desc imageDesc;
};
TEST_F(clEnqueueWriteImageTests, GivenNullCommandQueueWhenWritingImageThenInvalidCommandQueueErrorIsReturned) {
TEST_F(ClEnqueueWriteImageTests, GivenNullCommandQueueWhenWritingImageThenInvalidCommandQueueErrorIsReturned) {
auto retVal = clEnqueueWriteImage(
nullptr,
nullptr,
@@ -65,7 +65,7 @@ TEST_F(clEnqueueWriteImageTests, GivenNullCommandQueueWhenWritingImageThenInvali
EXPECT_EQ(CL_INVALID_COMMAND_QUEUE, retVal);
}
TEST_F(clEnqueueWriteImageTests, GivenNullImageWhenWritingImageThenInvalidMemObjectErrorIsReturned) {
TEST_F(ClEnqueueWriteImageTests, GivenNullImageWhenWritingImageThenInvalidMemObjectErrorIsReturned) {
auto retVal = clEnqueueWriteImage(
pCommandQueue,
nullptr,
@@ -82,7 +82,7 @@ TEST_F(clEnqueueWriteImageTests, GivenNullImageWhenWritingImageThenInvalidMemObj
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clEnqueueWriteImageTests, GivenValidParametersWhenWritingImageThenSuccessIsReturned) {
TEST_F(ClEnqueueWriteImageTests, GivenValidParametersWhenWritingImageThenSuccessIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
@@ -107,7 +107,7 @@ TEST_F(clEnqueueWriteImageTests, GivenValidParametersWhenWritingImageThenSuccess
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueReadImageTests, GivenQueueIncapableParametersWhenWritingImageThenInvalidOperationIsReturned) {
TEST_F(ClEnqueueReadImageTests, GivenQueueIncapableParametersWhenWritingImageThenInvalidOperationIsReturned) {
imageFormat.image_channel_order = CL_RGBA;
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
const size_t origin[] = {2, 2, 0};
@@ -132,9 +132,9 @@ TEST_F(clEnqueueReadImageTests, GivenQueueIncapableParametersWhenWritingImageThe
EXPECT_EQ(CL_SUCCESS, retVal);
}
typedef clEnqueueWriteImageTests clEnqueueWriteImageYUV;
typedef ClEnqueueWriteImageTests ClEnqueueWriteImageYUV;
TEST_F(clEnqueueWriteImageYUV, GivenValidParametersWhenWritingYuvImageThenSuccessIsReturned) {
TEST_F(ClEnqueueWriteImageYUV, GivenValidParametersWhenWritingYuvImageThenSuccessIsReturned) {
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
@@ -158,7 +158,7 @@ TEST_F(clEnqueueWriteImageYUV, GivenValidParametersWhenWritingYuvImageThenSucces
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueWriteImageYUV, GivenInvalidOriginWhenWritingYuvImageThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueWriteImageYUV, GivenInvalidOriginWhenWritingYuvImageThenInvalidValueErrorIsReturned) {
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
@@ -181,7 +181,7 @@ TEST_F(clEnqueueWriteImageYUV, GivenInvalidOriginWhenWritingYuvImageThenInvalidV
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clEnqueueWriteImageYUV, GivenInvalidRegionWhenWritingYuvImageThenInvalidValueErrorIsReturned) {
TEST_F(ClEnqueueWriteImageYUV, GivenInvalidRegionWhenWritingYuvImageThenInvalidValueErrorIsReturned) {
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);

42
opencl/test/unit_test/api/cl_get_image_info_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -14,7 +14,7 @@ using namespace NEO;
namespace ULT {
struct clGetImageInfoTests : public ApiFixture<>,
struct ClGetImageInfoTests : public ApiFixture<>,
public ::testing::Test {
void SetUp() override {
@@ -52,7 +52,7 @@ struct clGetImageInfoTests : public ApiFixture<>,
cl_mem image;
};
TEST_F(clGetImageInfoTests, GivenBufferWhenGettingImageInfoThenInvalidMemObjectErrorIsReturned) {
TEST_F(ClGetImageInfoTests, GivenBufferWhenGettingImageInfoThenInvalidMemObjectErrorIsReturned) {
size_t paramRetSize = 0;
auto buffer = clCreateBuffer(pContext, CL_MEM_READ_WRITE, 42, nullptr, &retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
@@ -62,14 +62,14 @@ TEST_F(clGetImageInfoTests, GivenBufferWhenGettingImageInfoThenInvalidMemObjectE
clReleaseMemObject(buffer);
}
TEST_F(clGetImageInfoTests, GivenNullWhenGettingImageInfoThenInvalidMemObjectErrorIsReturned) {
TEST_F(ClGetImageInfoTests, GivenNullWhenGettingImageInfoThenInvalidMemObjectErrorIsReturned) {
size_t paramRetSize = 0;
retVal = clGetImageInfo(nullptr, CL_IMAGE_ELEMENT_SIZE, 0, nullptr, &paramRetSize);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clGetImageInfoTests, GivenInvalidParamNameWhenGettingImageInfoThenInvalidValueErrorIsReturned) {
TEST_F(ClGetImageInfoTests, GivenInvalidParamNameWhenGettingImageInfoThenInvalidValueErrorIsReturned) {
size_t paramRetSize = 0;
retVal = clGetImageInfo(image, CL_MEM_SIZE, 0, nullptr, &paramRetSize);
@@ -77,7 +77,7 @@ TEST_F(clGetImageInfoTests, GivenInvalidParamNameWhenGettingImageInfoThenInvalid
ASSERT_EQ(0u, paramRetSize);
}
TEST_F(clGetImageInfoTests, GivenInvalidParametersWhenGettingImageInfoThenValueSizeRetIsNotUpdated) {
TEST_F(ClGetImageInfoTests, GivenInvalidParametersWhenGettingImageInfoThenValueSizeRetIsNotUpdated) {
size_t paramRetSize = 0x1234;
retVal = clGetImageInfo(image, CL_MEM_SIZE, 0, nullptr, &paramRetSize);
@@ -85,7 +85,7 @@ TEST_F(clGetImageInfoTests, GivenInvalidParametersWhenGettingImageInfoThenValueS
EXPECT_EQ(0x1234u, paramRetSize);
}
TEST_F(clGetImageInfoTests, GivenClImageFormatWhenGettingImageInfoThenImageFormatIsReturned) {
TEST_F(ClGetImageInfoTests, GivenClImageFormatWhenGettingImageInfoThenImageFormatIsReturned) {
cl_image_format imgFmtRet;
size_t paramRetSize = 0;
@@ -99,7 +99,7 @@ TEST_F(clGetImageInfoTests, GivenClImageFormatWhenGettingImageInfoThenImageForma
ASSERT_EQ(this->imageFormat.image_channel_order, imgFmtRet.image_channel_order);
}
TEST_F(clGetImageInfoTests, GivenClImageElementSizeWhenGettingImageInfoThenSizeOfImageElementIsReturned) {
TEST_F(ClGetImageInfoTests, GivenClImageElementSizeWhenGettingImageInfoThenSizeOfImageElementIsReturned) {
size_t elemSize = 4;
size_t sizeRet = 0;
size_t paramRetSize = 0;
@@ -113,7 +113,7 @@ TEST_F(clGetImageInfoTests, GivenClImageElementSizeWhenGettingImageInfoThenSizeO
ASSERT_EQ(elemSize, sizeRet);
}
TEST_F(clGetImageInfoTests, GivenClImageRowPitchWhenGettingImageInfoThenSizeOfRowIsReturned) {
TEST_F(ClGetImageInfoTests, GivenClImageRowPitchWhenGettingImageInfoThenSizeOfRowIsReturned) {
size_t rowPitchRet = 0;
size_t paramRetSize = 0;
@@ -126,7 +126,7 @@ TEST_F(clGetImageInfoTests, GivenClImageRowPitchWhenGettingImageInfoThenSizeOfRo
ASSERT_NE(0u, rowPitchRet);
}
TEST_F(clGetImageInfoTests, GivenClImageSlicePitchAnd2dImageWhenGettingImageInfoThenZeroIsReturned) {
TEST_F(ClGetImageInfoTests, GivenClImageSlicePitchAnd2dImageWhenGettingImageInfoThenZeroIsReturned) {
size_t slicePitchRet = 0;
size_t paramRetSize = 0;
@@ -139,7 +139,7 @@ TEST_F(clGetImageInfoTests, GivenClImageSlicePitchAnd2dImageWhenGettingImageInfo
ASSERT_EQ(0u, slicePitchRet);
}
TEST_F(clGetImageInfoTests, GivenClImageWidthWhenGettingImageInfoThenWidthOfImageIsReturned) {
TEST_F(ClGetImageInfoTests, GivenClImageWidthWhenGettingImageInfoThenWidthOfImageIsReturned) {
size_t widthRet = 0;
size_t paramRetSize = 0;
@@ -152,7 +152,7 @@ TEST_F(clGetImageInfoTests, GivenClImageWidthWhenGettingImageInfoThenWidthOfImag
ASSERT_EQ(this->imageDesc.image_width, widthRet);
}
TEST_F(clGetImageInfoTests, GivenImageWithMipMapsWhenGettingImageInfoThenWidthAndHeightOfImageAreShifted) {
TEST_F(ClGetImageInfoTests, GivenImageWithMipMapsWhenGettingImageInfoThenWidthAndHeightOfImageAreShifted) {
auto initialWidth = this->imageDesc.image_width;
auto initialHeight = this->imageDesc.image_height;
@@ -177,7 +177,7 @@ TEST_F(clGetImageInfoTests, GivenImageWithMipMapsWhenGettingImageInfoThenWidthAn
}
}
TEST_F(clGetImageInfoTests, GivenClImageHeightWhenGettingImageInfoThenHeightOfImageIsReturned) {
TEST_F(ClGetImageInfoTests, GivenClImageHeightWhenGettingImageInfoThenHeightOfImageIsReturned) {
size_t heightRet = 0;
size_t paramRetSize = 0;
@@ -190,7 +190,7 @@ TEST_F(clGetImageInfoTests, GivenClImageHeightWhenGettingImageInfoThenHeightOfIm
ASSERT_EQ(this->imageDesc.image_height, heightRet);
}
TEST_F(clGetImageInfoTests, Given3dImageWithMipMapsWhenGettingImageInfoThenWidthAndHeightOfImageAreShifted) {
TEST_F(ClGetImageInfoTests, Given3dImageWithMipMapsWhenGettingImageInfoThenWidthAndHeightOfImageAreShifted) {
size_t widthRet;
size_t expectedWidth;
size_t heightRet;
@@ -246,7 +246,7 @@ TEST_F(clGetImageInfoTests, Given3dImageWithMipMapsWhenGettingImageInfoThenWidth
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clGetImageInfoTests, Given1dImageWithMipMapsWhenGettingImageInfoThenWidthAndHeightOfImageAreShifted) {
TEST_F(ClGetImageInfoTests, Given1dImageWithMipMapsWhenGettingImageInfoThenWidthAndHeightOfImageAreShifted) {
size_t widthRet;
size_t expectedWidth;
size_t heightRet;
@@ -296,7 +296,7 @@ TEST_F(clGetImageInfoTests, Given1dImageWithMipMapsWhenGettingImageInfoThenWidth
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clGetImageInfoTests, GivenClImageDepthAnd2dImageWhenGettingImageInfoThenZeroIsReturned) {
TEST_F(ClGetImageInfoTests, GivenClImageDepthAnd2dImageWhenGettingImageInfoThenZeroIsReturned) {
size_t depthRet = 0;
size_t paramRetSize = 0;
@@ -309,7 +309,7 @@ TEST_F(clGetImageInfoTests, GivenClImageDepthAnd2dImageWhenGettingImageInfoThenZ
ASSERT_EQ(0U, depthRet);
}
TEST_F(clGetImageInfoTests, GivenClImageArraySizeAndNonArrayImageWhenGettingImageInfoThenZeroIsReturned) {
TEST_F(ClGetImageInfoTests, GivenClImageArraySizeAndNonArrayImageWhenGettingImageInfoThenZeroIsReturned) {
size_t arraySizeRet = 0;
size_t paramRetSize = 0;
@@ -322,7 +322,7 @@ TEST_F(clGetImageInfoTests, GivenClImageArraySizeAndNonArrayImageWhenGettingImag
ASSERT_EQ(0u, arraySizeRet);
}
TEST_F(clGetImageInfoTests, GivenClImageBufferWhenGettingImageInfoThenBufferIsReturned) {
TEST_F(ClGetImageInfoTests, GivenClImageBufferWhenGettingImageInfoThenBufferIsReturned) {
cl_mem bufferRet = nullptr;
size_t paramRetSize = 0;
@@ -335,7 +335,7 @@ TEST_F(clGetImageInfoTests, GivenClImageBufferWhenGettingImageInfoThenBufferIsRe
ASSERT_EQ(this->imageDesc.buffer, bufferRet);
}
TEST_F(clGetImageInfoTests, GivenClImageNumMipLevelsWhenGettingImageInfoThenCorrectMipMapLevelIsReturned) {
TEST_F(ClGetImageInfoTests, GivenClImageNumMipLevelsWhenGettingImageInfoThenCorrectMipMapLevelIsReturned) {
cl_uint numMipLevelRet = 0;
size_t paramRetSize = 0;
@@ -348,7 +348,7 @@ TEST_F(clGetImageInfoTests, GivenClImageNumMipLevelsWhenGettingImageInfoThenCorr
ASSERT_EQ(this->imageDesc.num_mip_levels, numMipLevelRet);
}
TEST_F(clGetImageInfoTests, GivenClImageNumSamplesWhenGettingImageInfoThenCorrectNumberOfSamplesIsReturned) {
TEST_F(ClGetImageInfoTests, GivenClImageNumSamplesWhenGettingImageInfoThenCorrectNumberOfSamplesIsReturned) {
cl_uint numSamplesRet = 0;
size_t paramRetSize = 0;
@@ -361,7 +361,7 @@ TEST_F(clGetImageInfoTests, GivenClImageNumSamplesWhenGettingImageInfoThenCorrec
ASSERT_EQ(this->imageDesc.num_samples, numSamplesRet);
}
TEST_F(clGetImageInfoTests, givenMultisampleCountForMcsWhenAskingForRowPitchThenReturnNewValueIfGreaterThanOne) {
TEST_F(ClGetImageInfoTests, givenMultisampleCountForMcsWhenAskingForRowPitchThenReturnNewValueIfGreaterThanOne) {
McsSurfaceInfo mcsInfo = {1, 1, 0};
imageDesc.num_samples = 16;
size_t receivedRowPitch = 0;

14
opencl/test/unit_test/api/cl_get_image_params_tests.inl
View File

@@ -14,7 +14,7 @@ using namespace NEO;
namespace ULT {
template <typename T>
struct clGetImageParams : public ApiFixture<>,
struct ClGetImageParams : public ApiFixture<>,
public T {
void SetUp() override {
@@ -45,9 +45,9 @@ struct clGetImageParams : public ApiFixture<>,
cl_image_desc imageDesc;
};
typedef clGetImageParams<::testing::Test> clGetImageParamsTest;
typedef ClGetImageParams<::testing::Test> ClGetImageParamsTest;
TEST_F(clGetImageParamsTest, GivenValidParamsWhenGettingImageParamsThenSuccessIsReturned) {
TEST_F(ClGetImageParamsTest, GivenValidParamsWhenGettingImageParamsThenSuccessIsReturned) {
size_t imageRowPitch = 0;
size_t imageSlicePitch = 0;
cl_int retVal = CL_INVALID_VALUE;
@@ -58,7 +58,7 @@ TEST_F(clGetImageParamsTest, GivenValidParamsWhenGettingImageParamsThenSuccessIs
EXPECT_NE(imageSlicePitch, 0u);
}
TEST_F(clGetImageParamsTest, GivenDefaultAndSpecializedContextsWhenGettingImageParamsThenTheSameValuesAreReturned) {
TEST_F(ClGetImageParamsTest, GivenDefaultAndSpecializedContextsWhenGettingImageParamsThenTheSameValuesAreReturned) {
cl_int retVal = CL_INVALID_VALUE;
MockDefaultContext defaultContext;
size_t defaultContextImageRowPitch = 0;
@@ -80,7 +80,7 @@ TEST_F(clGetImageParamsTest, GivenDefaultAndSpecializedContextsWhenGettingImageP
EXPECT_EQ(defaultContextImageSlicePitch, specializedContextImageSlicePitch);
}
TEST_F(clGetImageParamsTest, GivenNullContextWhenGettingImageParamsThenInvalidContextErrorIsReturned) {
TEST_F(ClGetImageParamsTest, GivenNullContextWhenGettingImageParamsThenInvalidContextErrorIsReturned) {
size_t imageRowPitch = 0;
size_t imageSlicePitch = 0;
cl_int retVal = CL_SUCCESS;
@@ -91,7 +91,7 @@ TEST_F(clGetImageParamsTest, GivenNullContextWhenGettingImageParamsThenInvalidCo
EXPECT_EQ(imageSlicePitch, 0u);
}
TEST_F(clGetImageParamsTest, GivenNullParamsWhenGettingImageParamsThenInvalidValueErrorIsReturned) {
TEST_F(ClGetImageParamsTest, GivenNullParamsWhenGettingImageParamsThenInvalidValueErrorIsReturned) {
size_t imageRowPitch = 0;
size_t imageSlicePitch = 0;
cl_int retVal = CL_SUCCESS;
@@ -117,7 +117,7 @@ TEST_F(clGetImageParamsTest, GivenNullParamsWhenGettingImageParamsThenInvalidVal
EXPECT_EQ(imageSlicePitch, 0u);
}
TEST_F(clGetImageParamsTest, GivenInvalidFormatWhenGettingImageParamsThenImageFormatNotSupportedErrorIsReturned) {
TEST_F(ClGetImageParamsTest, GivenInvalidFormatWhenGettingImageParamsThenImageFormatNotSupportedErrorIsReturned) {
size_t imageRowPitch = 0;
size_t imageSlicePitch = 0;

18
opencl/test/unit_test/api/cl_get_kernel_work_group_info_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -13,7 +13,7 @@ using namespace NEO;
namespace ULT {
TEST_P(clGetKernelWorkGroupInfoTests, GivenValidParametersWhenGettingKernelWorkGroupInfoThenSuccessIsReturned) {
TEST_P(ClGetKernelWorkGroupInfoTests, GivenValidParametersWhenGettingKernelWorkGroupInfoThenSuccessIsReturned) {
size_t paramValueSizeRet;
auto retVal = clGetKernelWorkGroupInfo(
@@ -28,7 +28,7 @@ TEST_P(clGetKernelWorkGroupInfoTests, GivenValidParametersWhenGettingKernelWorkG
EXPECT_NE(0u, paramValueSizeRet);
}
TEST_F(clGetKernelWorkGroupInfoTest, GivenInvalidDeviceWhenGettingWorkGroupInfoFromSingleDeviceKernelThenInvalidDeviceErrorIsReturned) {
TEST_F(ClGetKernelWorkGroupInfoTest, GivenInvalidDeviceWhenGettingWorkGroupInfoFromSingleDeviceKernelThenInvalidDeviceErrorIsReturned) {
size_t paramValueSizeRet;
auto retVal = clGetKernelWorkGroupInfo(
@@ -42,7 +42,7 @@ TEST_F(clGetKernelWorkGroupInfoTest, GivenInvalidDeviceWhenGettingWorkGroupInfoF
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
}
TEST_F(clGetKernelWorkGroupInfoTest, GivenNullDeviceWhenGettingWorkGroupInfoFromSingleDeviceKernelThenSuccessIsReturned) {
TEST_F(ClGetKernelWorkGroupInfoTest, GivenNullDeviceWhenGettingWorkGroupInfoFromSingleDeviceKernelThenSuccessIsReturned) {
size_t paramValueSizeRet;
auto retVal = clGetKernelWorkGroupInfo(
@@ -56,7 +56,7 @@ TEST_F(clGetKernelWorkGroupInfoTest, GivenNullDeviceWhenGettingWorkGroupInfoFrom
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clGetKernelWorkGroupInfoTest, GivenNullDeviceWhenGettingWorkGroupInfoFromMultiDeviceKernelThenInvalidDeviceErrorIsReturned) {
TEST_F(ClGetKernelWorkGroupInfoTest, GivenNullDeviceWhenGettingWorkGroupInfoFromMultiDeviceKernelThenInvalidDeviceErrorIsReturned) {
size_t paramValueSizeRet;
MockUnrestrictiveContext context;
@@ -74,7 +74,7 @@ TEST_F(clGetKernelWorkGroupInfoTest, GivenNullDeviceWhenGettingWorkGroupInfoFrom
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
}
TEST_F(clGetKernelWorkGroupInfoTests, GivenKernelRequiringScratchSpaceWhenGettingKernelWorkGroupInfoThenCorrectSpillMemSizeIsReturned) {
TEST_F(ClGetKernelWorkGroupInfoTests, GivenKernelRequiringScratchSpaceWhenGettingKernelWorkGroupInfoThenCorrectSpillMemSizeIsReturned) {
size_t paramValueSizeRet;
cl_ulong paramValue;
auto pDevice = castToObject<ClDevice>(testedClDevice);
@@ -99,7 +99,7 @@ TEST_F(clGetKernelWorkGroupInfoTests, GivenKernelRequiringScratchSpaceWhenGettin
}
using matcher = IsWithinProducts<IGFX_SKYLAKE, IGFX_DG1>;
HWTEST2_F(clGetKernelWorkGroupInfoTests, givenKernelHavingPrivateMemoryAllocationWhenAskedForPrivateAllocationSizeThenProperSizeIsReturned, matcher) {
HWTEST2_F(ClGetKernelWorkGroupInfoTests, givenKernelHavingPrivateMemoryAllocationWhenAskedForPrivateAllocationSizeThenProperSizeIsReturned, matcher) {
size_t paramValueSizeRet;
cl_ulong paramValue;
auto pDevice = castToObject<ClDevice>(testedClDevice);
@@ -120,7 +120,7 @@ HWTEST2_F(clGetKernelWorkGroupInfoTests, givenKernelHavingPrivateMemoryAllocatio
EXPECT_EQ(1024U, paramValue);
}
TEST_F(clGetKernelWorkGroupInfoTests, givenKernelNotHavingPrivateMemoryAllocationWhenAskedForPrivateAllocationSizeThenZeroIsReturned) {
TEST_F(ClGetKernelWorkGroupInfoTests, givenKernelNotHavingPrivateMemoryAllocationWhenAskedForPrivateAllocationSizeThenZeroIsReturned) {
size_t paramValueSizeRet;
cl_ulong paramValue;
auto pDevice = castToObject<ClDevice>(testedClDevice);
@@ -150,6 +150,6 @@ static cl_kernel_work_group_info paramNames[] = {
INSTANTIATE_TEST_CASE_P(
api,
clGetKernelWorkGroupInfoTests,
ClGetKernelWorkGroupInfoTests,
testing::ValuesIn(paramNames));
} // namespace ULT

24
opencl/test/unit_test/api/cl_get_pipe_info_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -13,13 +13,13 @@
using namespace NEO;
struct clGetPipeInfoTests : api_tests {
struct ClGetPipeInfoTests : api_tests {
VariableBackup<bool> supportsPipesBackup{&defaultHwInfo->capabilityTable.supportsPipes, true};
};
namespace ULT {
TEST_F(clGetPipeInfoTests, GivenValidPipeWithPacketSizeOneWhenGettingPipeInfoThenPacketSizeReturnedIsOne) {
TEST_F(ClGetPipeInfoTests, GivenValidPipeWithPacketSizeOneWhenGettingPipeInfoThenPacketSizeReturnedIsOne) {
auto pipe = clCreatePipe(pContext, CL_MEM_READ_WRITE, 1, 20, nullptr, &retVal);
EXPECT_NE(nullptr, pipe);
@@ -36,7 +36,7 @@ TEST_F(clGetPipeInfoTests, GivenValidPipeWithPacketSizeOneWhenGettingPipeInfoThe
clReleaseMemObject(pipe);
}
TEST_F(clGetPipeInfoTests, GivenValidPipeWithMaxPacketEqualTwentyWhenGettingPipeInfoThenMaxPacketReturnedIsTwenty) {
TEST_F(ClGetPipeInfoTests, GivenValidPipeWithMaxPacketEqualTwentyWhenGettingPipeInfoThenMaxPacketReturnedIsTwenty) {
auto pipe = clCreatePipe(pContext, CL_MEM_READ_WRITE, 1, 20, nullptr, &retVal);
EXPECT_NE(nullptr, pipe);
@@ -53,7 +53,7 @@ TEST_F(clGetPipeInfoTests, GivenValidPipeWithMaxPacketEqualTwentyWhenGettingPipe
clReleaseMemObject(pipe);
}
TEST_F(clGetPipeInfoTests, GivenInvalidParamNameWhenGettingPipeInfoThenClInvalidValueErrorIsReturned) {
TEST_F(ClGetPipeInfoTests, GivenInvalidParamNameWhenGettingPipeInfoThenClInvalidValueErrorIsReturned) {
auto pipe = clCreatePipe(pContext, CL_MEM_READ_WRITE, 1, 20, nullptr, &retVal);
EXPECT_NE(nullptr, pipe);
@@ -68,7 +68,7 @@ TEST_F(clGetPipeInfoTests, GivenInvalidParamNameWhenGettingPipeInfoThenClInvalid
clReleaseMemObject(pipe);
}
TEST_F(clGetPipeInfoTests, GivenInvalidParametersWhenGettingPipeInfoThenValueSizeRetIsNotUpdated) {
TEST_F(ClGetPipeInfoTests, GivenInvalidParametersWhenGettingPipeInfoThenValueSizeRetIsNotUpdated) {
auto pipe = clCreatePipe(pContext, CL_MEM_READ_WRITE, 1, 20, nullptr, &retVal);
EXPECT_NE(nullptr, pipe);
@@ -84,7 +84,7 @@ TEST_F(clGetPipeInfoTests, GivenInvalidParametersWhenGettingPipeInfoThenValueSiz
clReleaseMemObject(pipe);
}
TEST_F(clGetPipeInfoTests, GivenInvalidMemoryObjectWhenGettingPipeInfoThenClInvalidMemObjectErrorIsReturned) {
TEST_F(ClGetPipeInfoTests, GivenInvalidMemoryObjectWhenGettingPipeInfoThenClInvalidMemObjectErrorIsReturned) {
cl_uint paramValue = 0;
size_t paramValueRetSize = 0;
@@ -94,7 +94,7 @@ TEST_F(clGetPipeInfoTests, GivenInvalidMemoryObjectWhenGettingPipeInfoThenClInva
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clGetPipeInfoTests, GivenNullParamValueWhenGettingPipeInfoThenClSuccessIsReturned) {
TEST_F(ClGetPipeInfoTests, GivenNullParamValueWhenGettingPipeInfoThenClSuccessIsReturned) {
auto pipe = clCreatePipe(pContext, CL_MEM_READ_WRITE, 1, 20, nullptr, &retVal);
EXPECT_NE(nullptr, pipe);
@@ -109,7 +109,7 @@ TEST_F(clGetPipeInfoTests, GivenNullParamValueWhenGettingPipeInfoThenClSuccessIs
clReleaseMemObject(pipe);
}
TEST_F(clGetPipeInfoTests, GivenNullParamValueSizeRetWhenGettingPipeInfoThenClSuccessIsReturned) {
TEST_F(ClGetPipeInfoTests, GivenNullParamValueSizeRetWhenGettingPipeInfoThenClSuccessIsReturned) {
auto pipe = clCreatePipe(pContext, CL_MEM_READ_WRITE, 1, 20, nullptr, &retVal);
EXPECT_NE(nullptr, pipe);
@@ -123,7 +123,7 @@ TEST_F(clGetPipeInfoTests, GivenNullParamValueSizeRetWhenGettingPipeInfoThenClSu
clReleaseMemObject(pipe);
}
TEST_F(clGetPipeInfoTests, GivenParamValueSizeRetTooSmallWhenGettingPipeInfoThenClInvalidValueErrorIsReturned) {
TEST_F(ClGetPipeInfoTests, GivenParamValueSizeRetTooSmallWhenGettingPipeInfoThenClInvalidValueErrorIsReturned) {
auto pipe = clCreatePipe(pContext, CL_MEM_READ_WRITE, 1, 20, nullptr, &retVal);
EXPECT_NE(nullptr, pipe);
@@ -138,7 +138,7 @@ TEST_F(clGetPipeInfoTests, GivenParamValueSizeRetTooSmallWhenGettingPipeInfoThen
clReleaseMemObject(pipe);
}
TEST_F(clGetPipeInfoTests, GivenBufferInsteadOfPipeWhenGettingPipeInfoThenClInvalidMemObjectErrorIsReturned) {
TEST_F(ClGetPipeInfoTests, GivenBufferInsteadOfPipeWhenGettingPipeInfoThenClInvalidMemObjectErrorIsReturned) {
auto buffer = clCreateBuffer(pContext, CL_MEM_READ_WRITE, 20, nullptr, &retVal);
EXPECT_NE(nullptr, buffer);
@@ -153,7 +153,7 @@ TEST_F(clGetPipeInfoTests, GivenBufferInsteadOfPipeWhenGettingPipeInfoThenClInva
clReleaseMemObject(buffer);
}
TEST_F(clGetPipeInfoTests, WhenQueryingPipePropertiesThenNothingIsCopied) {
TEST_F(ClGetPipeInfoTests, WhenQueryingPipePropertiesThenNothingIsCopied) {
auto pipe = clCreatePipe(pContext, CL_MEM_READ_WRITE, 1, 20, nullptr, &retVal);
EXPECT_NE(nullptr, pipe);

38
opencl/test/unit_test/api/cl_get_platform_info_tests.inl
View File

@@ -13,7 +13,7 @@
using namespace NEO;
struct clGetPlatformInfoTests : Test<PlatformFixture> {
struct ClGetPlatformInfoTests : Test<PlatformFixture> {
void SetUp() override {
Test<PlatformFixture>::SetUp();
}
@@ -43,20 +43,20 @@ struct clGetPlatformInfoTests : Test<PlatformFixture> {
namespace ULT {
TEST_F(clGetPlatformInfoTests, GivenClPlatformProfileWhenGettingPlatformInfoStringThenFullProfileIsReturned) {
TEST_F(ClGetPlatformInfoTests, GivenClPlatformProfileWhenGettingPlatformInfoStringThenFullProfileIsReturned) {
paramValue = getPlatformInfoString(pPlatform, CL_PLATFORM_PROFILE);
EXPECT_STREQ(paramValue, "FULL_PROFILE");
}
class ClGetPlatformInfoParameterizedTests : public clGetPlatformInfoTests,
class ClGetPlatformInfoParameterizedTests : public ClGetPlatformInfoTests,
public ::testing::WithParamInterface<uint32_t> {
void SetUp() override {
DebugManager.flags.ForceOCLVersion.set(GetParam());
clGetPlatformInfoTests::SetUp();
ClGetPlatformInfoTests::SetUp();
}
void TearDown() override {
clGetPlatformInfoTests::TearDown();
ClGetPlatformInfoTests::TearDown();
DebugManager.flags.ForceOCLVersion.set(0);
}
};
@@ -96,20 +96,20 @@ INSTANTIATE_TEST_CASE_P(OCLVersions,
ClGetPlatformInfoParameterizedTests,
::testing::Values(12, 21, 30));
TEST_F(clGetPlatformInfoTests, GivenClPlatformNameWhenGettingPlatformInfoStringThenCorrectStringIsReturned) {
TEST_F(ClGetPlatformInfoTests, GivenClPlatformNameWhenGettingPlatformInfoStringThenCorrectStringIsReturned) {
paramValue = getPlatformInfoString(pPlatform, CL_PLATFORM_NAME);
EXPECT_STREQ(paramValue, "Intel(R) OpenCL Graphics");
}
class ClGetPlatformInfoOverridePlatformNameTests : public clGetPlatformInfoTests {
class ClGetPlatformInfoOverridePlatformNameTests : public ClGetPlatformInfoTests {
public:
void SetUp() override {
NEO::DebugManager.flags.OverridePlatformName.set(testPlatformName);
clGetPlatformInfoTests::SetUp();
ClGetPlatformInfoTests::SetUp();
}
void TearDown() override {
clGetPlatformInfoTests::TearDown();
ClGetPlatformInfoTests::TearDown();
}
DebugManagerStateRestore restorer;
@@ -121,24 +121,24 @@ TEST_F(ClGetPlatformInfoOverridePlatformNameTests, givenDebugVariableOverridePla
EXPECT_STREQ(paramValue, testPlatformName.c_str());
}
TEST_F(clGetPlatformInfoTests, GivenClPlatformVendorWhenGettingPlatformInfoStringThenCorrectStringIsReturned) {
TEST_F(ClGetPlatformInfoTests, GivenClPlatformVendorWhenGettingPlatformInfoStringThenCorrectStringIsReturned) {
paramValue = getPlatformInfoString(pPlatform, CL_PLATFORM_VENDOR);
EXPECT_STREQ(paramValue, "Intel(R) Corporation");
}
TEST_F(clGetPlatformInfoTests, GivenClPlatformExtensionsWhenGettingPlatformInfoStringThenExtensionStringIsReturned) {
TEST_F(ClGetPlatformInfoTests, GivenClPlatformExtensionsWhenGettingPlatformInfoStringThenExtensionStringIsReturned) {
paramValue = getPlatformInfoString(pPlatform, CL_PLATFORM_EXTENSIONS);
EXPECT_NE(nullptr, strstr(paramValue, "cl_khr_icd "));
EXPECT_NE(nullptr, strstr(paramValue, "cl_khr_fp16 "));
}
TEST_F(clGetPlatformInfoTests, GivenClPlatformIcdSuffixKhrWhenGettingPlatformInfoStringThenIntelIsReturned) {
TEST_F(ClGetPlatformInfoTests, GivenClPlatformIcdSuffixKhrWhenGettingPlatformInfoStringThenIntelIsReturned) {
paramValue = getPlatformInfoString(pPlatform, CL_PLATFORM_ICD_SUFFIX_KHR);
EXPECT_STREQ(paramValue, "INTEL");
}
TEST_F(clGetPlatformInfoTests, GivenClPlatformHostTimerResolutionWhenGettingPlatformInfoStringThenCorrectResolutionIsReturned) {
TEST_F(ClGetPlatformInfoTests, GivenClPlatformHostTimerResolutionWhenGettingPlatformInfoStringThenCorrectResolutionIsReturned) {
auto retVal = clGetPlatformInfo(pPlatform, CL_PLATFORM_HOST_TIMER_RESOLUTION, 0, nullptr, &retSize);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_GT(retSize, 0u);
@@ -152,7 +152,7 @@ TEST_F(clGetPlatformInfoTests, GivenClPlatformHostTimerResolutionWhenGettingPlat
EXPECT_EQ(resolution, value);
}
TEST_F(clGetPlatformInfoTests, GivenNullPlatformWhenGettingPlatformInfoStringThenClInvalidPlatformErrorIsReturned) {
TEST_F(ClGetPlatformInfoTests, GivenNullPlatformWhenGettingPlatformInfoStringThenClInvalidPlatformErrorIsReturned) {
char extensions[512];
auto retVal = clGetPlatformInfo(
nullptr, // invalid platform
@@ -164,7 +164,7 @@ TEST_F(clGetPlatformInfoTests, GivenNullPlatformWhenGettingPlatformInfoStringThe
EXPECT_EQ(CL_INVALID_PLATFORM, retVal);
}
TEST_F(clGetPlatformInfoTests, GivenInvalidParamNameWhenGettingPlatformInfoStringThenClInvalidValueErrorIsReturned) {
TEST_F(ClGetPlatformInfoTests, GivenInvalidParamNameWhenGettingPlatformInfoStringThenClInvalidValueErrorIsReturned) {
char extensions[512];
auto retVal = clGetPlatformInfo(
pPlatform,
@@ -176,7 +176,7 @@ TEST_F(clGetPlatformInfoTests, GivenInvalidParamNameWhenGettingPlatformInfoStrin
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clGetPlatformInfoTests, GivenInvalidParametersWhenGettingPlatformInfoThenValueSizeRetIsNotUpdated) {
TEST_F(ClGetPlatformInfoTests, GivenInvalidParametersWhenGettingPlatformInfoThenValueSizeRetIsNotUpdated) {
char extensions[512];
retSize = 0x1234;
auto retVal = clGetPlatformInfo(
@@ -190,7 +190,7 @@ TEST_F(clGetPlatformInfoTests, GivenInvalidParametersWhenGettingPlatformInfoThen
EXPECT_EQ(0x1234u, retSize);
}
TEST_F(clGetPlatformInfoTests, GivenInvalidParamSizeWhenGettingPlatformInfoStringThenClInvalidValueErrorIsReturned) {
TEST_F(ClGetPlatformInfoTests, GivenInvalidParamSizeWhenGettingPlatformInfoStringThenClInvalidValueErrorIsReturned) {
char extensions[512];
auto retVal = clGetPlatformInfo(
pPlatform,
@@ -202,7 +202,7 @@ TEST_F(clGetPlatformInfoTests, GivenInvalidParamSizeWhenGettingPlatformInfoStrin
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clGetPlatformInfoTests, GivenDeviceWhenGettingIcdDispatchTableThenDeviceAndPlatformTablesMatch) {
TEST_F(ClGetPlatformInfoTests, GivenDeviceWhenGettingIcdDispatchTableThenDeviceAndPlatformTablesMatch) {
EXPECT_NE(pPlatform->dispatch.icdDispatch, nullptr);
for (size_t deviceOrdinal = 0; deviceOrdinal < pPlatform->getNumDevices(); ++deviceOrdinal) {
auto device = pPlatform->getClDevice(deviceOrdinal);
@@ -211,7 +211,7 @@ TEST_F(clGetPlatformInfoTests, GivenDeviceWhenGettingIcdDispatchTableThenDeviceA
}
}
TEST_F(clGetPlatformInfoTests, WhenCheckingPlatformExtensionsWithVersionThenTheyMatchPlatformExtensions) {
TEST_F(ClGetPlatformInfoTests, WhenCheckingPlatformExtensionsWithVersionThenTheyMatchPlatformExtensions) {
auto retVal = clGetPlatformInfo(pPlatform, CL_PLATFORM_EXTENSIONS_WITH_VERSION, 0, nullptr, &retSize);
EXPECT_EQ(CL_SUCCESS, retVal);

8
opencl/test/unit_test/api/cl_retain_release_device_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -11,7 +11,7 @@
using namespace NEO;
struct clRetainReleaseDeviceTests : Test<PlatformFixture> {
struct ClRetainReleaseDeviceTests : Test<PlatformFixture> {
void SetUp() override {
DebugManager.flags.CreateMultipleRootDevices.set(maxRootDeviceCount);
Test<PlatformFixture>::SetUp();
@@ -21,7 +21,7 @@ struct clRetainReleaseDeviceTests : Test<PlatformFixture> {
};
namespace ULT {
TEST_F(clRetainReleaseDeviceTests, GivenRootDeviceWhenRetainingThenReferenceCountIsOne) {
TEST_F(ClRetainReleaseDeviceTests, GivenRootDeviceWhenRetainingThenReferenceCountIsOne) {
cl_uint numEntries = maxRootDeviceCount;
cl_device_id devices[maxRootDeviceCount];
@@ -43,7 +43,7 @@ TEST_F(clRetainReleaseDeviceTests, GivenRootDeviceWhenRetainingThenReferenceCoun
EXPECT_EQ(1u, theRef);
}
TEST_F(clRetainReleaseDeviceTests, GivenRootDeviceWhenReleasingThenReferenceCountIsOne) {
TEST_F(ClRetainReleaseDeviceTests, GivenRootDeviceWhenReleasingThenReferenceCountIsOne) {
constexpr cl_uint numEntries = maxRootDeviceCount;
cl_device_id devices[maxRootDeviceCount];

16
opencl/test/unit_test/api/cl_set_mem_object_destructor_callback_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -12,7 +12,7 @@
using namespace NEO;
typedef api_tests clCreateBufferTests;
typedef api_tests ClCreateBufferTests;
namespace ULT {
@@ -21,7 +21,7 @@ void CL_CALLBACK destructorCallback(cl_mem memObj, void *userData) {
cbInvoked++;
}
struct clSetMemObjectDestructorCallbackTests : public ApiFixture<>,
struct ClSetMemObjectDestructorCallbackTests : public ApiFixture<>,
public ::testing::Test {
void SetUp() override {
@@ -54,13 +54,13 @@ struct clSetMemObjectDestructorCallbackTests : public ApiFixture<>,
cl_image_desc imageDesc;
};
TEST_F(clSetMemObjectDestructorCallbackTests, GivenNullMemObjWhenSettingMemObjCallbackThenInvalidMemObjectErrorIsReturned) {
TEST_F(ClSetMemObjectDestructorCallbackTests, GivenNullMemObjWhenSettingMemObjCallbackThenInvalidMemObjectErrorIsReturned) {
retVal = clSetMemObjectDestructorCallback(nullptr, nullptr, nullptr);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
EXPECT_EQ(0, cbInvoked);
}
TEST_F(clSetMemObjectDestructorCallbackTests, GivenImageAndDestructorCallbackWhenSettingMemObjCallbackThenSuccessIsReturned) {
TEST_F(ClSetMemObjectDestructorCallbackTests, GivenImageAndDestructorCallbackWhenSettingMemObjCallbackThenSuccessIsReturned) {
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
retVal = clSetMemObjectDestructorCallback(image, destructorCallback, nullptr);
@@ -71,7 +71,7 @@ TEST_F(clSetMemObjectDestructorCallbackTests, GivenImageAndDestructorCallbackWhe
EXPECT_EQ(1, cbInvoked);
}
TEST_F(clSetMemObjectDestructorCallbackTests, GivenImageAndNullCallbackFunctionWhenSettingMemObjCallbackThenInvalidValueErrorIsReturned) {
TEST_F(ClSetMemObjectDestructorCallbackTests, GivenImageAndNullCallbackFunctionWhenSettingMemObjCallbackThenInvalidValueErrorIsReturned) {
auto image = Image::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_WRITE, 0, &imageFormat, &imageDesc, nullptr, retVal);
retVal = clSetMemObjectDestructorCallback(image, nullptr, nullptr);
@@ -82,7 +82,7 @@ TEST_F(clSetMemObjectDestructorCallbackTests, GivenImageAndNullCallbackFunctionW
EXPECT_EQ(0, cbInvoked);
}
TEST_F(clSetMemObjectDestructorCallbackTests, GivenBufferAndDestructorCallbackFunctionWhenSettingMemObjCallbackThenSuccessIsReturned) {
TEST_F(ClSetMemObjectDestructorCallbackTests, GivenBufferAndDestructorCallbackFunctionWhenSettingMemObjCallbackThenSuccessIsReturned) {
auto buffer = clCreateBuffer(pContext, CL_MEM_READ_WRITE, 42, nullptr, &retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, buffer);
@@ -95,7 +95,7 @@ TEST_F(clSetMemObjectDestructorCallbackTests, GivenBufferAndDestructorCallbackFu
EXPECT_EQ(1, cbInvoked);
}
TEST_F(clSetMemObjectDestructorCallbackTests, GivenBufferAndNullCallbackFunctionWhenSettingMemObjCallbackThenInvalidValueErrorIsReturned) {
TEST_F(ClSetMemObjectDestructorCallbackTests, GivenBufferAndNullCallbackFunctionWhenSettingMemObjCallbackThenInvalidValueErrorIsReturned) {
auto buffer = clCreateBuffer(pContext, CL_MEM_READ_WRITE, 42, nullptr, &retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, buffer);

6
opencl/test/unit_test/api/cl_set_performance_configuration_tests.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -12,7 +12,7 @@
using namespace NEO;
struct clSetPerformanceConfigurationINTELTests : public DeviceInstrumentationFixture,
struct ClSetPerformanceConfigurationINTELTests : public DeviceInstrumentationFixture,
public PerformanceCountersDeviceFixture,
::testing::Test {
void SetUp() override {
@@ -25,7 +25,7 @@ struct clSetPerformanceConfigurationINTELTests : public DeviceInstrumentationFix
};
namespace ULT {
TEST_F(clSetPerformanceConfigurationINTELTests, GivenAnyArgumentsWhenSettingPerformanceConfigurationThenInvalidOperationErrorIsReturned) {
TEST_F(ClSetPerformanceConfigurationINTELTests, GivenAnyArgumentsWhenSettingPerformanceConfigurationThenInvalidOperationErrorIsReturned) {
cl_int ret = CL_OUT_OF_RESOURCES;
cl_uint offsets[2];
cl_uint values[2];

18
opencl/test/unit_test/api/cl_svm_alloc_tests.inl
View File

@@ -34,7 +34,7 @@ class ClSvmAllocTemplateTests : public ApiFixture<>,
}
};
struct clSVMAllocValidFlagsTests : public ClSvmAllocTemplateTests {
struct ClSVMAllocValidFlagsTests : public ClSvmAllocTemplateTests {
cl_uchar pHostPtr[64];
};
@@ -59,7 +59,7 @@ TEST(clSVMAllocTest, givenPlatformWithoutDevicesWhenClSVMAllocIsCalledThenDevice
clSVMFree(context.get(), svmPtr);
}
TEST_P(clSVMAllocValidFlagsTests, GivenSvmSupportWhenAllocatingSvmThenSvmIsAllocated) {
TEST_P(ClSVMAllocValidFlagsTests, GivenSvmSupportWhenAllocatingSvmThenSvmIsAllocated) {
cl_mem_flags flags = GetParam();
const ClDeviceInfo &devInfo = pDevice->getDeviceInfo();
// check for svm support
@@ -109,17 +109,17 @@ static cl_mem_flags SVMAllocValidFlags[] = {
INSTANTIATE_TEST_CASE_P(
SVMAllocCheckFlags,
clSVMAllocValidFlagsTests,
ClSVMAllocValidFlagsTests,
testing::ValuesIn(SVMAllocValidFlags));
using clSVMAllocFtrFlagsTests = ClSvmAllocTemplateTests;
using ClSVMAllocFtrFlagsTests = ClSvmAllocTemplateTests;
INSTANTIATE_TEST_CASE_P(
SVMAllocCheckFlagsFtrFlags,
clSVMAllocFtrFlagsTests,
ClSVMAllocFtrFlagsTests,
testing::ValuesIn(SVMAllocValidFlags));
TEST_P(clSVMAllocFtrFlagsTests, GivenCorrectFlagsWhenAllocatingSvmThenSvmIsAllocated) {
TEST_P(ClSVMAllocFtrFlagsTests, GivenCorrectFlagsWhenAllocatingSvmThenSvmIsAllocated) {
HardwareInfo *pHwInfo = pDevice->getExecutionEnvironment()->rootDeviceEnvironments[testedRootDeviceIndex]->getMutableHardwareInfo();
cl_mem_flags flags = GetParam();
@@ -151,10 +151,10 @@ TEST_P(clSVMAllocFtrFlagsTests, GivenCorrectFlagsWhenAllocatingSvmThenSvmIsAlloc
clSVMFree(pContext, svmPtr);
};
struct clSVMAllocInvalidFlagsTests : public ClSvmAllocTemplateTests {
struct ClSVMAllocInvalidFlagsTests : public ClSvmAllocTemplateTests {
};
TEST_P(clSVMAllocInvalidFlagsTests, GivenInvalidFlagsWhenAllocatingSvmThenSvmIsNotAllocated) {
TEST_P(ClSVMAllocInvalidFlagsTests, GivenInvalidFlagsWhenAllocatingSvmThenSvmIsNotAllocated) {
cl_mem_flags flags = GetParam();
auto svmPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
@@ -169,7 +169,7 @@ cl_mem_flags SVMAllocInvalidFlags[] = {
INSTANTIATE_TEST_CASE_P(
SVMAllocCheckFlags,
clSVMAllocInvalidFlagsTests,
ClSVMAllocInvalidFlagsTests,
testing::ValuesIn(SVMAllocInvalidFlags));
TEST_F(clSVMAllocTests, GivenNullContextWhenAllocatingSvmThenSvmIsNotAllocated) {

4
opencl/test/unit_test/command_queue/command_queue_hw_1_tests.cpp
View File

@@ -897,7 +897,7 @@ HWTEST_F(CommandQueueHwTest, givenCommandQueueThatIsBlockedAndUsesCpuCopyWhenEve
HWTEST_F(CommandQueueHwTest, givenEventWithRecordedCommandWhenSubmitCommandIsCalledThenTaskCountMustBeUpdatedFromOtherThread) {
std::atomic_bool go{false};
struct mockEvent : public Event {
struct MockEvent : public Event {
using Event::Event;
using Event::eventWithoutCommand;
using Event::submitCommand;
@@ -909,7 +909,7 @@ HWTEST_F(CommandQueueHwTest, givenEventWithRecordedCommandWhenSubmitCommandIsCal
std::atomic_bool *atomicFence = nullptr;
};
mockEvent neoEvent(this->pCmdQ, CL_COMMAND_MAP_BUFFER, CompletionStamp::notReady, CompletionStamp::notReady);
MockEvent neoEvent(this->pCmdQ, CL_COMMAND_MAP_BUFFER, CompletionStamp::notReady, CompletionStamp::notReady);
neoEvent.atomicFence = &go;
EXPECT_TRUE(neoEvent.eventWithoutCommand);
neoEvent.eventWithoutCommand = false;

38
opencl/test/unit_test/command_queue/enqueue_kernel_1_tests.cpp
View File

@@ -776,7 +776,7 @@ HWTEST_F(EnqueueKernelTest, givenCommandStreamReceiverInBatchingModeWhenEnqueueK
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice, context);
@@ -896,7 +896,7 @@ HWTEST_F(EnqueueKernelTest, givenCommandStreamReceiverInBatchingModeAndBatchedKe
mockCsrmockCsr->useGpuIdleImplicitFlush = false;
pDevice->resetCommandStreamReceiver(mockCsrmockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsrmockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice);
@@ -917,7 +917,7 @@ HWTEST_F(EnqueueKernelTest, givenCommandStreamReceiverInBatchingModeAndBatchedKe
mockCsrmockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
pDevice->resetCommandStreamReceiver(mockCsrmockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsrmockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice);
@@ -938,7 +938,7 @@ HWTEST_F(EnqueueKernelTest, givenCommandStreamReceiverInBatchingModeWhenKernelIs
mockCsrmockCsr.overrideDispatchPolicy(DispatchMode::BatchedDispatch);
mockCsrmockCsr.useNewResourceImplicitFlush = false;
mockCsrmockCsr.useGpuIdleImplicitFlush = false;
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsrmockCsr.submissionAggregator.reset(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice, context);
@@ -969,7 +969,7 @@ HWTEST_F(EnqueueKernelTest, givenCommandStreamReceiverInBatchingModeWhenFlushIsC
mockCsr->useGpuIdleImplicitFlush = false;
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice);
@@ -989,7 +989,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, EnqueueKernelTest, givenTwoEnqueueProgrammedWithinS
mockCsr->useGpuIdleImplicitFlush = false;
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
ClHardwareParse hwParse;
@@ -1013,7 +1013,7 @@ HWTEST_F(EnqueueKernelTest, givenCsrInBatchingModeWhenFinishIsCalledThenBatchesS
mockCsr->useGpuIdleImplicitFlush = false;
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice);
@@ -1034,7 +1034,7 @@ HWTEST_F(EnqueueKernelTest, givenCsrInBatchingModeWhenThressEnqueueKernelsAreCal
mockCsr->useGpuIdleImplicitFlush = false;
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice);
@@ -1056,7 +1056,7 @@ HWTEST_F(EnqueueKernelTest, givenCsrInBatchingModeWhenWaitForEventsIsCalledThenB
mockCsr->useGpuIdleImplicitFlush = false;
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice);
@@ -1082,7 +1082,7 @@ HWTEST_F(EnqueueKernelTest, givenCsrInBatchingModeWhenCommandIsFlushedThenFlushS
mockCsr->useGpuIdleImplicitFlush = false;
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice);
@@ -1137,7 +1137,7 @@ HWTEST_F(EnqueueKernelTest, givenCsrInBatchingModeWhenCommandWithEventIsFollowed
mockCsr->useGpuIdleImplicitFlush = false;
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice);
@@ -1191,7 +1191,7 @@ HWTEST_F(EnqueueKernelTest, givenCsrInBatchingModeWhenWaitForEventsIsCalledWithU
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice);
@@ -1215,7 +1215,7 @@ HWTEST_F(EnqueueKernelTest, givenCsrInBatchingModeWhenFinishIsCalledWithUnflushe
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice);
@@ -1244,7 +1244,7 @@ HWTEST_F(EnqueueKernelTest, givenOutOfOrderCommandQueueWhenEnqueueKernelIsMadeTh
mockCsr->useGpuIdleImplicitFlush = false;
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice, context);
@@ -1266,7 +1266,7 @@ HWTEST_F(EnqueueKernelTest, givenInOrderCommandQueueWhenEnqueueKernelIsMadeThenP
mockCsr.overrideDispatchPolicy(DispatchMode::BatchedDispatch);
mockCsr.useNewResourceImplicitFlush = false;
mockCsr.useGpuIdleImplicitFlush = false;
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr.submissionAggregator.reset(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice, context);
@@ -1290,7 +1290,7 @@ HWTEST_F(EnqueueKernelTest, givenInOrderCommandQueueWhenEnqueueKernelThatHasShar
mockCsr->useGpuIdleImplicitFlush = false;
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice, context);
@@ -1330,7 +1330,7 @@ HWTEST_F(EnqueueKernelTest, givenInOrderCommandQueueWhenEnqueueKernelReturningEv
mockCsr->timestampPacketWriteEnabled = false;
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice, context);
@@ -1359,7 +1359,7 @@ HWTEST_F(EnqueueKernelTest, givenInOrderCommandQueueWhenEnqueueKernelReturningEv
pDevice->resetCommandStreamReceiver(mockCsr);
mockCsr->enableNTo1SubmissionModel();
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
MockKernelWithInternals mockKernel(*pClDevice, context);
@@ -1384,7 +1384,7 @@ HWTEST_F(EnqueueKernelTest, givenOutOfOrderCommandQueueWhenEnqueueKernelReturnin
mockCsr->useGpuIdleImplicitFlush = false;
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, 0};

4
opencl/test/unit_test/command_queue/enqueue_kernel_2_tests.cpp
View File

@@ -726,7 +726,7 @@ INSTANTIATE_TEST_CASE_P(EnqueueKernel,
using EnqueueKernelTests = ::testing::Test;
HWTEST_F(EnqueueKernelTests, whenEnqueueingKernelThenCsrCorrectlySetsRequiredThreadArbitrationPolicy) {
struct myCsr : public UltCommandStreamReceiver<FamilyType> {
struct MyCsr : public UltCommandStreamReceiver<FamilyType> {
using CommandStreamReceiverHw<FamilyType>::streamProperties;
};
@@ -751,7 +751,7 @@ HWTEST_F(EnqueueKernelTests, whenEnqueueingKernelThenCsrCorrectlySetsRequiredThr
cl_int retVal;
std::unique_ptr<CommandQueue> pCommandQueue{CommandQueue::create(&context, clDeviceFactory.rootDevices[0], nullptr, true, retVal)};
auto &csr = static_cast<myCsr &>(pCommandQueue->getGpgpuCommandStreamReceiver());
auto &csr = static_cast<MyCsr &>(pCommandQueue->getGpgpuCommandStreamReceiver());
pCommandQueue->enqueueKernel(
mockKernelWithInternalsWithIfpRequired.mockKernel,

2
opencl/test/unit_test/command_queue/enqueue_kernel_mt_tests.cpp
View File

@@ -22,7 +22,7 @@ HWTEST_F(EnqueueKernelTest, givenCsrInBatchingModeWhenFinishIsCalledThenBatchesS
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
pDevice->resetCommandStreamReceiver(mockCsr);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
std::atomic<bool> startEnqueueProcess(false);

4
opencl/test/unit_test/command_queue/enqueue_map_image_tests.cpp
View File

@@ -186,7 +186,7 @@ INSTANTIATE_TEST_CASE_P(MipMapMapImageParamsTest_givenAllocatedMapPtrAndMapWithD
MipMapMapImageParamsTest, ::testing::Values(CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE2D, CL_MEM_OBJECT_IMAGE2D_ARRAY, CL_MEM_OBJECT_IMAGE3D));
template <typename GfxFamily>
struct mockedImage : public ImageHw<GfxFamily> {
struct MockedImage : public ImageHw<GfxFamily> {
using ImageHw<GfxFamily>::ImageHw;
void setAllocatedMapPtr(void *allocatedMapPtr) override {
ownershipTaken = this->hasOwnership();
@@ -204,7 +204,7 @@ HWTEST_F(EnqueueMapImageTest, givenTiledImageWhenMapImageIsCalledThenStorageIsSe
auto graphicsAllocation = image->getGraphicsAllocation(pClDevice->getRootDeviceIndex());
auto surfaceFormatInfo = image->getSurfaceFormatInfo();
mockedImage<FamilyType> mockImage(context,
MockedImage<FamilyType> mockImage(context,
{},
0,
0,

8
opencl/test/unit_test/command_queue/enqueue_svm_tests.cpp
View File

@@ -1739,7 +1739,7 @@ HWTEST_F(EnqueueSvmTest, whenInternalAllocationIsTriedToBeAddedTwiceToResidencyC
svmManager->freeSVMAlloc(unifiedMemoryPtr);
}
struct createHostUnifiedMemoryAllocationTest : public ::testing::Test {
struct CreateHostUnifiedMemoryAllocationTest : public ::testing::Test {
void SetUp() override {
REQUIRE_SVM_OR_SKIP(defaultHwInfo);
device0 = context.pRootDevice0;
@@ -1757,7 +1757,7 @@ struct createHostUnifiedMemoryAllocationTest : public ::testing::Test {
SVMAllocsManager *svmManager = nullptr;
};
HWTEST_F(createHostUnifiedMemoryAllocationTest,
HWTEST_F(CreateHostUnifiedMemoryAllocationTest,
whenCreatingHostUnifiedMemoryAllocationThenOneAllocDataIsCreatedWithOneGraphicsAllocationPerDevice) {
NEO::SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::HOST_UNIFIED_MEMORY, context.getRootDeviceIndices(), context.getDeviceBitfields());
@@ -1779,7 +1779,7 @@ HWTEST_F(createHostUnifiedMemoryAllocationTest,
svmManager->freeSVMAlloc(unifiedMemoryPtr);
}
HWTEST_F(createHostUnifiedMemoryAllocationTest,
HWTEST_F(CreateHostUnifiedMemoryAllocationTest,
whenCreatingMultiGraphicsAllocationThenGraphicsAllocationPerDeviceIsCreated) {
NEO::SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::HOST_UNIFIED_MEMORY, context.getRootDeviceIndices(), context.getDeviceBitfields());
@@ -1825,7 +1825,7 @@ HWTEST_F(createHostUnifiedMemoryAllocationTest,
}
}
HWTEST_F(createHostUnifiedMemoryAllocationTest,
HWTEST_F(CreateHostUnifiedMemoryAllocationTest,
whenCreatingMultiGraphicsAllocationForSpecificRootDeviceIndicesThenOnlyGraphicsAllocationPerSpecificRootDeviceIndexIsCreated) {
NEO::SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::HOST_UNIFIED_MEMORY, context.getRootDeviceIndices(), context.getDeviceBitfields());

2
opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_1_tests.cpp
View File

@@ -182,7 +182,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeAndMidThread
mockCsr.useNewResourceImplicitFlush = false;
mockCsr.useGpuIdleImplicitFlush = false;
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr.submissionAggregator.reset(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();

2
opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_2_tests.cpp
View File

@@ -1214,7 +1214,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenCsrInNonDi
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
configureCSRtoNonDirtyState<FamilyType>(false);

48
opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_3_tests.cpp
View File

@@ -51,7 +51,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenFlushTas
mockCsr->useNewResourceImplicitFlush = false;
mockCsr->useGpuIdleImplicitFlush = false;
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -109,7 +109,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenTaskStreamWhenFlushingThenSto
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -142,7 +142,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeAndTwoRecord
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -210,7 +210,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeAndThreeReco
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -275,7 +275,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeAndThreeReco
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
auto memorySize = (size_t)pDevice->getDeviceInfo().globalMemSize;
@@ -344,7 +344,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenFlushTas
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -418,7 +418,7 @@ HWCMDTEST_F(IGFX_GEN8_CORE, CommandStreamReceiverFlushTaskTests, givenCsrInBatch
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
configureCSRtoNonDirtyState<FamilyType>(false);
@@ -497,7 +497,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenBlocking
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
configureCSRtoNonDirtyState<FamilyType>(false);
@@ -727,7 +727,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenWaitForT
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -768,7 +768,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenEnqueueI
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -809,7 +809,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenSusbsequ
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -875,7 +875,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenTotalRes
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -931,7 +931,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests,
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -1250,7 +1250,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenDcFlushI
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -1284,7 +1284,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenEpiloguePipeControlThenDcFlus
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -1332,7 +1332,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenEpiloguePipeControlWhendDcFlu
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -1369,7 +1369,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests,
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -1428,7 +1428,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeAndOoqFlagSe
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -1468,7 +1468,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenCsrInBatchingModeWhenPipeCont
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -1531,7 +1531,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests,
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -1673,7 +1673,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenDispatchFlagsWithThrottleSetT
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -1706,7 +1706,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenDispatchFlagsWithThrottleSetT
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -1756,7 +1756,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenDispatchFlagsWithThrottleSetT
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();
@@ -1838,7 +1838,7 @@ HWTEST_F(CommandStreamReceiverFlushTaskTests, givenDispatchFlagsWithNewSliceCoun
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
uint64_t newSliceCount = 1;

2
opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_gmock_tests.cpp
View File

@@ -72,7 +72,7 @@ HWTEST2_F(CommandStreamReceiverFlushTaskGmockTests,
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
mockCsr->useNewResourceImplicitFlush = false;
mockCsr->useGpuIdleImplicitFlush = false;
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
DispatchFlags dispatchFlags = DispatchFlagsHelper::createDefaultDispatchFlags();

4
opencl/test/unit_test/command_stream/command_stream_receiver_flush_task_tests_xehp_and_later.cpp
View File

@@ -641,7 +641,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, CommandStreamReceiverFlushTaskXeHPAndLaterTests, gi
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
configureCSRtoNonDirtyState<FamilyType>(true);
@@ -677,7 +677,7 @@ HWCMDTEST_F(IGFX_XE_HP_CORE, CommandStreamReceiverFlushTaskXeHPAndLaterTests, gi
mockCsr->useGpuIdleImplicitFlush = false;
mockCsr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
configureCSRtoNonDirtyState<FamilyType>(true);

4
opencl/test/unit_test/event/event_tests.cpp
View File

@@ -72,7 +72,7 @@ TEST(Event, givenEventThatStatusChangeWhenPeekIsCalledThenEventIsNotUpdated) {
MockContext ctx;
MockCommandQueue cmdQ(&ctx, mockDevice.get(), 0, false);
struct mockEvent : public Event {
struct MockEvent : public Event {
using Event::Event;
void updateExecutionStatus() override {
callCount++;
@@ -80,7 +80,7 @@ TEST(Event, givenEventThatStatusChangeWhenPeekIsCalledThenEventIsNotUpdated) {
uint32_t callCount = 0u;
};
mockEvent event(&cmdQ, CL_COMMAND_NDRANGE_KERNEL, CompletionStamp::notReady, 0);
MockEvent event(&cmdQ, CL_COMMAND_NDRANGE_KERNEL, CompletionStamp::notReady, 0);
EXPECT_EQ(0u, event.callCount);
event.peekExecutionStatus();
EXPECT_EQ(0u, event.callCount);

8
opencl/test/unit_test/event/user_events_tests.cpp
View File

@@ -372,14 +372,14 @@ TEST_F(MockEventTests, GivenTwoUserEvenstWhenCountOnNdr1IsInjectedThenItIsPropag
}
TEST_F(EventTests, givenQueueThatIsBlockedByUserEventWhenIsQueueBlockedIsCalledThenVirtualEventOnlyQueriesForExecutionStatus) {
struct mockEvent : public Event {
struct MockEvent : public Event {
using Event::Event;
void updateExecutionStatus() override {
updateExecutionStatusCalled = true;
}
bool updateExecutionStatusCalled = false;
};
mockEvent mockedVirtualEvent(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, CompletionStamp::notReady, 0);
MockEvent mockedVirtualEvent(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, CompletionStamp::notReady, 0);
pCmdQ->virtualEvent = &mockedVirtualEvent;
EXPECT_TRUE(pCmdQ->isQueueBlocked());
@@ -1095,7 +1095,7 @@ TEST_F(EventTests, WhenPassingBlockedUserEventToEnqueueNdRangeThenCommandQueueIs
}
TEST_F(EventTests, givenUserEventWhenSetStatusIsDoneThenDeviceMutextisAcquired) {
struct mockedEvent : public UserEvent {
struct MockedEvent : public UserEvent {
using UserEvent::UserEvent;
bool setStatus(cl_int status) override {
auto commandStreamReceiverOwnership = ctx->getDevice(0)->getDefaultEngine().commandStreamReceiver->obtainUniqueOwnership();
@@ -1105,7 +1105,7 @@ TEST_F(EventTests, givenUserEventWhenSetStatusIsDoneThenDeviceMutextisAcquired)
bool mutexProperlyAcquired = false;
};
mockedEvent mockEvent(this->context);
MockedEvent mockEvent(this->context);
clSetUserEventStatus(&mockEvent, CL_COMPLETE);
EXPECT_TRUE(mockEvent.mutexProperlyAcquired);
}

6
opencl/test/unit_test/fixtures/kernel_work_group_info_fixture.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
* Copyright (C) 2021-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -13,7 +13,7 @@
#include "opencl/test/unit_test/api/cl_api_tests.h"
using namespace NEO;
struct clGetKernelWorkGroupInfoTest : public ApiFixture<>,
struct ClGetKernelWorkGroupInfoTest : public ApiFixture<>,
public ::testing::Test {
typedef ApiFixture BaseClass;
@@ -76,6 +76,6 @@ struct clGetKernelWorkGroupInfoTest : public ApiFixture<>,
KernelBinaryHelper *kbHelper;
};
struct clGetKernelWorkGroupInfoTests : public clGetKernelWorkGroupInfoTest,
struct ClGetKernelWorkGroupInfoTests : public ClGetKernelWorkGroupInfoTest,
public ::testing::WithParamInterface<uint32_t> {
};

12
opencl/test/unit_test/mt_tests/api/cl_set_mem_object_destructor_callback_tests_mt.inl
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,7 +10,7 @@
using namespace NEO;
typedef api_tests clCreateBufferTests;
typedef api_tests ClCreateBufferTests;
namespace ULT {
@@ -19,7 +19,7 @@ void CL_CALLBACK destructorCallBackMt(cl_mem memObj, void *userData) {
cbInvoked++;
}
struct clSetMemObjectDestructorCallbackMtTests : public ApiFixture<>,
struct ClSetMemObjectDestructorCallbackMtTests : public ApiFixture<>,
public ::testing::Test {
void SetUp() override {
@@ -37,13 +37,13 @@ struct clSetMemObjectDestructorCallbackMtTests : public ApiFixture<>,
}
};
TEST_F(clSetMemObjectDestructorCallbackMtTests, GivenMultipleThreadsWhenSettingDestructorCallbackThenCallbackWasInvokedForEachThread) {
TEST_F(ClSetMemObjectDestructorCallbackMtTests, GivenMultipleThreadsWhenSettingDestructorCallbackThenCallbackWasInvokedForEachThread) {
auto buffer = clCreateBuffer(pContext, CL_MEM_READ_WRITE, 42, nullptr, &retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, buffer);
std::thread t1(clSetMemObjectDestructorCallbackMtTests::setMemCallbackThreadFunc, buffer);
std::thread t2(clSetMemObjectDestructorCallbackMtTests::setMemCallbackThreadFunc, buffer);
std::thread t1(ClSetMemObjectDestructorCallbackMtTests::setMemCallbackThreadFunc, buffer);
std::thread t2(ClSetMemObjectDestructorCallbackMtTests::setMemCallbackThreadFunc, buffer);
retVal = clSetMemObjectDestructorCallback(buffer, destructorCallBackMt, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
t1.join();

14
opencl/test/unit_test/os_interface/linux/linux_create_command_queue_with_properties_tests.cpp
View File

@@ -19,7 +19,7 @@
using namespace NEO;
struct clCreateCommandQueueWithPropertiesLinux : public UltCommandStreamReceiverTest {
struct ClCreateCommandQueueWithPropertiesLinux : public UltCommandStreamReceiverTest {
void SetUp() override {
UltCommandStreamReceiverTest::SetUp();
ExecutionEnvironment *executionEnvironment = new MockExecutionEnvironment();
@@ -50,7 +50,7 @@ struct clCreateCommandQueueWithPropertiesLinux : public UltCommandStreamReceiver
namespace ULT {
TEST_F(clCreateCommandQueueWithPropertiesLinux, givenUnPossiblePropertiesWithClQueueSliceCountWhenCreateCommandQueueThenQueueNotCreated) {
TEST_F(ClCreateCommandQueueWithPropertiesLinux, givenUnPossiblePropertiesWithClQueueSliceCountWhenCreateCommandQueueThenQueueNotCreated) {
uint64_t newSliceCount = 1;
size_t maxSliceCount;
clGetDeviceInfo(clDevice, CL_DEVICE_SLICE_COUNT_INTEL, sizeof(size_t), &maxSliceCount, nullptr);
@@ -65,7 +65,7 @@ TEST_F(clCreateCommandQueueWithPropertiesLinux, givenUnPossiblePropertiesWithClQ
EXPECT_EQ(CL_INVALID_QUEUE_PROPERTIES, retVal);
}
TEST_F(clCreateCommandQueueWithPropertiesLinux, givenZeroWithClQueueSliceCountWhenCreateCommandQueueThenSliceCountEqualDefaultSliceCount) {
TEST_F(ClCreateCommandQueueWithPropertiesLinux, givenZeroWithClQueueSliceCountWhenCreateCommandQueueThenSliceCountEqualDefaultSliceCount) {
uint64_t newSliceCount = 0;
@@ -83,7 +83,7 @@ TEST_F(clCreateCommandQueueWithPropertiesLinux, givenZeroWithClQueueSliceCountWh
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateCommandQueueWithPropertiesLinux, givenPossiblePropertiesWithClQueueSliceCountWhenCreateCommandQueueThenSliceCountIsSet) {
TEST_F(ClCreateCommandQueueWithPropertiesLinux, givenPossiblePropertiesWithClQueueSliceCountWhenCreateCommandQueueThenSliceCountIsSet) {
uint64_t newSliceCount = 1;
size_t maxSliceCount;
@@ -106,7 +106,7 @@ TEST_F(clCreateCommandQueueWithPropertiesLinux, givenPossiblePropertiesWithClQue
EXPECT_EQ(CL_SUCCESS, retVal);
}
HWTEST_F(clCreateCommandQueueWithPropertiesLinux, givenPropertiesWithClQueueSliceCountWhenCreateCommandQueueThenCallFlushTaskAndSliceCountIsSet) {
HWTEST_F(ClCreateCommandQueueWithPropertiesLinux, givenPropertiesWithClQueueSliceCountWhenCreateCommandQueueThenCallFlushTaskAndSliceCountIsSet) {
uint64_t newSliceCount = 1;
size_t maxSliceCount;
clGetDeviceInfo(clDevice, CL_DEVICE_SLICE_COUNT_INTEL, sizeof(size_t), &maxSliceCount, nullptr);
@@ -151,7 +151,7 @@ HWTEST_F(clCreateCommandQueueWithPropertiesLinux, givenPropertiesWithClQueueSlic
EXPECT_EQ(CL_SUCCESS, retVal);
}
HWTEST_F(clCreateCommandQueueWithPropertiesLinux, givenSameSliceCountAsRecentlySetWhenCreateCommandQueueThenSetQueueSliceCountNotCalled) {
HWTEST_F(ClCreateCommandQueueWithPropertiesLinux, givenSameSliceCountAsRecentlySetWhenCreateCommandQueueThenSetQueueSliceCountNotCalled) {
uint64_t newSliceCount = 1;
size_t maxSliceCount;
@@ -197,7 +197,7 @@ HWTEST_F(clCreateCommandQueueWithPropertiesLinux, givenSameSliceCountAsRecentlyS
EXPECT_EQ(CL_SUCCESS, retVal);
}
HWTEST_F(clCreateCommandQueueWithPropertiesLinux, givenPropertiesWithClQueueSliceCountWhenCreateCommandQueueThenSetReturnFalseAndLastSliceCountNotModify) {
HWTEST_F(ClCreateCommandQueueWithPropertiesLinux, givenPropertiesWithClQueueSliceCountWhenCreateCommandQueueThenSetReturnFalseAndLastSliceCountNotModify) {
uint64_t newSliceCount = 1;
size_t maxSliceCount;
clGetDeviceInfo(clDevice, CL_DEVICE_SLICE_COUNT_INTEL, sizeof(size_t), &maxSliceCount, nullptr);

10
opencl/test/unit_test/program/program_tests.cpp
View File

@@ -2873,8 +2873,8 @@ struct SpecializationConstantRootDeviceEnvironment : public RootDeviceEnvironmen
}
};
struct setProgramSpecializationConstantTests : public ::testing::Test {
setProgramSpecializationConstantTests() : device(new MockDevice()) {}
struct SetProgramSpecializationConstantTests : public ::testing::Test {
SetProgramSpecializationConstantTests() : device(new MockDevice()) {}
void SetUp() override {
mockCompiler = new SpecializationConstantCompilerInterfaceMock();
auto rootDeviceEnvironment = device.getExecutionEnvironment()->rootDeviceEnvironments[0].get();
@@ -2893,7 +2893,7 @@ struct setProgramSpecializationConstantTests : public ::testing::Test {
int specValue = 1;
};
TEST_F(setProgramSpecializationConstantTests, whenSetProgramSpecializationConstantThenBinarySourceIsUsed) {
TEST_F(SetProgramSpecializationConstantTests, whenSetProgramSpecializationConstantThenBinarySourceIsUsed) {
auto retVal = mockProgram->setProgramSpecializationConstant(1, sizeof(int), &specValue);
EXPECT_EQ(1, mockCompiler->counter);
@@ -2902,7 +2902,7 @@ TEST_F(setProgramSpecializationConstantTests, whenSetProgramSpecializationConsta
EXPECT_EQ(mockProgram->irBinary.get(), mockCompiler->spirV);
}
TEST_F(setProgramSpecializationConstantTests, whenSetProgramSpecializationConstantMultipleTimesThenSpecializationConstantsAreInitializedOnce) {
TEST_F(SetProgramSpecializationConstantTests, whenSetProgramSpecializationConstantMultipleTimesThenSpecializationConstantsAreInitializedOnce) {
auto retVal = mockProgram->setProgramSpecializationConstant(1, sizeof(int), &specValue);
EXPECT_EQ(1, mockCompiler->counter);
@@ -2916,7 +2916,7 @@ TEST_F(setProgramSpecializationConstantTests, whenSetProgramSpecializationConsta
EXPECT_TRUE(mockProgram->areSpecializationConstantsInitialized);
}
TEST_F(setProgramSpecializationConstantTests, givenInvalidGetSpecConstantsInfoReturnValueWhenSetProgramSpecializationConstantThenErrorIsReturned) {
TEST_F(SetProgramSpecializationConstantTests, givenInvalidGetSpecConstantsInfoReturnValueWhenSetProgramSpecializationConstantThenErrorIsReturned) {
mockCompiler->returnError();
auto retVal = mockProgram->setProgramSpecializationConstant(1, sizeof(int), &specValue);

2
shared/source/device_binary_format/zebin/zeinfo.h
View File

@@ -704,7 +704,7 @@ struct InlineSamplerBaseT {
} // namespace Kernel
namespace GlobalHostAccessTable {
struct globalHostAccessTableT {
struct GlobalHostAccessTableT {
std::string deviceName;
std::string hostName;
};

2
shared/source/device_binary_format/zebin/zeinfo_decoder.h
View File

@@ -52,7 +52,7 @@ DecodeError decodeAndPopulateKernelMiscInfo(size_t kernelMiscInfoOffset, std::ve
void extractZeInfoKernelSections(const NEO::Yaml::YamlParser &parser, const NEO::Yaml::Node &kernelNd, ZeInfoKernelSections &outZeInfoKernelSections, ConstStringRef context, std::string &outWarning);
DecodeError validateZeInfoKernelSectionsCount(const ZeInfoKernelSections &outZeInfoKernelSections, std::string &outErrReason, std::string &outWarning);
using ZeInfoGlobalHostAccessTables = StackVec<Types::GlobalHostAccessTable::globalHostAccessTableT, 32>;
using ZeInfoGlobalHostAccessTables = StackVec<Types::GlobalHostAccessTable::GlobalHostAccessTableT, 32>;
DecodeError readZeInfoGlobalHostAceessTable(const NEO::Yaml::YamlParser &parser, const NEO::Yaml::Node &node,
ZeInfoGlobalHostAccessTables &outDeviceNameToHostTable,
ConstStringRef context,

8
shared/test/common/libult/gen11.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2022 Intel Corporation
* Copyright (C) 2019-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -23,13 +23,13 @@ void populateFactoryTable<UltCommandStreamReceiver<Family>>() {
commandStreamReceiverFactory[IGFX_MAX_CORE + gfxCore] = UltCommandStreamReceiver<Family>::create;
}
struct enableGen11 {
enableGen11() {
struct EnableGen11 {
EnableGen11() {
populateFactoryTable<UltCommandStreamReceiver<Family>>();
}
};
static enableGen11 enable;
static EnableGen11 enable;
static MockDebuggerL0HwPopulateFactory<gfxCore, Family> mockDebuggerGen11;

8
shared/test/common/libult/gen12lp.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2019-2022 Intel Corporation
* Copyright (C) 2019-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -23,13 +23,13 @@ void populateFactoryTable<UltCommandStreamReceiver<Family>>() {
commandStreamReceiverFactory[IGFX_MAX_CORE + gfxCore] = UltCommandStreamReceiver<Family>::create;
}
struct enableGen12LP {
enableGen12LP() {
struct EnableGen12LP {
EnableGen12LP() {
populateFactoryTable<UltCommandStreamReceiver<Family>>();
}
};
static enableGen12LP enable;
static EnableGen12LP enable;
static MockDebuggerL0HwPopulateFactory<gfxCore, Family> mockDebuggerGen12lp;
template class UltCommandStreamReceiver<Gen12LpFamily>;

8
shared/test/common/libult/gen8.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -23,13 +23,13 @@ void populateFactoryTable<UltCommandStreamReceiver<Family>>() {
commandStreamReceiverFactory[IGFX_MAX_CORE + gfxCore] = UltCommandStreamReceiver<Family>::create;
}
struct enableGen8 {
enableGen8() {
struct EnableGen8 {
EnableGen8() {
populateFactoryTable<UltCommandStreamReceiver<Family>>();
}
};
static enableGen8 enable;
static EnableGen8 enable;
static MockDebuggerL0HwPopulateFactory<gfxCore, Family> mockDebuggerGen8;
template class UltCommandStreamReceiver<Gen8Family>;

8
shared/test/common/libult/gen9.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2022 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -23,13 +23,13 @@ void populateFactoryTable<UltCommandStreamReceiver<Family>>() {
commandStreamReceiverFactory[IGFX_MAX_CORE + gfxCore] = UltCommandStreamReceiver<Family>::create;
}
struct enableGen9 {
enableGen9() {
struct EnableGen9 {
EnableGen9() {
populateFactoryTable<UltCommandStreamReceiver<Family>>();
}
};
static enableGen9 enable;
static EnableGen9 enable;
static MockDebuggerL0HwPopulateFactory<gfxCore, Family> mockDebuggerGen9;

8
shared/test/common/libult/xe_hpc_core.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
* Copyright (C) 2021-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -23,13 +23,13 @@ void populateFactoryTable<UltCommandStreamReceiver<Family>>() {
commandStreamReceiverFactory[IGFX_MAX_CORE + gfxCore] = UltCommandStreamReceiver<Family>::create;
}
struct enableXeHpcCore {
enableXeHpcCore() {
struct EnableXeHpcCore {
EnableXeHpcCore() {
populateFactoryTable<UltCommandStreamReceiver<Family>>();
}
};
static enableXeHpcCore enable;
static EnableXeHpcCore enable;
static MockDebuggerL0HwPopulateFactory<gfxCore, Family> mockDebuggerXeHpcCore;
template class UltCommandStreamReceiver<XeHpcCoreFamily>;

8
shared/test/common/libult/xe_hpg_core.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
* Copyright (C) 2021-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -23,13 +23,13 @@ void populateFactoryTable<UltCommandStreamReceiver<Family>>() {
commandStreamReceiverFactory[IGFX_MAX_CORE + gfxCore] = UltCommandStreamReceiver<Family>::create;
}
struct enableXeHpgCore {
enableXeHpgCore() {
struct EnableXeHpgCore {
EnableXeHpgCore() {
populateFactoryTable<UltCommandStreamReceiver<Family>>();
}
};
static enableXeHpgCore enable;
static EnableXeHpgCore enable;
static MockDebuggerL0HwPopulateFactory<gfxCore, Family> mockDebuggerXeHpgCore;
template class UltCommandStreamReceiver<XeHpgCoreFamily>;

4
shared/test/common/mocks/mock_submissions_aggregator.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -10,7 +10,7 @@
#include "shared/source/command_stream/submissions_aggregator.h"
namespace NEO {
struct mockSubmissionsAggregator : public SubmissionAggregator {
struct MockSubmissionsAggregator : public SubmissionAggregator {
CommandBufferList &peekCommandBuffers() {
return this->cmdBuffers;
}

4
shared/test/common/mocks/mock_wddm.cpp
View File

@@ -22,7 +22,7 @@
using namespace NEO;
struct mockHwDeviceId : public HwDeviceIdWddm {
struct MockHwDeviceId : public HwDeviceIdWddm {
using HwDeviceIdWddm::osEnvironment;
};
@@ -30,7 +30,7 @@ WddmMock::WddmMock(RootDeviceEnvironment &rootDeviceEnvironment) : Wddm(std::mak
if (!rootDeviceEnvironment.executionEnvironment.osEnvironment.get()) {
rootDeviceEnvironment.executionEnvironment.osEnvironment = std::make_unique<OsEnvironmentWin>();
}
static_cast<mockHwDeviceId *>(this->hwDeviceId.get())->osEnvironment = rootDeviceEnvironment.executionEnvironment.osEnvironment.get();
static_cast<MockHwDeviceId *>(this->hwDeviceId.get())->osEnvironment = rootDeviceEnvironment.executionEnvironment.osEnvironment.get();
this->temporaryResources = std::make_unique<MockWddmResidentAllocationsContainer>(this);
};

10
shared/test/unit_test/command_stream/compute_mode_tests.h
View File

@@ -17,10 +17,10 @@ using namespace NEO;
struct ComputeModeRequirements : public ::testing::Test {
template <typename FamilyType>
struct myCsr : public UltCommandStreamReceiver<FamilyType> {
struct MyCsr : public UltCommandStreamReceiver<FamilyType> {
using CommandStreamReceiver::commandStream;
using CommandStreamReceiver::streamProperties;
myCsr(ExecutionEnvironment &executionEnvironment, const DeviceBitfield deviceBitfield)
MyCsr(ExecutionEnvironment &executionEnvironment, const DeviceBitfield deviceBitfield)
: UltCommandStreamReceiver<FamilyType>(executionEnvironment, 0, deviceBitfield){};
CsrSizeRequestFlags *getCsrRequestFlags() { return &this->csrSizeRequestFlags; }
bool hasSharedHandles() override {
@@ -67,8 +67,8 @@ struct ComputeModeRequirements : public ::testing::Test {
}
template <typename FamilyType>
myCsr<FamilyType> *getCsrHw() {
return static_cast<myCsr<FamilyType> *>(csr);
MyCsr<FamilyType> *getCsrHw() {
return static_cast<MyCsr<FamilyType> *>(csr);
}
template <typename FamilyType>
@@ -81,7 +81,7 @@ struct ComputeModeRequirements : public ::testing::Test {
device.reset(MockDevice::createWithNewExecutionEnvironment<MockDevice>(hardwareInfo));
device->executionEnvironment->rootDeviceEnvironments[0]->setHwInfoAndInitHelpers(hardwareInfo);
device->executionEnvironment->rootDeviceEnvironments[0]->initGmm();
csr = new myCsr<FamilyType>(*device->executionEnvironment, device->getDeviceBitfield());
csr = new MyCsr<FamilyType>(*device->executionEnvironment, device->getDeviceBitfield());
device->resetCommandStreamReceiver(csr);
AllocationProperties properties(device->getRootDeviceIndex(), false, MemoryConstants::pageSize, AllocationType::SHARED_BUFFER, false, {});

8
shared/test/unit_test/gen11/coherency_tests_gen11.cpp
View File

@@ -21,10 +21,10 @@ using namespace NEO;
struct Gen11CoherencyRequirements : public ::testing::Test {
typedef typename Gen11Family::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
struct myCsr : public CommandStreamReceiverHw<Gen11Family> {
struct MyCsr : public CommandStreamReceiverHw<Gen11Family> {
using CommandStreamReceiver::commandStream;
using CommandStreamReceiver::streamProperties;
myCsr(ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverHw<Gen11Family>(executionEnvironment, 0, 1){};
MyCsr(ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverHw<Gen11Family>(executionEnvironment, 0, 1){};
CsrSizeRequestFlags *getCsrRequestFlags() { return &csrSizeRequestFlags; }
};
@@ -36,11 +36,11 @@ struct Gen11CoherencyRequirements : public ::testing::Test {
void SetUp() override {
device.reset(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
csr = new myCsr(*device->executionEnvironment);
csr = new MyCsr(*device->executionEnvironment);
device->resetCommandStreamReceiver(csr);
}
myCsr *csr = nullptr;
MyCsr *csr = nullptr;
std::unique_ptr<MockDevice> device;
DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags();
};

8
shared/test/unit_test/gen11/icllp/test_program_media_sampler_icllp.cpp
View File

@@ -22,10 +22,10 @@ struct Gen11MediaSamplerProgramingTest : public ::testing::Test {
typedef typename Gen11Family::MI_LOAD_REGISTER_IMM MI_LOAD_REGISTER_IMM;
typedef typename Gen11Family::PIPE_CONTROL PIPE_CONTROL;
struct myCsr : public CommandStreamReceiverHw<Gen11Family> {
struct MyCsr : public CommandStreamReceiverHw<Gen11Family> {
using CommandStreamReceiver::commandStream;
using CommandStreamReceiverHw<Gen11Family>::programMediaSampler;
myCsr(ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverHw<Gen11Family>(executionEnvironment, 0, 1){};
MyCsr(ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverHw<Gen11Family>(executionEnvironment, 0, 1){};
void overrideLastVmeSubliceConfig(bool value) {
lastVmeSubslicesConfig = value;
}
@@ -38,7 +38,7 @@ struct Gen11MediaSamplerProgramingTest : public ::testing::Test {
void SetUp() override {
device.reset(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
csr = new myCsr(*device->executionEnvironment);
csr = new MyCsr(*device->executionEnvironment);
device->resetCommandStreamReceiver(csr);
stream.reset(new LinearStream(buff, MemoryConstants::pageSize));
@@ -52,7 +52,7 @@ struct Gen11MediaSamplerProgramingTest : public ::testing::Test {
return csr->getCmdSizeForMediaSampler(flags.pipelineSelectArgs.mediaSamplerRequired);
}
myCsr *csr = nullptr;
MyCsr *csr = nullptr;
std::unique_ptr<MockDevice> device;
DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags();
char buff[MemoryConstants::pageSize];

8
shared/test/unit_test/gen12lp/coherency_tests_gen12lp.inl
View File

@@ -21,10 +21,10 @@ struct Gen12LpCoherencyRequirements : public ::testing::Test {
using PIPE_CONTROL = typename Gen12LpFamily::PIPE_CONTROL;
using PIPELINE_SELECT = typename Gen12LpFamily::PIPELINE_SELECT;
struct myCsr : public CommandStreamReceiverHw<Gen12LpFamily> {
struct MyCsr : public CommandStreamReceiverHw<Gen12LpFamily> {
using CommandStreamReceiver::commandStream;
using CommandStreamReceiver::streamProperties;
myCsr(ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverHw<Gen12LpFamily>(executionEnvironment, 0, 1){};
MyCsr(ExecutionEnvironment &executionEnvironment) : CommandStreamReceiverHw<Gen12LpFamily>(executionEnvironment, 0, 1){};
CsrSizeRequestFlags *getCsrRequestFlags() { return &csrSizeRequestFlags; }
};
@@ -44,7 +44,7 @@ struct Gen12LpCoherencyRequirements : public ::testing::Test {
void SetUp() override {
device.reset(MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get()));
csr = new myCsr(*device->executionEnvironment);
csr = new MyCsr(*device->executionEnvironment);
device->resetCommandStreamReceiver(csr);
AllocationProperties properties(device->getRootDeviceIndex(), false, MemoryConstants::pageSize, AllocationType::SHARED_BUFFER, false, {});
@@ -55,7 +55,7 @@ struct Gen12LpCoherencyRequirements : public ::testing::Test {
device->getMemoryManager()->freeGraphicsMemory(alloc);
}
myCsr *csr = nullptr;
MyCsr *csr = nullptr;
std::unique_ptr<MockDevice> device;
DispatchFlags flags = DispatchFlagsHelper::createDefaultDispatchFlags();
GraphicsAllocation *alloc = nullptr;

8
shared/test/unit_test/helpers/basic_math_tests.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -124,7 +124,7 @@ INSTANTIATE_TEST_CASE_P(Float2Half,
Float2HalfTest,
::testing::ValuesIn(float2HalfParams));
struct l3Config {
struct L3Config {
union {
unsigned int RawValue;
struct {
@@ -141,7 +141,7 @@ struct l3Config {
};
TEST(l3configsGenerator, givenInputValuesWhenPassedToL3ConfigThenRawValueIsProduced) {
l3Config config;
L3Config config;
config.bits = {
0, // SLM Enabled
0x30, // URB Allocation
@@ -154,7 +154,7 @@ TEST(l3configsGenerator, givenInputValuesWhenPassedToL3ConfigThenRawValueIsProdu
EXPECT_EQ(config.RawValue, 0x60000160u);
l3Config config2;
L3Config config2;
config2.RawValue = 0x80000140u;
EXPECT_EQ(0x40u, config2.bits.AllL3WayAssignement);
EXPECT_EQ(0x20u, config2.bits.UrbAllocation);

4
shared/test/unit_test/os_interface/linux/drm_command_stream_tests_1.cpp
View File

@@ -461,7 +461,7 @@ HWTEST_TEMPLATED_F(DrmCommandStreamBatchingTests, givenCsrWhenDispatchPolicyIsSe
csr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
auto testedCsr = static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr);
testedCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
testedCsr->useNewResourceImplicitFlush = false;
@@ -528,7 +528,7 @@ HWTEST_TEMPLATED_F(DrmCommandStreamBatchingTests, givenRecordedCommandBufferWhen
mock->reset();
csr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
auto testedCsr = static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr);
testedCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
testedCsr->useNewResourceImplicitFlush = false;

8
shared/test/unit_test/os_interface/linux/drm_gem_close_worker_tests.cpp
View File

@@ -163,24 +163,24 @@ TEST_F(DrmGemCloseWorkerTests, givenAllocationWhenAskedForUnreferenceWithForceFl
}
TEST_F(DrmGemCloseWorkerTests, givenDrmGemCloseWorkerWhenCloseIsCalledWithBlockingFlagThenThreadIsClosed) {
struct mockDrmGemCloseWorker : DrmGemCloseWorker {
struct MockDrmGemCloseWorker : DrmGemCloseWorker {
using DrmGemCloseWorker::DrmGemCloseWorker;
using DrmGemCloseWorker::thread;
};
std::unique_ptr<mockDrmGemCloseWorker> worker(new mockDrmGemCloseWorker(*mm));
std::unique_ptr<MockDrmGemCloseWorker> worker(new MockDrmGemCloseWorker(*mm));
EXPECT_NE(nullptr, worker->thread);
worker->close(true);
EXPECT_EQ(nullptr, worker->thread);
}
TEST_F(DrmGemCloseWorkerTests, givenDrmGemCloseWorkerWhenCloseIsCalledMultipleTimeWithBlockingFlagThenThreadIsClosed) {
struct mockDrmGemCloseWorker : DrmGemCloseWorker {
struct MockDrmGemCloseWorker : DrmGemCloseWorker {
using DrmGemCloseWorker::DrmGemCloseWorker;
using DrmGemCloseWorker::thread;
};
std::unique_ptr<mockDrmGemCloseWorker> worker(new mockDrmGemCloseWorker(*mm));
std::unique_ptr<MockDrmGemCloseWorker> worker(new MockDrmGemCloseWorker(*mm));
worker->close(true);
worker->close(true);
worker->close(true);

2
shared/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp
View File

@@ -2135,7 +2135,7 @@ TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerWhenUnlockResourceIsCalledOnAl
unlockResourceInLocalMemoryImplParam.bo = bo;
unlockResourceInLocalMemoryImplParam.called = true;
}
struct unlockResourceInLocalMemoryImplParamType {
struct UnlockResourceInLocalMemoryImplParamType {
BufferObject *bo = nullptr;
bool called = false;
} unlockResourceInLocalMemoryImplParam;

2
shared/test/unit_test/os_interface/windows/device_command_stream_tests.cpp
View File

@@ -888,7 +888,7 @@ HWTEST_TEMPLATED_F(WddmCommandStreamMockGdiTest, givenRecordedCommandBufferWhenI
mockCsr->useNewResourceImplicitFlush = false;
mockCsr->useGpuIdleImplicitFlush = false;
auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
auto mockedSubmissionsAggregator = new MockSubmissionsAggregator();
mockCsr->overrideSubmissionAggregator(mockedSubmissionsAggregator);
auto commandBuffer = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{mockCsr->getRootDeviceIndex(), MemoryConstants::pageSize});